@simbimbo/memory-ocmemog 0.1.10 → 0.1.12

package/scripts/ocmemog-release-check.sh

@@ -0,0 +1,330 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+PYTHON_BIN="${OCMEMOG_PYTHON_BIN:-}"
+if [[ -z "${PYTHON_BIN}" ]]; then
+  if [[ -x ".venv/bin/python3" ]]; then
+    PYTHON_BIN=".venv/bin/python3"
+  else
+    PYTHON_BIN="$(command -v python3)"
+  fi
+fi
+if [[ -z "${PYTHON_BIN}" ]] || ! command -v "${PYTHON_BIN}" >/dev/null 2>&1; then
+  echo "A python executable could not be found. Set OCMEMOG_PYTHON_BIN to a valid interpreter path."
+  exit 1
+fi
+
+BROAD_TEST_FILES=(
+  tests/test_sidecar_routes.py
+  tests/test_regressions.py
+  tests/test_pondering_engine.py
+  tests/test_doctor.py
+  tests/test_governance_queue.py
+  tests/test_promotion_governance_integration.py
+  tests/test_hybrid_retrieval.py
+)
+LIVE_CHECK_URL="${OCMEMOG_RELEASE_LIVE_ENDPOINT:-http://127.0.0.1:17891}"
+PROOF_REPORT_DIR="${OCMEMOG_RELEASE_PROOF_DIR:-${ROOT_DIR}/reports}"
+PROOF_REPORT_FILE="${PROOF_REPORT_DIR}/release-gate-proof.json"
+PROOF_LEGACY_ENDPOINT="${OCMEMOG_RELEASE_LEGACY_ENDPOINT:-}"
+LIVE_STATE_DIR="$(mktemp -d -t ocmemog-release-live-XXXXXX)"
+DOCTOR_STATE_DIR="$(mktemp -d -t ocmemog-release-doctor-XXXXXX)"
+mkdir -p "$PROOF_REPORT_DIR"
+trap 'rm -rf "$DOCTOR_STATE_DIR" "$LIVE_STATE_DIR"' EXIT
+
+STATUS=0
+
+run_step() {
+  local label="$1"
+  shift
+  echo
+  echo "[ocmemog-release-check] ${label}"
+  if "$@"; then
+    echo "[PASS] ${label}"
+  else
+    local rc=$?
+    STATUS=1
+    echo "[FAIL] ${label} (status=${rc})"
+    return $rc
+  fi
+}
+
+run_optional_step() {
+  local label="$1"
+  shift
+  echo
+  echo "[ocmemog-release-check] ${label}"
+  if "$@"; then
+    :
+  else
+    echo "[WARN] ${label}: command reported a non-blocking warning"
+  fi
+}
+
+run_step "Verifying shell script syntax" \
+  bash -n scripts/install-ocmemog.sh \
+  && bash -n scripts/ocmemog-install.sh
+
+run_step "Checking installer command surfaces" \
+  ./scripts/install-ocmemog.sh --help \
+  && ./scripts/install-ocmemog.sh --dry-run
+
+run_step "Running strict doctor checks against temporary state" \
+  "$PYTHON_BIN" scripts/ocmemog-doctor.py \
+    --json \
+    --strict \
+    --state-dir "$DOCTOR_STATE_DIR" \
+    --check runtime/imports \
+    --check state/path-writable \
+    --check sqlite/schema-access \
+    --check queue/health \
+    --check sidecar/env-toggles \
+    --check sidecar/app-import
+
+run_optional_step "Running transcript-root diagnostics (non-blocking)" \
+  bash -c '
+    if "$0" scripts/ocmemog-doctor.py \
+      --json \
+      --state-dir "$1" \
+      --check sidecar/transcript-roots; then
+      :
+    else
+      rc=$?
+      if [[ "$rc" -eq 1 ]]; then
+        echo "transcript-root diagnostics reported warning."
+      elif [[ "$rc" -eq 2 ]]; then
+        echo "transcript-root diagnostics reported failure-level issue."
+      else
+        echo "transcript-root diagnostics exited with unexpected status ${rc}."
+      fi
+    fi
+' "${PYTHON_BIN}" "$DOCTOR_STATE_DIR"
+
+run_optional_step "Running optional runtime probe (non-blocking warning)" \
+  bash -c '
+    if "$0" scripts/ocmemog-doctor.py --json --state-dir "$1" --check vector/runtime-probe; then
+      :
+    else
+      rc=$?
+      if [[ "$rc" -eq 1 ]]; then
+        echo "runtime probe reports warning-level status (sidecar may be unavailable in this environment)."
+      elif [[ "$rc" -eq 2 ]]; then
+        echo "runtime probe reports fail-level status (likely unavailable in this environment)."
+      else
+        echo "runtime probe exited with unexpected status ${rc}."
+      fi
+    fi
+' "${PYTHON_BIN}" "$DOCTOR_STATE_DIR"
+
+run_step "Checking test dependencies for route tests" \
+  "$PYTHON_BIN" - <<'PY'
+import importlib.util
+
+missing = [
+    name
+    for name in ("pytest", "httpx")
+    if importlib.util.find_spec(name) is None
+]
+if missing:
+    raise SystemExit("missing test dependencies: " + ", ".join(missing))
+PY
+
+run_step "Running broad regression subset" \
+  "$PYTHON_BIN" -m pytest -q "${BROAD_TEST_FILES[@]}"
+
+run_step "Running contract-facing sidecar route tests" \
+  "$PYTHON_BIN" -m pytest -q tests/test_sidecar_routes.py
+
+LIVE_CHECK_ENDPOINT="$LIVE_CHECK_URL"
+export LIVE_CHECK_ENDPOINT
+run_step "Running live /healthz, /memory/ingest and /memory/search smoke checks" \
+  "$PYTHON_BIN" - <<PY
+import os
+import json
+import time
+import uuid
+import urllib.error
+from urllib import request
+
+endpoint = os.environ["LIVE_CHECK_ENDPOINT"].rstrip("/")
+
+def post(path, payload, timeout=10):
+    req = request.Request(
+        f"{endpoint}{path}",
+        data=json.dumps(payload).encode("utf-8"),
+        method="POST",
+    )
+    req.add_header("Content-Type", "application/json")
+    with request.urlopen(req, timeout=timeout) as response:
+        payload = response.read().decode("utf-8")
+    return json.loads(payload)
+
+def get(path, timeout=10):
+    req = request.Request(f"{endpoint}{path}")
+    with request.urlopen(req, timeout=timeout) as response:
+        payload = response.read().decode("utf-8")
+    return json.loads(payload)
+
+def wait_ready(timeout=20):
+    deadline = time.time() + timeout
+    health_payload = {}
+    while time.time() < deadline:
+        try:
+            health = get("/healthz", timeout=3)
+        except Exception:
+            health = None
+        if isinstance(health, dict):
+            health_payload = health
+            if health.get("ok"):
+                if health.get("ready") is False:
+                    print(f"[ocmemog-release-check] healthz degraded mode={health.get('mode')}: continuing smoke checks with warning")
+                    return
+                return
+            # keep probing only for operational OK states
+        time.sleep(0.3)
+    if health_payload:
+        if not isinstance(health_payload, dict) or not health_payload.get("ok"):
+            raise SystemExit(f"healthz did not return ok: {health_payload}")
+        raise SystemExit(f"healthz did not become ready after {timeout}s (mode={health_payload.get('mode')})")
+    raise SystemExit("healthz did not become ready")
+
+def drain_queue():
+    post("/memory/ingest_flush", {"limit": 0}, timeout=10)
+    deadline = time.time() + 10
+    while time.time() < deadline:
+        status = get("/memory/ingest_status", timeout=10)
+        if int(status.get("queueDepth", 0) or 0) <= 0:
+            return
+        time.sleep(0.25)
+    raise SystemExit("post-process queue did not drain")
+
+wait_ready()
+
+conversation_id = f"release-check-{uuid.uuid4().hex}"
+session_id = f"release-check-session-{uuid.uuid4().hex}"
+thread_id = f"release-check-thread-{uuid.uuid4().hex}"
+token = f"release-check-token-{uuid.uuid4().hex}"
+
+ingest = post(
+    "/memory/ingest",
+    {
+        "content": f"{token} for release gate verification",
+        "kind": "memory",
+        "memory_type": "knowledge",
+        "conversation_id": conversation_id,
+        "session_id": session_id,
+        "thread_id": thread_id,
+    },
+    timeout=20,
+)
+if not ingest.get("ok") or "reference" not in ingest:
+    raise SystemExit("memory ingest endpoint failed")
+reference = str(ingest.get("reference"))
+
+# /memory/ingest is synchronous for the core write; async post-processing may settle later.
+search = post("/memory/search", {"query": token, "limit": 2}, timeout=20)
+if not search.get("ok"):
+    raise SystemExit("memory search endpoint failed")
+results = list(search.get("results") or [])
+if not results:
+    raise SystemExit("memory search returned no results")
+if len(results) > 2:
+    raise SystemExit("memory search returned unbounded results")
+if not any(str(item.get("reference") or "") == reference for item in results):
+    raise SystemExit("memory search did not recall inserted memory reference")
+
+get_response = post("/memory/get", {"reference": reference}, timeout=15)
+if not get_response.get("ok"):
+    raise SystemExit("memory get endpoint failed")
+if token not in str(get_response.get("memory", {}).get("content") or ""):
+    raise SystemExit("memory get response did not include ingested content")
+
+hydrate = post(
+    "/conversation/hydrate",
+    {
+        "conversation_id": conversation_id,
+        "session_id": session_id,
+        "thread_id": thread_id,
+        "turns_limit": 2,
+        "memory_limit": 2,
+    },
+    timeout=20,
+)
+if not hydrate.get("ok"):
+    raise SystemExit("conversation hydrate endpoint failed")
+if len(hydrate.get("linked_memories") or []) > 2:
+    raise SystemExit("conversation hydrate did not compact linked memories")
+print(json.dumps({"health": True, "reference": reference, "search_count": len(results)}, sort_keys=True))
+PY
+
+run_step "Running integrated OpenClaw memory contract proof (fresh-state)" \
+  bash -lc '
+    set -e
+    cd "$1"
+    "$2" scripts/ocmemog-integrated-proof.py \
+      --start-sidecar \
+      --endpoint "$3" \
+      --state-dir "$4" \
+      --timeout 180 \
+      ${5:+--legacy-endpoint "$5"} \
+      >"$6" 2>"$6.stderr"
+  ' -- \
+  "$ROOT_DIR" "$PYTHON_BIN" "$LIVE_CHECK_URL" "$LIVE_STATE_DIR" "$PROOF_LEGACY_ENDPOINT" "$PROOF_REPORT_FILE"
+
+run_step "Validating proof output" \
+  "$PYTHON_BIN" - <<PY
+import json
+from pathlib import Path
+
+try:
+    payload = json.loads(Path("$PROOF_REPORT_FILE").read_text(encoding="utf-8"))
+except FileNotFoundError:
+    raise SystemExit("proof output file was not produced")
+except json.JSONDecodeError as exc:
+    raise SystemExit(f"proof output invalid JSON: {exc}")
+
+if not payload.get("ingest_ok"):
+    raise SystemExit("proof ingest check failed")
+if not payload.get("search_ok"):
+    raise SystemExit("proof search check failed")
+if not payload.get("get_ok"):
+    raise SystemExit("proof get check failed")
+if not payload.get("hydrate_ok"):
+    raise SystemExit("proof hydrate check failed")
+if int(payload.get("search_count") or 0) > 2:
+    raise SystemExit("proof search_count must be capped")
+if int(payload.get("linked_count") or 0) > 2:
+    raise SystemExit("proof linked_count must be compact")
+if "reference" not in payload:
+    raise SystemExit("proof missing reference")
+json.dumps(payload, sort_keys=True)
+PY
+
+run_optional_step "Checking npm pack --dry-run (non-blocking)" \
+  bash -c "cd \"$ROOT_DIR\" && npm pack --dry-run"
+
+run_step "Running package and syntax proofs" \
+  "$PYTHON_BIN" - <<'PY'
+import json
+from pathlib import Path
+
+json.loads(Path("package.json").read_text(encoding="utf-8"))
+
+for candidate in sorted(Path("ocmemog").rglob("*.py")):
+    compile(candidate.read_text(encoding="utf-8"), str(candidate), "exec")
+
+for candidate in sorted(Path("scripts").glob("*.py")):
+    compile(candidate.read_text(encoding="utf-8"), str(candidate), "exec")
+PY
+
+echo
+if [[ "$STATUS" -ne 0 ]]; then
+  echo "[ocmemog-release-check] RELEASE CHECK FAILED"
+  exit 1
+fi
+
+echo "[ocmemog-release-check] RELEASE CHECK PASSED"
+echo "[ocmemog-release-check] Proof report: $PROOF_REPORT_FILE"

package/scripts/ocmemog-sidecar.sh

@@ -40,8 +40,10 @@ export OCMEMOG_LOCAL_EMBED_MODEL="${OCMEMOG_LOCAL_EMBED_MODEL:-nomic-embed-text-
 export OCMEMOG_OLLAMA_MODEL="${OCMEMOG_OLLAMA_MODEL:-qwen2.5:7b}"
 export OCMEMOG_OLLAMA_EMBED_MODEL="${OCMEMOG_OLLAMA_EMBED_MODEL:-nomic-embed-text:latest}"
 export OCMEMOG_PONDER_MODEL="${OCMEMOG_PONDER_MODEL:-local-openai:qwen2.5-7b-instruct}"
-export BRAIN_EMBED_MODEL_PROVIDER="${BRAIN_EMBED_MODEL_PROVIDER:-local-openai}"
-export BRAIN_EMBED_MODEL_LOCAL="${BRAIN_EMBED_MODEL_LOCAL:-}"
+export OCMEMOG_EMBED_MODEL_PROVIDER="${OCMEMOG_EMBED_MODEL_PROVIDER:-${BRAIN_EMBED_MODEL_PROVIDER:-local-openai}}"
+export OCMEMOG_EMBED_MODEL_LOCAL="${OCMEMOG_EMBED_MODEL_LOCAL:-${BRAIN_EMBED_MODEL_LOCAL:-}}"
+export BRAIN_EMBED_MODEL_PROVIDER="${BRAIN_EMBED_MODEL_PROVIDER:-${OCMEMOG_EMBED_MODEL_PROVIDER}}"
+export BRAIN_EMBED_MODEL_LOCAL="${BRAIN_EMBED_MODEL_LOCAL:-${OCMEMOG_EMBED_MODEL_LOCAL}}"
 
 # battery-aware transcript watcher defaults
 export OCMEMOG_TRANSCRIPT_WATCHER="${OCMEMOG_TRANSCRIPT_WATCHER:-true}"

package/scripts/ocmemog-test-rig.py

@@ -152,8 +152,10 @@ def _distill_batches(endpoint: str, target: int, batch_sizes: list[int], timeout
 
 
 def _enable_local_embeddings() -> None:
-    os.environ.setdefault("BRAIN_EMBED_MODEL_LOCAL", "")
-    os.environ.setdefault("BRAIN_EMBED_MODEL_PROVIDER", "local-openai")
+    os.environ.setdefault("OCMEMOG_EMBED_MODEL_LOCAL", "")
+    os.environ.setdefault("OCMEMOG_EMBED_MODEL_PROVIDER", "local-openai")
+    os.environ.setdefault("BRAIN_EMBED_MODEL_LOCAL", os.environ["OCMEMOG_EMBED_MODEL_LOCAL"])
+    os.environ.setdefault("BRAIN_EMBED_MODEL_PROVIDER", os.environ["OCMEMOG_EMBED_MODEL_PROVIDER"])
     os.environ.setdefault("OCMEMOG_LOCAL_EMBED_BASE_URL", "http://127.0.0.1:18081/v1")
     os.environ.setdefault("OCMEMOG_LOCAL_EMBED_MODEL", "nomic-embed-text-v1.5")
 
@@ -268,7 +270,7 @@ def main() -> int:
     ponder_summary = {}
     research_summary = {}
     try:
-        from brain.runtime.memory import promote, store, pondering_engine, memory_synthesis, semantic_search
+        from ocmemog.runtime.memory import promote, store, pondering_engine, memory_synthesis, semantic_search
 
         conn = store.connect()
         rows = conn.execute(

package/brain/runtime/memory/artifacts.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Dict, Any
-
-from brain.runtime import state_store
-from brain.runtime.memory import store
-
-
-def _artifact_dir() -> Path:
-    path = state_store.memory_dir() / "artifacts"
-    path.mkdir(parents=True, exist_ok=True)
-    return path
-
-
-def store_artifact(artifact_id: str, content: bytes, metadata: Dict[str, Any]) -> Path:
-    path = _artifact_dir() / f"{artifact_id}.bin"
-    path.write_bytes(content)
-    content_hash = str(hash(content))
-    conn = store.connect()
-    conn.execute(
-        "INSERT INTO artifacts (artifact_id, artifact_type, source_path, content_hash, metadata) VALUES (?, ?, ?, ?, ?)",
-        (artifact_id, metadata.get("artifact_type", "unknown"), metadata.get("source_path", ""), content_hash, json.dumps(metadata)),
-    )
-    conn.commit()
-    conn.close()
-    return path
-
-
-def load_artifact(artifact_id: str) -> bytes:
-    path = _artifact_dir() / f"{artifact_id}.bin"
-    return path.read_bytes()

package/brain/runtime/memory/context_builder.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import re
-from typing import Any, Dict, List
-
-from brain.runtime.instrumentation import emit_event
-from brain.runtime import state_store, inference
-from brain.runtime.memory import retrieval
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def _heuristic_queries(prompt: str, limit: int = 3) -> List[str]:
-    cleaned = re.sub(r"\s+", " ", prompt or "").strip()
-    parts = re.split(r",| and | then | also ", cleaned)
-    queries = []
-    for part in parts:
-        q = part.strip(" .")
-        if len(q) >= 8 and q.lower() not in {cleaned.lower()}:
-            queries.append(q)
-    if cleaned and cleaned not in queries:
-        queries.insert(0, cleaned)
-    deduped: List[str] = []
-    seen = set()
-    for q in queries:
-        key = q.lower()
-        if key in seen:
-            continue
-        seen.add(key)
-        deduped.append(q)
-        if len(deduped) >= limit:
-            break
-    return deduped
-
-
-def _should_skip_query_grooming(prompt: str) -> bool:
-    cleaned = re.sub(r"\s+", " ", prompt or "").strip()
-    if not cleaned:
-        return True
-    if len(cleaned) <= 32 and ',' not in cleaned and ' and ' not in cleaned.lower():
-        return True
-    words = cleaned.split()
-    if 1 <= len(words) <= 5 and all(len(w) >= 3 for w in words):
-        return True
-    return False
-
-
-def _groom_queries(prompt: str, limit: int = 3) -> List[str]:
-    cleaned = re.sub(r"\s+", " ", prompt or "").strip()
-    if not cleaned:
-        return []
-    if _should_skip_query_grooming(cleaned):
-        return _heuristic_queries(cleaned, limit=limit)
-    model = os.environ.get("OCMEMOG_PONDER_MODEL", "local-openai:qwen2.5-7b-instruct")
-    ask = (
-        "Rewrite this raw memory request into up to 3 short search queries. "
-        "Return strict JSON as {\"queries\":[\"...\"]}. "
-        "Prefer compact entity/topic phrases, not full sentences.\n\n"
-        f"Request: {cleaned}\n"
-    )
-    try:
-        result = inference.infer(ask, provider_name=model)
-    except Exception:
-        return _heuristic_queries(cleaned, limit=limit)
-    if result.get("status") != "ok":
-        return _heuristic_queries(cleaned, limit=limit)
-    output = str(result.get("output") or "").strip()
-    try:
-        payload = json.loads(output)
-        raw_queries = payload.get("queries") or []
-        queries = [str(q).strip() for q in raw_queries if str(q).strip()]
-    except Exception:
-        queries = []
-    cleaned_queries: List[str] = []
-    seen = set()
-    for q in queries:
-        key = q.lower()
-        if len(q) < 4 or key in seen:
-            continue
-        seen.add(key)
-        cleaned_queries.append(q)
-        if len(cleaned_queries) >= limit:
-            break
-    return cleaned_queries or _heuristic_queries(cleaned, limit=limit)
-
-
-def build_context(prompt: str, memory_queries: List[str] | None = None, limit: int = 5) -> Dict[str, Any]:
-    emit_event(LOGFILE, "brain_memory_context_build_start", status="ok")
-    queries = memory_queries or _groom_queries(prompt, limit=3)
-    memories: List[Dict[str, Any]] = []
-    seen: set[str] = set()
-    for query in queries:
-        for item in retrieval.retrieve_memories(query, limit=limit):
-            ref = str(item.get("reference") or item.get("id") or "")
-            if ref and ref in seen:
-                continue
-            if ref:
-                seen.add(ref)
-            memories.append(item)
-            if len(memories) >= limit:
-                break
-        if len(memories) >= limit:
-            break
-
-    emit_event(LOGFILE, "brain_memory_context_build_complete", status="ok", item_count=len(memories), query_count=len(queries))
-    return {
-        "prompt": prompt,
-        "queries": queries,
-        "memories": memories,
-    }

package/brain/runtime/memory/interaction_memory.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-import time
-from typing import Dict, List
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import person_memory
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def _connect() -> sqlite3.Connection:
-    path = state_store.data_dir() / "interaction_memory.db"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(path))
-    conn.row_factory = sqlite3.Row
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS interaction_memory (
-            interaction_id INTEGER PRIMARY KEY AUTOINCREMENT,
-            person_id TEXT,
-            timestamp TEXT,
-            channel TEXT,
-            thread_id TEXT,
-            sentiment TEXT,
-            outcome TEXT
-        )
-        """
-    )
-    return conn
-
-
-def record_interaction(person_id: str, channel: str, thread_id: str, sentiment: str, outcome: str) -> None:
-    conn = _connect()
-    conn.execute(
-        "INSERT INTO interaction_memory (person_id, timestamp, channel, thread_id, sentiment, outcome) VALUES (?, ?, ?, ?, ?, ?)",
-        (person_id, time.strftime("%Y-%m-%d %H:%M:%S"), channel, thread_id, sentiment, outcome[:80]),
-    )
-    conn.commit()
-    conn.close()
-    person_memory.update_person(
-        person_id,
-        {"interaction_count": (person_memory.get_person(person_id) or {}).get("interaction_count", 0) + 1, "last_seen": time.strftime("%Y-%m-%d %H:%M:%S")},
-    )
-    emit_event(LOGFILE, "brain_person_interaction_recorded", status="ok", person_id=person_id)
-
-
-def get_recent_interactions(person_id: str, limit: int = 10) -> List[Dict[str, object]]:
-    conn = _connect()
-    rows = conn.execute(
-        "SELECT timestamp, channel, thread_id, sentiment, outcome FROM interaction_memory WHERE person_id=? ORDER BY timestamp DESC LIMIT ?",
-        (person_id, limit),
-    ).fetchall()
-    conn.close()
-    return [dict(row) for row in rows]

package/brain/runtime/memory/memory_gate.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Dict
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-DIRECT_THRESHOLD = float(os.environ.get("BRAIN_MEMORY_GATE_DIRECT", 1.5))
-ASSIST_THRESHOLD = float(os.environ.get("BRAIN_MEMORY_GATE_ASSIST", 0.8))
-
-
-def decide_gate(result: Dict[str, float]) -> Dict[str, float | str]:
-    similarity = float(result.get("similarity", result.get("score", 0.0)))
-    reinforcement = float(result.get("reinforcement_weight", 0.0))
-    freshness = float(result.get("freshness", 0.0))
-    promotion = float(result.get("promotion_confidence", 0.0))
-    score = similarity + reinforcement + freshness + promotion
-    if score >= DIRECT_THRESHOLD:
-        decision = "memory_direct"
-    elif score >= ASSIST_THRESHOLD:
-        decision = "memory_assisted"
-    else:
-        decision = "model_escalation"
-    payload = {
-        "decision": decision,
-        "score": round(score, 3),
-        "similarity": similarity,
-        "reinforcement_weight": reinforcement,
-        "freshness": freshness,
-        "promotion_confidence": promotion,
-        "salience_score": float(result.get("salience_score", 0.0)),
-    }
-    emit_event(LOGFILE, "brain_memory_gate_decision", status="ok", decision=decision, score=round(score, 3))
-    emit_event(LOGFILE, "brain_memory_gate_score", status="ok", score=round(score, 3))
-    return payload

package/brain/runtime/memory/memory_graph.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import sqlite3
-from typing import Dict, List
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def _connect() -> sqlite3.Connection:
-    path = state_store.data_dir() / "memory_graph.db"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(path))
-    conn.row_factory = sqlite3.Row
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS memory_graph (
-            source_reference TEXT NOT NULL,
-            edge_type TEXT NOT NULL,
-            target_reference TEXT NOT NULL,
-            created_at TEXT NOT NULL DEFAULT (datetime('now')),
-            UNIQUE(source_reference, edge_type, target_reference)
-        )
-        """
-    )
-    return conn
-
-
-def add_memory_edge(source_reference: str, edge_type: str, target_reference: str) -> None:
-    conn = _connect()
-    conn.execute(
-        "INSERT OR IGNORE INTO memory_graph (source_reference, edge_type, target_reference) VALUES (?, ?, ?)",
-        (source_reference, edge_type, target_reference),
-    )
-    conn.commit()
-    conn.close()
-    emit_event(LOGFILE, "brain_memory_graph_edge_created", status="ok", edge_type=edge_type)
-
-
-def get_neighbors(source_reference: str) -> List[Dict[str, str]]:
-    conn = _connect()
-    rows = conn.execute(
-        "SELECT edge_type, target_reference FROM memory_graph WHERE source_reference=?",
-        (source_reference,),
-    ).fetchall()
-    conn.close()
-    return [{"edge_type": row[0], "target_reference": row[1]} for row in rows]
-
-
-def get_cluster(source_reference: str, limit: int = 5) -> List[str]:
-    neighbors = get_neighbors(source_reference)
-    return [item["target_reference"] for item in neighbors[:limit]]