@simbimbo/memory-ocmemog 0.1.10 → 0.1.12

package/ocmemog/runtime/memory/vector_index.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+import os
+import threading
+from typing import Any, Dict, List, Iterable
+
+from ocmemog.runtime.security import redaction
+from ocmemog.runtime import state_store
+from ocmemog.runtime.instrumentation import emit_event
+from . import embedding_engine, memory_links, store
+
+LOGFILE = state_store.report_log_path()
+
+EMBEDDING_TABLES: tuple[str, ...] = tuple(store.MEMORY_TABLES)
+_REBUILD_LOCK = threading.Lock()
+_WRITE_CHUNK_SIZE = 64
+_EMBEDDING_TEXT_LIMIT = 1000
+_EMBEDDING_KNOWLEDGE_ARTIFACT_LIMIT = 500
+_EMBEDDING_REFLECTION_LIMIT = 1200
+_EMBEDDING_EXTENDED_LIMIT = 2000
+_EMBEDDING_ULTRA_LIMIT = 4000
+_HTML_TAG_RE = re.compile(r"<[^>]+>")
+_WHITESPACE_RE = re.compile(r"\s+")
+
+
+def _ensure_vector_table(conn) -> None:
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS vector_embeddings (
+            id TEXT PRIMARY KEY,
+            source_type TEXT NOT NULL,
+            source_id TEXT NOT NULL,
+            embedding TEXT NOT NULL,
+            created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+        """
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_vector_embeddings_source ON vector_embeddings (source_type, source_id)"
+    )
+
+
+def _cosine_similarity(a: List[float], b: List[float]) -> float:
+    if not a or not b:
+        return 0.0
+    size = min(len(a), len(b))
+    if size == 0:
+        return 0.0
+    a2 = a[:size]
+    b2 = b[:size]
+    dot = sum(x * y for x, y in zip(a2, b2))
+    mag_a = math.sqrt(sum(x * x for x in a2))
+    mag_b = math.sqrt(sum(x * x for x in b2))
+    if mag_a == 0.0 or mag_b == 0.0:
+        return 0.0
+    return dot / (mag_a * mag_b)
+
+
+def _normalized_tables(tables: Iterable[str] | None) -> List[str]:
+    source = EMBEDDING_TABLES if tables is None else tables
+    seen: set[str] = set()
+    normalized: List[str] = []
+    for table in source:
+        if table in EMBEDDING_TABLES and table not in seen:
+            normalized.append(table)
+            seen.add(table)
+    return normalized
+
+
+def insert_memory(
+    memory_id: int,
+    content: str,
+    confidence: float,
+    *,
+    source_type: str = "knowledge",
+    skip_provider: bool = False,
+) -> None:
+    source_type = source_type if source_type in EMBEDDING_TABLES else "knowledge"
+    redacted_content, changed = redaction.redact_text(content)
+    embedding = embedding_engine.generate_embedding(redacted_content, skip_provider=skip_provider)
+    metadata_json = json.dumps({"redacted": changed, "source_type": source_type})
+
+    def _write() -> None:
+        conn = store.connect()
+        try:
+            _ensure_vector_table(conn)
+            conn.execute(
+                "INSERT INTO memory_index (source, confidence, metadata_json, content, schema_version) VALUES (?, ?, ?, ?, ?)",
+                (
+                    f"{source_type}:{memory_id}",
+                    confidence,
+                    metadata_json,
+                    redacted_content,
+                    store.SCHEMA_VERSION,
+                ),
+            )
+            if embedding:
+                emit_event(LOGFILE, "brain_memory_embedding_generated", status="ok", source_id=str(memory_id))
+                conn.execute(
+                    """
+                    INSERT INTO vector_embeddings (id, source_type, source_id, embedding)
+                    VALUES (?, ?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET embedding=excluded.embedding
+                    """,
+                    (f"{source_type}:{memory_id}", source_type, str(memory_id), json.dumps(embedding)),
+                )
+            conn.commit()
+        finally:
+            conn.close()
+
+    store.submit_write(_write, timeout=30.0)
+
+
+def _load_table_rows(table: str, *, limit: int | None = None, descending: bool = False, missing_only: bool = False) -> List[Dict[str, Any]]:
+    conn = store.connect()
+    try:
+        order = "DESC" if descending else "ASC"
+        where = ""
+        params: list[Any] = []
+        if missing_only:
+            where = (
+                " WHERE NOT EXISTS ("
+                "SELECT 1 FROM vector_embeddings AS ve "
+                "WHERE ve.source_type = ? AND ve.source_id = CAST(tbl.id AS TEXT)"
+                ")"
+            )
+            params.append(table)
+        if limit is None:
+            rows = conn.execute(
+                f"SELECT tbl.id, tbl.content, tbl.confidence, tbl.metadata_json FROM {table} AS tbl{where} ORDER BY tbl.id {order}",
+                tuple(params),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                f"SELECT tbl.id, tbl.content, tbl.confidence, tbl.metadata_json FROM {table} AS tbl{where} ORDER BY tbl.id {order} LIMIT ?",
+                tuple(params + [limit]),
+            ).fetchall()
+    finally:
+        conn.close()
+    return [dict(row) for row in rows]
+
+
+def _embedding_input(text: str, *, table: str = "knowledge") -> str:
+    """Normalize and hard-cap embedding input text.
+
+    Keep output deterministic and bounded for embedded calls that may have
+    conservative token windows.
+    """
+    raw = _WHITESPACE_RE.sub(" ", str(text or "")).strip()
+    cleaned = _HTML_TAG_RE.sub(" ", raw)
+    cleaned = _WHITESPACE_RE.sub(" ", cleaned).strip()
+    if not cleaned:
+        cleaned = raw
+    lowered = cleaned.lower()
+    artifactish = (
+        "| chunk " in lowered
+        or ".sql" in lowered
+        or "topology/" in lowered
+        or cleaned.count("),(") >= 8
+    )
+    if table == "knowledge" and artifactish:
+        return cleaned[:_EMBEDDING_KNOWLEDGE_ARTIFACT_LIMIT]
+    if table == "knowledge" and len(cleaned) > 9000:
+        return cleaned[:_EMBEDDING_TEXT_LIMIT]
+    if table == "reflections" and len(cleaned) > 8000:
+        return cleaned[:_EMBEDDING_REFLECTION_LIMIT]
+    if len(cleaned) > 20000:
+        return cleaned[:_EMBEDDING_ULTRA_LIMIT]
+    if len(cleaned) > 12000:
+        return cleaned[:_EMBEDDING_EXTENDED_LIMIT]
+    # Local llama.cpp embedding runtime currently rejects inputs above its effective
+    # token window (~512 tokens physical batch). Keep a conservative character cap so
+    # backfill and live embedding stay deterministic instead of failing with HTTP 500s.
+    return cleaned[:_EMBEDDING_TEXT_LIMIT]
+
+
+def _prepare_embedding_rows(rows: Iterable[Dict[str, Any]], *, table: str) -> List[Dict[str, Any]]:
+    prepared: List[Dict[str, Any]] = []
+    embedding_cache: Dict[str, List[float] | None] = {}
+    for row in rows:
+        content = str(row.get("content") or "")
+        redacted_content, changed = redaction.redact_text(content)
+        embedding_input = _embedding_input(redacted_content, table=table)
+        cache_key = hashlib.sha256(embedding_input.encode("utf-8", errors="ignore")).hexdigest()
+        if cache_key in embedding_cache:
+            embedding = embedding_cache[cache_key]
+        else:
+            embedding = embedding_engine.generate_embedding(embedding_input)
+            embedding_cache[cache_key] = embedding
+        if not embedding:
+            continue
+        try:
+            metadata = json.loads(row.get("metadata_json") or "{}")
+        except Exception:
+            metadata = {}
+        metadata["redacted"] = changed
+        prepared.append(
+            {
+                "id": int(row["id"]),
+                "content": redacted_content,
+                "confidence": float(row.get("confidence") or 0.0),
+                "metadata_json": json.dumps(metadata),
+                "embedding": json.dumps(embedding),
+                "source_type": table,
+            }
+        )
+    return prepared
+
+
+def _write_embedding_chunk(table: str, rows: List[Dict[str, Any]]) -> int:
+    if not rows:
+        return 0
+
+    def _write() -> int:
+        conn = store.connect()
+        try:
+            _ensure_vector_table(conn)
+            for row in rows:
+                conn.execute(
+                    f"UPDATE {table} SET content=?, metadata_json=? WHERE id=?",
+                    (row["content"], row["metadata_json"], row["id"]),
+                )
+                conn.execute(
+                    """
+                    INSERT INTO vector_embeddings (id, source_type, source_id, embedding)
+                    VALUES (?, ?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET embedding=excluded.embedding
+                    """,
+                    (f"{table}:{row['id']}", table, str(row["id"]), row["embedding"]),
+                )
+            conn.commit()
+            return len(rows)
+        finally:
+            conn.close()
+
+    return int(store.submit_write(_write, timeout=60.0))
+
+
+def index_memory(limit: int = 100, *, tables: Iterable[str] | None = None) -> int:
+    emit_event(LOGFILE, "brain_memory_vector_index_start", status="ok")
+    count = 0
+    for table in (tables or EMBEDDING_TABLES):
+        if table not in EMBEDDING_TABLES:
+            continue
+        prepared = _prepare_embedding_rows(_load_table_rows(table, limit=limit, descending=True), table=table)
+        for offset in range(0, len(prepared), _WRITE_CHUNK_SIZE):
+            count += _write_embedding_chunk(table, prepared[offset: offset + _WRITE_CHUNK_SIZE])
+    emit_event(LOGFILE, "brain_memory_vector_index_complete", status="ok", indexed=count)
+    return count
+
+
+def rebuild_vector_index(*, tables: Iterable[str] | None = None) -> int:
+    emit_event(LOGFILE, "brain_memory_vector_rebuild_start", status="ok")
+    requested_tables = _normalized_tables(tables)
+    if not requested_tables:
+        emit_event(LOGFILE, "brain_memory_vector_rebuild_complete", status="skipped", reason="no_valid_tables")
+        return 0
+    if not _REBUILD_LOCK.acquire(blocking=False):
+        emit_event(LOGFILE, "brain_memory_vector_rebuild_complete", status="skipped", reason="already_running")
+        return 0
+    count = 0
+    try:
+        def _clear() -> None:
+            conn = store.connect()
+            try:
+                _ensure_vector_table(conn)
+                if requested_tables:
+                    conn.executemany(
+                        "DELETE FROM vector_embeddings WHERE source_type = ?",
+                        [(table,) for table in requested_tables],
+                    )
+                conn.commit()
+            finally:
+                conn.close()
+
+        store.submit_write(_clear, timeout=60.0)
+        for table in requested_tables:
+            prepared = _prepare_embedding_rows(_load_table_rows(table), table=table)
+            for offset in range(0, len(prepared), _WRITE_CHUNK_SIZE):
+                count += _write_embedding_chunk(table, prepared[offset: offset + _WRITE_CHUNK_SIZE])
+    finally:
+        _REBUILD_LOCK.release()
+    emit_event(LOGFILE, "brain_memory_vector_rebuild_complete", status="ok", indexed=count)
+    return count
+
+
+def backfill_missing_vectors(*, tables: Iterable[str] | None = None, limit_per_table: int | None = None) -> int:
+    emit_event(LOGFILE, "brain_memory_vector_backfill_start", status="ok")
+    requested_tables = _normalized_tables(tables)
+    if not requested_tables:
+        emit_event(LOGFILE, "brain_memory_vector_backfill_complete", status="skipped", reason="no_valid_tables")
+        return 0
+    if limit_per_table is not None and limit_per_table <= 0:
+        emit_event(LOGFILE, "brain_memory_vector_backfill_complete", status="skipped", reason="invalid_limit")
+        return 0
+    if not _REBUILD_LOCK.acquire(blocking=False):
+        emit_event(LOGFILE, "brain_memory_vector_backfill_complete", status="skipped", reason="already_running")
+        return 0
+    count = 0
+    try:
+        for table in requested_tables:
+            prepared = _prepare_embedding_rows(
+                _load_table_rows(table, limit=limit_per_table, missing_only=True),
+                table=table,
+            )
+            for offset in range(0, len(prepared), _WRITE_CHUNK_SIZE):
+                count += _write_embedding_chunk(table, prepared[offset: offset + _WRITE_CHUNK_SIZE])
+    finally:
+        _REBUILD_LOCK.release()
+    emit_event(LOGFILE, "brain_memory_vector_backfill_complete", status="ok", indexed=count)
+    return count
+
+
+def search_memory(
+    query: str,
+    limit: int = 5,
+    *,
+    skip_provider: bool = False,
+    source_types: Iterable[str] | None = None,
+) -> List[Dict[str, Any]]:
+    emit_event(LOGFILE, "brain_memory_vector_search_start", status="ok")
+    conn = store.connect()
+    _ensure_vector_table(conn)
+
+    query_embedding = embedding_engine.generate_embedding(query, skip_provider=skip_provider)
+    results: List[Dict[str, Any]] = []
+
+    try:
+        scan_limit = int(os.environ.get("OCMEMOG_SEARCH_VECTOR_SCAN_LIMIT", 1200))
+    except Exception:
+        scan_limit = 1200
+    if scan_limit <= 0:
+        scan_limit = max(1, limit * 8)
+    scan_limit = max(limit, scan_limit)
+
+    if source_types is None:
+        filtered_source_types = tuple(EMBEDDING_TABLES)
+    else:
+        filtered_source_types = tuple(
+            source_type
+            for source_type in dict.fromkeys(source_type for source_type in source_types if source_type in EMBEDDING_TABLES)
+        )
+    if filtered_source_types:
+        placeholders = ",".join("?" for _ in filtered_source_types)
+        vector_query = (
+            "SELECT id, source_type, source_id, embedding "
+            f"FROM vector_embeddings WHERE source_type IN ({placeholders}) "
+            "ORDER BY rowid DESC LIMIT ?"
+        )
+        scan_rows = (*filtered_source_types, scan_limit)
+    else:
+        vector_query = "SELECT id, source_type, source_id, embedding FROM vector_embeddings ORDER BY rowid DESC LIMIT ?"
+        scan_rows = (scan_limit,)
+
+    if query_embedding:
+        rows = conn.execute(vector_query, scan_rows).fetchall()
+        scored: List[Dict[str, Any]] = []
+        for row in rows:
+            try:
+                emb = json.loads(row["embedding"])
+                emb_list = [float(x) for x in emb]
+            except Exception:
+                continue
+            score = _cosine_similarity(query_embedding, emb_list)
+            scored.append(
+                {
+                    "entry_id": row["id"],
+                    "source_type": row["source_type"],
+                    "source_id": row["source_id"],
+                    "score": round(score, 6),
+                }
+            )
+        scored.sort(key=lambda item: item["score"], reverse=True)
+        results = scored[:limit]
+
+    if not results:
+        fallback_where = ""
+        fallback_params: List[Any] = [f"%{query}%"]
+        if filtered_source_types:
+            patterns = [f"{source_type}:%" for source_type in filtered_source_types]
+            fallback_where = f" AND ({' OR '.join(['source LIKE ?'] * len(patterns))})"
+            fallback_params.extend(patterns)
+        rows = conn.execute(
+            f"SELECT id, source, content, confidence, metadata_json FROM memory_index WHERE content LIKE ?{fallback_where} ORDER BY id DESC LIMIT ?",
+            tuple(fallback_params + [limit]),
+        ).fetchall()
+        fallback_results: List[Dict[str, Any]] = []
+        for row in rows:
+            source_ref = str(row["source"] or "")
+            source_type, _, source_id = source_ref.partition(":")
+            canonical_type = source_type if source_type in EMBEDDING_TABLES else "knowledge"
+            canonical_ref = f"{canonical_type}:{source_id}" if source_id else source_ref
+            fallback_results.append(
+                {
+                    "entry_id": canonical_ref,
+                    "source_type": canonical_type,
+                    "source_id": source_id or str(row["id"]),
+                    "score": float(row["confidence"] or 0.0),
+                    "content": str(row["content"] or "")[:240],
+                    "links": memory_links.get_memory_links(canonical_ref),
+                }
+            )
+        results = fallback_results
+
+    conn.close()
+    emit_event(LOGFILE, "brain_memory_vector_search_complete", status="ok", result_count=len(results))
+    return results

package/ocmemog/runtime/model_roles.py

@@ -0,0 +1,16 @@
+"""Model-role mapping helpers owned by ocmemog."""
+
+from __future__ import annotations
+
+from . import config
+
+__wrapped_from__ = "brain.runtime.model_roles"
+
+
+def get_model_for_role(role: str) -> str:
+    if role == "memory":
+        return config.OCMEMOG_MEMORY_MODEL
+    if role == "embedding":
+        return config.OCMEMOG_OPENAI_EMBED_MODEL
+    return config.OCMEMOG_MEMORY_MODEL
+

package/ocmemog/runtime/model_router.py

@@ -0,0 +1,29 @@
+"""Model-provider routing helpers owned by ocmemog."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import config
+
+__wrapped_from__ = "brain.runtime.model_router"
+
+
+@dataclass(frozen=True)
+class ModelSelection:
+    provider_id: str = ""
+    model: str = ""
+
+
+def get_provider_for_role(role: str) -> ModelSelection:
+    if role != "embedding":
+        return ModelSelection()
+    provider = (config.OCMEMOG_EMBED_PROVIDER or config.BRAIN_EMBED_MODEL_PROVIDER or "").strip().lower()
+    if provider in {"openai", "openai_compatible", "openai-compatible"}:
+        return ModelSelection(provider_id="openai", model=config.OCMEMOG_OPENAI_EMBED_MODEL)
+    if provider in {"local-openai", "local_openai", "llamacpp", "llama.cpp"}:
+        return ModelSelection(provider_id="local-openai", model=config.OCMEMOG_LOCAL_EMBED_MODEL)
+    if provider in {"ollama", "local-ollama"}:
+        return ModelSelection(provider_id="ollama", model=config.OCMEMOG_OLLAMA_EMBED_MODEL)
+    return ModelSelection()
+

package/ocmemog/runtime/providers.py

@@ -0,0 +1,79 @@
+"""Embedding provider execution wrapper owned by ocmemog."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+
+from . import config, instrumentation, state_store
+
+__wrapped_from__ = "brain.runtime.providers"
+
+LOGFILE = state_store.report_log_path()
+
+
+class ProviderExecute:
+    def execute_embedding_call(self, selection, text: str) -> dict[str, object]:
+        provider_id = getattr(selection, "provider_id", "") or ""
+        model = getattr(selection, "model", "") or config.OCMEMOG_OPENAI_EMBED_MODEL
+        if provider_id in {"openai", "local-openai"}:
+            api_key = None
+            url_base = config.OCMEMOG_OPENAI_API_BASE
+            provider_label = "openai"
+            if provider_id == "openai":
+                api_key = os.environ.get("OCMEMOG_OPENAI_API_KEY") or os.environ.get("OPENAI_API_KEY")
+                if not api_key:
+                    return {}
+            else:
+                url_base = config.OCMEMOG_LOCAL_EMBED_BASE_URL
+                api_key = os.environ.get("OCMEMOG_LOCAL_EMBED_API_KEY") or os.environ.get("LOCAL_EMBED_API_KEY")
+                provider_label = "local-openai"
+            url = f"{url_base.rstrip('/')}/embeddings"
+            payload = json.dumps({"model": model, "input": text}).encode("utf-8")
+            req = urllib.request.Request(url, data=payload, method="POST")
+            if api_key:
+                req.add_header("Authorization", f"Bearer {api_key}")
+            req.add_header("Content-Type", "application/json")
+            try:
+                with urllib.request.urlopen(req, timeout=20) as resp:
+                    data = json.loads(resp.read().decode("utf-8"))
+            except Exception as exc:
+                instrumentation.emit_event(
+                    LOGFILE, "brain_embedding_provider_error", status="error", provider=provider_label, error=str(exc)
+                )
+                return {}
+            try:
+                embedding = data["data"][0]["embedding"]
+            except Exception as exc:
+                instrumentation.emit_event(
+                    LOGFILE, "brain_embedding_provider_error", status="error", provider=provider_label, error=str(exc)
+                )
+                return {}
+            return {"embedding": embedding}
+
+        if provider_id == "ollama":
+            url = f"{config.OCMEMOG_OLLAMA_HOST.rstrip('/')}/api/embeddings"
+            payload = json.dumps({"model": model, "prompt": text}).encode("utf-8")
+            req = urllib.request.Request(url, data=payload, method="POST")
+            req.add_header("Content-Type", "application/json")
+            try:
+                with urllib.request.urlopen(req, timeout=20) as resp:
+                    data = json.loads(resp.read().decode("utf-8"))
+            except Exception as exc:
+                instrumentation.emit_event(LOGFILE, "brain_embedding_provider_error", status="error", provider="ollama", error=str(exc))
+                return {}
+            embedding = data.get("embedding")
+            if not isinstance(embedding, list):
+                instrumentation.emit_event(
+                    LOGFILE, "brain_embedding_provider_error", status="error", provider="ollama", error="invalid_embedding"
+                )
+                return {}
+            return {"embedding": embedding}
+
+        return {}
+
+
+provider_execute = ProviderExecute()
+provider_execute.__shim__ = False
+

package/ocmemog/runtime/roles.py

@@ -0,0 +1,92 @@
+"""Native role registry surfaced as an engine-like runtime surface.
+
+The upstream brAIn project exposes role-prioritized context behavior through a
+`roles` module. This repo keeps a compatible shape in `ocmemog` so callers can
+query role metadata without being coupled to legacy implementation details.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+# Core roles are intentionally conservative and deterministic so they can be used
+# by fallback context builders and lightweight policy checks.
+ROLE_REGISTRY: Dict[str, Dict[str, object]] = {
+    "default": {
+        "priority": 90,
+        "description": "Balanced fallback role for generic memory lookup",
+        "ordered_buckets": (
+            "knowledge",
+            "preferences",
+            "identity",
+            "reflections",
+            "directives",
+            "tasks",
+            "runbooks",
+            "lessons",
+        ),
+        "soft_window": 5,
+    },
+    "user": {
+        "priority": 100,
+        "description": "User-sourced prompts should prioritize reflective and identity buckets",
+        "ordered_buckets": (
+            "reflections",
+            "identity",
+            "preferences",
+            "knowledge",
+            "tasks",
+            "directives",
+            "runbooks",
+            "lessons",
+        ),
+        "soft_window": 6,
+    },
+    "assistant": {
+        "priority": 80,
+        "description": "Assistant-sourced prompts should prioritize concise operational memory",
+        "ordered_buckets": (
+            "tasks",
+            "directives",
+            "knowledge",
+            "runbooks",
+            "lessons",
+            "preferences",
+            "reflections",
+            "identity",
+        ),
+        "soft_window": 4,
+    },
+}
+
+__all__ = ["ROLE_REGISTRY", "role_registry", "role_profile", "sorted_roles"]
+
+
+def role_registry() -> Dict[str, Dict[str, object]]:
+    """Return the current role registry as a copy for safe introspection."""
+
+    return {
+        key: {
+            "role": key,
+            **{
+                "buckets": tuple(profile.get("ordered_buckets") or ()),
+                "priority": int(profile.get("priority", 0)),
+                "description": str(profile.get("description", "")),
+                "soft_window": int(profile.get("soft_window", 0)),
+            },
+        }
+        for key, profile in ROLE_REGISTRY.items()
+    }
+
+
+def role_profile(role: str) -> Dict[str, object] | None:
+    """Return a normalized profile for a single role, if defined."""
+
+    normalized = str(role or "").strip().lower() or "default"
+    return role_registry().get(normalized)
+
+
+def sorted_roles() -> List[str]:
+    """Return role ids ordered by descending priority."""
+
+    return sorted((role_registry().keys()), key=lambda role_id: role_registry()[role_id]["priority"], reverse=True)

package/ocmemog/runtime/security/__init__.py

@@ -0,0 +1,8 @@
+"""ocmemog-native security namespace."""
+
+from __future__ import annotations
+
+from . import redaction
+
+__all__ = ["redaction"]
+

package/ocmemog/runtime/security/redaction.py

@@ -0,0 +1,17 @@
+"""Input redaction helpers owned by ocmemog."""
+
+from __future__ import annotations
+
+import re
+
+EMAIL_RE = re.compile(r"\b[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}\b")
+PHONE_RE = re.compile(r"\b(?:\+?1[-.\s]?)?(?:\(?\d{3}\)?[-.\s]?){2}\d{4}\b")
+
+
+def redact_text(text: str) -> tuple[str, bool]:
+    if not isinstance(text, str):
+        return "", False
+    redacted = EMAIL_RE.sub("[redacted-email]", text)
+    redacted = PHONE_RE.sub("[redacted-phone]", redacted)
+    return redacted, redacted != text
+

package/ocmemog/runtime/state_store.py

@@ -0,0 +1,34 @@
+"""Runtime state persistence surface owned by ocmemog."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from . import storage_paths
+
+__wrapped_from__ = "brain.runtime.state_store"
+__wrapped_by__ = "ocmemog-runtime-bridge"
+
+
+def root_dir() -> Path:
+    return storage_paths.root_dir()
+
+
+def data_dir() -> Path:
+    return storage_paths.data_dir()
+
+
+def memory_dir() -> Path:
+    return storage_paths.memory_dir()
+
+
+def reports_dir() -> Path:
+    return storage_paths.reports_dir()
+
+
+def report_log_path() -> Path:
+    return storage_paths.report_log_path()
+
+
+def memory_db_path() -> Path:
+    return storage_paths.memory_db_path()