@simbimbo/memory-ocmemog 0.1.11 → 0.1.13

package/brain/runtime/memory/integrity.py

@@ -1,188 +1,3 @@
 from __future__ import annotations
 
-from typing import Dict, Any, List
-
-from brain.runtime.instrumentation import emit_event
-from brain.runtime import state_store
-from brain.runtime.memory import store
-
-
-EMBED_TABLES = tuple(store.MEMORY_TABLES)
-
-
-def run_integrity_check() -> Dict[str, Any]:
-    emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_start", status="ok")
-    conn = store.connect()
-    issues: List[str] = []
-    repairable: List[str] = []
-    sqlite_ok = True
-
-    # required tables
-    required = {
-        "experiences",
-        "knowledge",
-        "preferences",
-        "identity",
-        "reflections",
-        "tasks",
-        "directives",
-        "promotions",
-        "candidates",
-        "memory_index",
-        "vector_embeddings",
-        "runbooks",
-        "lessons",
-    }
-    tables = {row[0] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
-    missing = required - tables
-    if missing:
-        issues.append(f"missing_tables:{','.join(sorted(missing))}")
-        emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_issue", status="warn")
-
-    # orphan candidates (source_event_id missing in experiences)
-    try:
-        orphan = conn.execute(
-            "SELECT COUNT(*) FROM candidates WHERE source_event_id NOT IN (SELECT id FROM experiences)",
-        ).fetchone()[0]
-        if orphan:
-            issues.append(f"orphan_candidates:{orphan}")
-            emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_issue", status="warn")
-    except Exception:
-        pass
-
-    # duplicate promotions
-    try:
-        dup_groups = conn.execute(
-            "SELECT COUNT(*) FROM (SELECT 1 FROM promotions GROUP BY source, content HAVING COUNT(*) > 1)",
-        ).fetchone()[0]
-        if dup_groups:
-            issues.append(f"duplicate_promotions:{dup_groups}")
-            emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_issue", status="warn")
-    except Exception:
-        pass
-
-    # reinforcement references missing
-    try:
-        missing_ref = conn.execute(
-            "SELECT COUNT(*) FROM experiences WHERE memory_reference IS NULL OR memory_reference = ''",
-        ).fetchone()[0]
-        if missing_ref:
-            issues.append(f"missing_memory_reference:{missing_ref}")
-            repairable.append("missing_memory_reference")
-            emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_issue", status="warn")
-    except Exception:
-        pass
-
-    # vector index mismatch (knowledge/runbooks/lessons vs vector_embeddings)
-    missing_vectors = 0
-    orphan_vectors = 0
-    try:
-        for table in EMBED_TABLES:
-            missing_vectors += conn.execute(
-                f"SELECT COUNT(*) FROM {table} WHERE id NOT IN (SELECT CAST(source_id AS INTEGER) FROM vector_embeddings WHERE source_type=?)",
-                (table,),
-            ).fetchone()[0]
-    except Exception:
-        pass
-
-    try:
-        for table in EMBED_TABLES:
-            orphan_vectors += conn.execute(
-                "SELECT COUNT(*) FROM vector_embeddings WHERE source_type=? AND CAST(source_id AS INTEGER) NOT IN (SELECT id FROM %s)"
-                % table,
-                (table,),
-            ).fetchone()[0]
-    except Exception:
-        pass
-
-    if missing_vectors:
-        issues.append(f"vector_missing:{missing_vectors}")
-        emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_vector_integrity_issue", status="warn")
-
-    if orphan_vectors:
-        issues.append(f"vector_orphan:{orphan_vectors}")
-        repairable.append("vector_orphan")
-        emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_vector_integrity_issue", status="warn")
-
-    try:
-        quick_check = conn.execute("PRAGMA quick_check(1)").fetchone()
-        quick_value = str((quick_check or ["ok"])[0] or "ok")
-        if quick_value.lower() != "ok":
-            sqlite_ok = False
-            issues.append(f"sqlite_quick_check:{quick_value}")
-            emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_issue", status="warn")
-    except Exception:
-        sqlite_ok = False
-
-    warning_type = ""
-    warning_summary = ""
-    for issue in issues:
-        if issue.startswith("vector_missing"):
-            warning_type = "vector_missing"
-            warning_summary = "Vector embeddings missing entries"
-            break
-        if issue.startswith("vector_orphan"):
-            warning_type = "vector_orphan"
-            warning_summary = "Vector embeddings have orphan entries"
-            break
-
-    conn.close()
-    emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_complete", status="ok")
-    return {
-        "issues": issues,
-        "ok": len(issues) == 0 and sqlite_ok,
-        "warning_type": warning_type,
-        "warning_summary": warning_summary,
-        "repairable_issues": repairable,
-        "sqlite_ok": sqlite_ok,
-    }
-
-
-def repair_integrity() -> Dict[str, Any]:
-    repaired: List[str] = []
-
-    def _write() -> Dict[str, Any]:
-        conn = store.connect()
-        removed_orphans = 0
-        repaired_missing_refs = 0
-        try:
-            tables = {row[0] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
-            if "vector_embeddings" in tables:
-                for table in EMBED_TABLES:
-                    if table not in tables:
-                        continue
-                    removed_orphans += conn.execute(
-                        f"""
-                        DELETE FROM vector_embeddings
-                        WHERE source_type = ?
-                          AND NOT EXISTS (
-                            SELECT 1 FROM {table} source
-                            WHERE source.id = CAST(vector_embeddings.source_id AS INTEGER)
-                          )
-                        """,
-                        (table,),
-                    ).rowcount
-            if "experiences" in tables:
-                repaired_missing_refs += conn.execute(
-                    """
-                    UPDATE experiences
-                    SET memory_reference = 'legacy:' || COALESCE(experience_type, 'unknown') || ':' || id
-                    WHERE memory_reference IS NULL OR memory_reference = ''
-                    """
-                ).rowcount
-            conn.commit()
-            return {
-                "removed_orphan_vectors": int(removed_orphans),
-                "repaired_missing_memory_references": int(repaired_missing_refs),
-            }
-        finally:
-            conn.close()
-
-    result = store.submit_write(_write, timeout=30.0)
-    if int(result.get("removed_orphan_vectors") or 0) > 0:
-        repaired.append(f"vector_orphan:{int(result['removed_orphan_vectors'])}")
-        emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_repair", status="ok", repaired="vector_orphan", count=int(result["removed_orphan_vectors"]))
-    if int(result.get("repaired_missing_memory_references") or 0) > 0:
-        repaired.append(f"missing_memory_reference:{int(result['repaired_missing_memory_references'])}")
-        emit_event(state_store.reports_dir() / "brain_memory.log.jsonl", "brain_memory_integrity_repair", status="ok", repaired="missing_memory_reference", count=int(result["repaired_missing_memory_references"]))
-    return {"ok": True, "repaired": repaired, **result}
+from ocmemog.runtime.memory.integrity import *  # noqa: F401,F403

package/brain/runtime/memory/memory_consolidation.py

@@ -1,60 +1,3 @@
 from __future__ import annotations
 
-from typing import Dict, List, Tuple
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import memory_taxonomy
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def _cluster_key(record: Dict[str, object]) -> Tuple[str, str]:
-    mem_type = memory_taxonomy.classify_memory_type(record)
-    content = str(record.get("content") or "")
-    anchor = content[:48].lower()
-    return mem_type, anchor
-
-
-def consolidate_memories(records: List[Dict[str, object]], max_clusters: int = 5) -> Dict[str, object]:
-    emit_event(LOGFILE, "brain_memory_consolidation_start", status="ok")
-    clusters: Dict[Tuple[str, str], List[Dict[str, object]]] = {}
-    for record in records:
-        content = str(record.get("content") or "").strip()
-        if not content:
-            continue
-        key = _cluster_key(record)
-        clusters.setdefault(key, []).append(record)
-        if len(clusters) >= max_clusters:
-            break
-    consolidated: List[Dict[str, object]] = []
-    reinforcement_updates: List[Dict[str, object]] = []
-    for key, items in clusters.items():
-        mem_type, anchor = key
-        summary = f"{mem_type} cluster: {anchor}"
-        references = [str(item.get("reference") or "") for item in items if str(item.get("reference") or "")]
-        consolidated.append(
-            {
-                "memory_type": mem_type,
-                "summary": summary,
-                "count": len(items),
-                "references": references,
-                "candidate_kinds": sorted({str(item.get("candidate_kind") or "memory") for item in items}),
-            }
-        )
-        reinforcement_updates.append(
-            {
-                "memory_type": mem_type,
-                "weight": min(1.0, len(items) / 5.0),
-                "references": references,
-            }
-        )
-        emit_event(
-            LOGFILE,
-            "brain_memory_consolidation_cluster",
-            status="ok",
-            memory_type=mem_type,
-            count=len(items),
-        )
-    emit_event(LOGFILE, "brain_memory_consolidation_complete", status="ok", cluster_count=len(consolidated))
-    return {"consolidated": consolidated, "reinforcement": reinforcement_updates}
+from ocmemog.runtime.memory.memory_consolidation import *  # noqa: F401,F403

package/brain/runtime/memory/memory_links.py

@@ -1,109 +1,3 @@
 from __future__ import annotations
 
-import sqlite3
-from typing import Dict, List
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import store
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def _dedupe_memory_links(conn) -> None:
-    conn.execute(
-        """
-        DELETE FROM memory_links
-        WHERE rowid NOT IN (
-            SELECT MIN(rowid)
-            FROM memory_links
-            GROUP BY source_reference, link_type, target_reference
-        )
-        """
-    )
-
-
-def _ensure_table(conn) -> None:
-    conn.execute(
-        """
-        CREATE TABLE IF NOT EXISTS memory_links (
-            source_reference TEXT NOT NULL,
-            link_type TEXT NOT NULL,
-            target_reference TEXT NOT NULL,
-            created_at TEXT NOT NULL DEFAULT (datetime('now')),
-            UNIQUE(source_reference, link_type, target_reference)
-        )
-        """
-    )
-    try:
-        conn.execute(
-            "CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_links_unique ON memory_links(source_reference, link_type, target_reference)"
-        )
-    except sqlite3.IntegrityError:
-        _dedupe_memory_links(conn)
-        conn.execute("DROP INDEX IF EXISTS idx_memory_links_unique")
-        conn.execute(
-            "CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_links_unique ON memory_links(source_reference, link_type, target_reference)"
-        )
-        conn.commit()
-
-
-def add_memory_link(source_reference: str, link_type: str, target_reference: str) -> None:
-    conn = store.connect()
-    _ensure_table(conn)
-    conn.execute(
-        "INSERT OR IGNORE INTO memory_links (source_reference, link_type, target_reference) VALUES (?, ?, ?)",
-        (source_reference, link_type, target_reference),
-    )
-    conn.commit()
-    conn.close()
-    emit_event(LOGFILE, "brain_memory_link_created", status="ok", link_type=link_type)
-
-
-def get_memory_links(source_reference: str) -> List[Dict[str, str]]:
-    conn = store.connect()
-    _ensure_table(conn)
-    rows = conn.execute(
-        "SELECT link_type, target_reference FROM memory_links WHERE source_reference=?",
-        (source_reference,),
-    ).fetchall()
-    conn.close()
-    return [{"link_type": row[0], "target_reference": row[1]} for row in rows]
-
-
-def get_memory_links_for_target(target_reference: str) -> List[Dict[str, str]]:
-    conn = store.connect()
-    _ensure_table(conn)
-    rows = conn.execute(
-        "SELECT source_reference, link_type, target_reference FROM memory_links WHERE target_reference=? ORDER BY created_at DESC",
-        (target_reference,),
-    ).fetchall()
-    conn.close()
-    return [
-        {
-            "source_reference": row[0],
-            "link_type": row[1],
-            "target_reference": row[2],
-        }
-        for row in rows
-    ]
-
-
-def get_memory_links_for_thread(thread_id: str) -> List[Dict[str, str]]:
-    return get_memory_links_for_target(f"thread:{thread_id}")
-
-
-def get_memory_links_for_session(session_id: str) -> List[Dict[str, str]]:
-    return get_memory_links_for_target(f"session:{session_id}")
-
-
-def get_memory_links_for_conversation(conversation_id: str) -> List[Dict[str, str]]:
-    return get_memory_links_for_target(f"conversation:{conversation_id}")
-
-
-def count_memory_links() -> int:
-    conn = store.connect()
-    _ensure_table(conn)
-    row = conn.execute("SELECT COUNT(*) FROM memory_links").fetchone()
-    conn.close()
-    return int(row[0]) if row else 0
+from ocmemog.runtime.memory.memory_links import *  # noqa: F401,F403

package/brain/runtime/memory/memory_salience.py

@@ -1,235 +1,3 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Mapping, Sequence
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import freshness
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-def score_salience(record: Mapping[str, float]) -> Dict[str, float | bool]:
-    importance = float(record.get("importance", 0.2))
-    novelty = float(record.get("novelty", 0.1))
-    uncertainty = float(record.get("uncertainty", 0.1))
-    risk = float(record.get("risk", 0.0))
-    goal_alignment = float(record.get("goal_alignment", 0.1))
-    reinforcement = float(record.get("reinforcement", 0.0))
-    user_interest = float(record.get("user_interest", 0.0))
-    recency = float(record.get("freshness", 0.0))
-    signal_priority = float(record.get("signal_priority", 0.0))
-    salience_score = max(
-        0.0,
-        min(3.0, importance + novelty + uncertainty + risk + goal_alignment + reinforcement + user_interest + recency + signal_priority),
-    )
-    activation_strength = min(1.0, salience_score / 3.0)
-    attention_trigger = salience_score >= 1.5
-    emit_event(LOGFILE, "brain_memory_salience_scored", status="ok", score=salience_score)
-    emit_event(LOGFILE, "brain_memory_salience_updated", status="ok", score=salience_score)
-    return {
-        "salience_score": round(salience_score, 3),
-        "activation_strength": round(activation_strength, 3),
-        "attention_trigger": attention_trigger,
-    }
-
-
-def _as_float(value: Any, default: float = 0.0) -> float:
-    try:
-        return float(value)
-    except Exception:
-        return default
-
-
-def _content_text(record: Mapping[str, Any]) -> str:
-    return str(record.get("effective_content") or record.get("content") or "").strip()
-
-
-def _normalized_position(record_id: int, *, latest_id: int, earliest_id: int) -> float:
-    if latest_id <= earliest_id:
-        return 1.0
-    return max(0.0, min(1.0, (record_id - earliest_id) / float(latest_id - earliest_id)))
-
-
-def score_turn_salience(
-    turn: Mapping[str, Any],
-    *,
-    latest_turn_id: int | None = None,
-    earliest_turn_id: int | None = None,
-    active_branch_id: str | None = None,
-    reply_chain_turn_ids: Sequence[int] | None = None,
-) -> Dict[str, Any]:
-    metadata = turn.get("metadata") if isinstance(turn.get("metadata"), dict) else {}
-    resolution = metadata.get("resolution") if isinstance(metadata.get("resolution"), dict) else {}
-    role = str(turn.get("role") or "")
-    content = _content_text(turn)
-    turn_id = int(turn.get("id") or 0)
-    branch_id = str(metadata.get("branch_id") or "")
-    latest_turn_id = int(latest_turn_id or turn_id or 1)
-    earliest_turn_id = int(earliest_turn_id or turn_id or 1)
-    reply_chain_ids = {int(item) for item in (reply_chain_turn_ids or []) if int(item or 0) > 0}
-    freshness_score = _normalized_position(turn_id or earliest_turn_id, latest_id=latest_turn_id, earliest_id=earliest_turn_id)
-
-    importance = 0.55 if role == "user" else 0.35
-    novelty = 0.25 if metadata.get("branch_depth") == 0 and branch_id else 0.1
-    uncertainty = 0.45 if "?" in content else 0.0
-    risk = 0.35 if resolution.get("decision") == "decline" else 0.0
-    goal_alignment = 0.45 if role == "user" else 0.0
-    if resolution:
-        goal_alignment += 0.2
-    if any(token in content.lower() for token in ("i will", "i'll", "let me", "next", "need to", "please", "can you")):
-        goal_alignment += 0.2
-    reinforcement = 0.2 if resolution.get("decision") == "confirm" else 0.0
-    user_interest = 0.3 if role == "user" else 0.0
-    signal_priority = 0.0
-    if active_branch_id and branch_id and branch_id == active_branch_id:
-        signal_priority += 0.45
-    if turn_id and turn_id in reply_chain_ids:
-        signal_priority += 0.35
-    if metadata.get("reply_to_turn_id"):
-        signal_priority += 0.1
-
-    scored = score_salience(
-        {
-            "importance": importance,
-            "novelty": novelty,
-            "uncertainty": uncertainty,
-            "risk": risk,
-            "goal_alignment": min(goal_alignment, 0.8),
-            "reinforcement": reinforcement,
-            "user_interest": user_interest,
-            "freshness": freshness_score,
-            "signal_priority": min(signal_priority, 0.9),
-        }
-    )
-    return {
-        **dict(scored),
-        "reference": turn.get("reference"),
-        "id": turn.get("id"),
-        "role": role,
-        "content": content,
-        "branch_id": branch_id or None,
-        "resolution": resolution or None,
-    }
-
-
-def score_checkpoint_salience(
-    checkpoint: Mapping[str, Any],
-    *,
-    latest_checkpoint_id: int | None = None,
-    active_branch_id: str | None = None,
-) -> Dict[str, Any]:
-    metadata = checkpoint.get("metadata") if isinstance(checkpoint.get("metadata"), dict) else {}
-    active_branch = metadata.get("active_branch") if isinstance(metadata.get("active_branch"), dict) else {}
-    checkpoint_id = int(checkpoint.get("id") or 0)
-    latest_checkpoint_id = int(latest_checkpoint_id or checkpoint_id or 1)
-    freshness_score = 1.0 if latest_checkpoint_id <= 0 else max(0.0, min(1.0, checkpoint_id / float(latest_checkpoint_id or 1)))
-    open_loops = checkpoint.get("open_loops") if isinstance(checkpoint.get("open_loops"), list) else []
-    pending_actions = checkpoint.get("pending_actions") if isinstance(checkpoint.get("pending_actions"), list) else []
-    latest_user_ask = str(checkpoint.get("latest_user_ask") or "").strip()
-    commitment = str(checkpoint.get("last_assistant_commitment") or "").strip()
-
-    importance = 0.45 + min(0.3, len(open_loops) * 0.08)
-    novelty = 0.1 + (0.15 if int(checkpoint.get("depth") or 0) == 0 else 0.0)
-    uncertainty = 0.3 if "?" in latest_user_ask else 0.0
-    risk = min(0.45, len(pending_actions) * 0.08)
-    goal_alignment = 0.25 + (0.2 if latest_user_ask else 0.0) + (0.15 if commitment else 0.0)
-    reinforcement = 0.0
-    user_interest = 0.25 if latest_user_ask else 0.0
-    signal_priority = 0.0
-    if active_branch_id and str(active_branch.get("branch_id") or "") == active_branch_id:
-        signal_priority += 0.35
-    if open_loops:
-        signal_priority += 0.25
-
-    scored = score_salience(
-        {
-            "importance": min(importance, 0.8),
-            "novelty": novelty,
-            "uncertainty": uncertainty,
-            "risk": risk,
-            "goal_alignment": min(goal_alignment, 0.8),
-            "reinforcement": reinforcement,
-            "user_interest": user_interest,
-            "freshness": freshness_score,
-            "signal_priority": min(signal_priority, 0.8),
-        }
-    )
-    return {
-        **dict(scored),
-        "reference": checkpoint.get("reference"),
-        "id": checkpoint.get("id"),
-        "summary": str(checkpoint.get("summary") or "").strip(),
-        "active_branch_id": active_branch.get("branch_id"),
-    }
-
-
-def rank_turns_by_salience(
-    turns: Sequence[Mapping[str, Any]],
-    *,
-    active_branch_id: str | None = None,
-    reply_chain_turn_ids: Sequence[int] | None = None,
-    limit: int | None = None,
-) -> List[Dict[str, Any]]:
-    turns_list = list(turns)
-    if not turns_list:
-        return []
-    ids = [int(item.get("id") or 0) for item in turns_list if int(item.get("id") or 0) > 0]
-    latest_turn_id = max(ids) if ids else 1
-    earliest_turn_id = min(ids) if ids else latest_turn_id
-    ranked = []
-    for turn in turns_list:
-        salience = score_turn_salience(
-            turn,
-            latest_turn_id=latest_turn_id,
-            earliest_turn_id=earliest_turn_id,
-            active_branch_id=active_branch_id,
-            reply_chain_turn_ids=reply_chain_turn_ids,
-        )
-        ranked.append({"turn": dict(turn), "salience": salience})
-    ranked.sort(
-        key=lambda item: (
-            _as_float(item["salience"].get("salience_score")),
-            _as_float((item["turn"] or {}).get("id")),
-        ),
-        reverse=True,
-    )
-    return ranked[: limit or len(ranked)]
-
-
-def rank_checkpoints_by_salience(
-    checkpoints: Sequence[Mapping[str, Any]],
-    *,
-    active_branch_id: str | None = None,
-    limit: int | None = None,
-) -> List[Dict[str, Any]]:
-    checkpoint_list = list(checkpoints)
-    if not checkpoint_list:
-        return []
-    latest_checkpoint_id = max(int(item.get("id") or 0) for item in checkpoint_list) or 1
-    ranked = []
-    for checkpoint in checkpoint_list:
-        salience = score_checkpoint_salience(
-            checkpoint,
-            latest_checkpoint_id=latest_checkpoint_id,
-            active_branch_id=active_branch_id,
-        )
-        ranked.append({"checkpoint": dict(checkpoint), "salience": salience})
-    ranked.sort(
-        key=lambda item: (
-            _as_float(item["salience"].get("salience_score")),
-            _as_float((item["checkpoint"] or {}).get("id")),
-        ),
-        reverse=True,
-    )
-    return ranked[: limit or len(ranked)]
-
-
-def scan_salient_memories(limit: int = 5) -> List[Dict[str, float | bool]]:
-    advisories = freshness.scan_freshness(limit=limit).get("advisories", [])
-    results = []
-    for item in advisories:
-        score = score_salience({"freshness": float(item.get("freshness_score", 0.0))})
-        if score.get("attention_trigger"):
-            results.append(score)
-    return results[:limit]
+from ocmemog.runtime.memory.memory_salience import *  # noqa: F401,F403

package/brain/runtime/memory/memory_synthesis.py

@@ -1,33 +1,3 @@
 from __future__ import annotations
 
-from typing import Dict, List
-
-from brain.runtime import state_store
-from brain.runtime.instrumentation import emit_event
-from brain.runtime.memory import reinforcement
-
-LOGFILE = state_store.reports_dir() / "brain_memory.log.jsonl"
-
-
-SYNTHESIS_TYPES = [
-    "theme_summary",
-    "user_preference",
-    "candidate_procedure",
-    "recurring_pattern",
-    "contradiction_candidate",
-]
-
-
-def synthesize_memory_patterns(limit: int = 5) -> List[Dict[str, str]]:
-    emit_event(LOGFILE, "brain_memory_synthesis_start", status="ok")
-    stats = reinforcement.list_recent_experiences(limit=limit)
-    results: List[Dict[str, str]] = []
-    for key, count in stats.items():
-        results.append(
-            {
-                "type": "recurring_pattern",
-                "summary": f"{key} occurred {count} times",
-            }
-        )
-    emit_event(LOGFILE, "brain_memory_synthesis_complete", status="ok", count=len(results))
-    return results[:limit]
+from ocmemog.runtime.memory.memory_synthesis import *  # noqa: F401,F403

package/brain/runtime/memory/memory_taxonomy.py

@@ -1,35 +1,3 @@
 from __future__ import annotations
 
-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"
-
-MEMORY_TYPES = [
-    "episodic",
-    "semantic",
-    "procedural",
-    "relationship",
-    "working",
-]
-
-
-def list_memory_types() -> List[str]:
-    return list(MEMORY_TYPES)
-
-
-def classify_memory_type(record: Dict[str, object]) -> str:
-    content = str(record.get("content") or "")
-    memory_type = "semantic"
-    if "how to" in content.lower() or "step" in content.lower():
-        memory_type = "procedural"
-    elif "met" in content.lower() or "relationship" in content.lower():
-        memory_type = "relationship"
-    elif record.get("memory_type") in MEMORY_TYPES:
-        memory_type = str(record.get("memory_type"))
-    elif record.get("source") == "working":
-        memory_type = "working"
-    emit_event(LOGFILE, "brain_memory_taxonomy_assigned", status="ok", memory_type=memory_type)
-    return memory_type
+from ocmemog.runtime.memory.memory_taxonomy import *  # noqa: F401,F403