@simbimbo/memory-ocmemog 0.1.11 → 0.1.13

package/ocmemog/runtime/memory/integrity.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ocmemog.runtime.instrumentation import emit_event
+from ocmemog.runtime import state_store
+from ocmemog.runtime.memory import store
+
+EMBED_TABLES = tuple(store.MEMORY_TABLES)
+
+
+def run_integrity_check() -> Dict[str, Any]:
+    emit_event(state_store.report_log_path(), "brain_memory_integrity_start", status="ok")
+    conn = store.connect()
+    issues: List[str] = []
+    repairable: List[str] = []
+    sqlite_ok = True
+
+    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.report_log_path(), "brain_memory_integrity_issue", status="warn")
+
+    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.report_log_path(), "brain_memory_integrity_issue", status="warn")
+    except Exception:
+        pass
+
+    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.report_log_path(), "brain_memory_integrity_issue", status="warn")
+    except Exception:
+        pass
+
+    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.report_log_path(), "brain_memory_integrity_issue", status="warn")
+    except Exception:
+        pass
+
+    missing_vectors = 0
+    orphan_vectors = 0
+    try:
+        for table in EMBED_TABLES:
+            missing_vectors += conn.execute(
+                f"""
+                SELECT COUNT(*) FROM {table} AS source
+                WHERE NOT EXISTS (
+                    SELECT 1
+                    FROM vector_embeddings AS embeddings
+                    WHERE embeddings.source_type = ?
+                      AND CAST(embeddings.source_id AS TEXT) = CAST(source.id AS TEXT)
+                )
+                """,
+                (table,),
+            ).fetchone()[0]
+    except Exception:
+        pass
+
+    try:
+        for table in EMBED_TABLES:
+            orphan_vectors += conn.execute(
+                """
+                SELECT COUNT(*) FROM vector_embeddings AS embeddings
+                WHERE embeddings.source_type = ?
+                  AND NOT EXISTS (
+                    SELECT 1 FROM %s AS source
+                    WHERE CAST(source.id AS TEXT) = CAST(embeddings.source_id AS TEXT)
+                  )
+                """ % table,
+                (table,),
+            ).fetchone()[0]
+    except Exception:
+        pass
+
+    if missing_vectors:
+        issues.append(f"vector_missing:{missing_vectors}")
+        emit_event(state_store.report_log_path(), "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.report_log_path(), "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.report_log_path(), "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.report_log_path(), "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} AS source
+                            WHERE CAST(source.id AS TEXT) = CAST(vector_embeddings.source_id AS TEXT)
+                          )
+                        """,
+                        (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.report_log_path(),
+            "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.report_log_path(),
+            "brain_memory_integrity_repair",
+            status="ok",
+            repaired="missing_memory_reference",
+            count=int(result["repaired_missing_memory_references"]),
+        )
+    return {"ok": True, "repaired": repaired, **result}

package/ocmemog/runtime/memory/memory_consolidation.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Dict, List, Tuple
+
+from ocmemog.runtime import state_store
+from ocmemog.runtime.instrumentation import emit_event
+from ocmemog.runtime.memory import memory_taxonomy
+
+LOGFILE = state_store.report_log_path()
+
+
+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}

package/ocmemog/runtime/memory/memory_links.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import sqlite3
+from typing import Dict, List
+
+from ocmemog.runtime import state_store
+from ocmemog.runtime.instrumentation import emit_event
+from . import store
+
+LOGFILE = state_store.report_log_path()
+
+
+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

package/ocmemog/runtime/memory/memory_salience.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Mapping, Sequence
+
+from ocmemog.runtime import state_store
+from ocmemog.runtime.instrumentation import emit_event
+from ocmemog.runtime.memory import freshness
+
+LOGFILE = state_store.report_log_path()
+
+
+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]

package/ocmemog/runtime/memory/memory_synthesis.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from ocmemog.runtime import state_store
+from ocmemog.runtime.instrumentation import emit_event
+from ocmemog.runtime.memory import reinforcement
+
+LOGFILE = state_store.report_log_path()
+
+
+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]

package/ocmemog/runtime/memory/memory_taxonomy.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from ocmemog.runtime import state_store
+from ocmemog.runtime.instrumentation import emit_event
+
+LOGFILE = state_store.report_log_path()
+
+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