@simbimbo/memory-ocmemog 0.1.4

package/brain/runtime/memory/memory_consolidation.py

@@ -0,0 +1,60 @@
+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}

package/brain/runtime/memory/memory_gate.py

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,54 @@
+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]]

package/brain/runtime/memory/memory_links.py

@@ -0,0 +1,109 @@
+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

package/brain/runtime/memory/memory_salience.py

@@ -0,0 +1,235 @@
+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]

package/brain/runtime/memory/memory_synthesis.py

@@ -0,0 +1,33 @@
+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]

package/brain/runtime/memory/memory_taxonomy.py

@@ -0,0 +1,35 @@
+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

package/brain/runtime/memory/person_identity.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Dict, Tuple
+import re
+
+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 extract_intro_candidate(text: str) -> str | None:
+    if not isinstance(text, str):
+        return None
+    cleaned = text.strip()
+    if not cleaned:
+        return None
+    lowered = cleaned.lower().strip(".!")
+    call_me_match = re.search(r"\byou can call me\s+([a-z][a-z\-']*)", lowered)
+    if call_me_match:
+        return call_me_match.group(1).strip(" .!").title()
+    direct_call_match = re.search(r"\bcall me\s+([a-z][a-z\-']*)", lowered)
+    if direct_call_match:
+        return direct_call_match.group(1).strip(" .!").title()
+    patterns = [
+        r"^my name is (.+)$",
+        r"^i am (.+)$",
+        r"^i'm (.+)$",
+    ]
+    for pattern in patterns:
+        match = re.match(pattern, lowered)
+        if match:
+            candidate = match.group(1).split(" but ")[0].strip(" .!")
+            return candidate.title() if candidate else None
+    return None
+
+
+def extract_name_candidate(text: str) -> str | None:
+    candidate = extract_intro_candidate(text)
+    if candidate:
+        return candidate
+    if not isinstance(text, str):
+        return None
+    cleaned = text.strip()
+    if not cleaned:
+        return None
+    tokens = [token for token in cleaned.replace(".", "").split() if token]
+    if 1 <= len(tokens) <= 3:
+        return " ".join(tokens)
+    return None
+
+
+def extract_operator_name(text: str) -> str | None:
+    from brain.runtime import inference
+
+    llm_result = inference.parse_operator_name(text)
+    llm_name = llm_result.get("name") if isinstance(llm_result, dict) else ""
+    if isinstance(llm_name, str) and llm_name.strip():
+        return llm_name.strip()
+    return extract_name_candidate(text)
+
+
+def resolve_interaction_person(metadata: Dict[str, str]) -> Tuple[Dict[str, object] | None, float, bool]:
+    person = None
+    confidence = 0.0
+    name_input = metadata.get("name") or ""
+    name_candidate = extract_name_candidate(name_input) if name_input else None
+    if name_candidate:
+        person = person_memory.get_person(name_candidate) or person_memory.create_person(name_candidate, name_candidate)
+        confidence = 0.7
+    if not person and metadata.get("email"):
+        person = person_memory.find_person_by_email(metadata["email"])
+        confidence = 0.6 if person else 0.0
+    if not person and metadata.get("phone"):
+        person = person_memory.find_person_by_phone(metadata["phone"])
+        confidence = 0.6 if person else 0.0
+    ask_name_required = confidence < 0.5
+    if person:
+        emit_event(LOGFILE, "brain_person_identity_resolved", status="ok", person_id=person.get("person_id"))
+    else:
+        emit_event(LOGFILE, "brain_person_identity_uncertain", status="ok")
+    return person, confidence, ask_name_required