@geravant/sinain 1.12.0 → 1.13.0

package/sinain-memory/eval/benchmarks/run_meeting_bench.sh

@@ -0,0 +1,318 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ── Meeting Memory Benchmark — end-to-end capture + evaluate ─────────────────
+# 1. Opens meeting recording fullscreen in QuickTime
+# 2. Starts sinain (audio + sense capture, no agent, no overlay)
+# 3. Waits for recording to finish
+# 4. Stops sinain → saves pending session
+# 5. Restarts sinain → distills pending session into knowledge graph
+# 6. Runs evaluation harness against the distilled DB
+#
+# Usage: ./run_meeting_bench.sh <mp4_path>
+# Output: eval/benchmarks/results/meeting_results.md
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SINAIN_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
+KOOG_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+BOLD='\033[1m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+RED='\033[0;31m'
+CYAN='\033[0;36m'
+RESET='\033[0m'
+
+log()  { echo -e "${BOLD}[bench]${RESET} $*"; }
+ok()   { echo -e "${BOLD}[bench]${RESET} ${GREEN}✓${RESET} $*"; }
+warn() { echo -e "${BOLD}[bench]${RESET} ${YELLOW}⚠${RESET} $*"; }
+fail() { echo -e "${BOLD}[bench]${RESET} ${RED}✗${RESET} $*"; exit 1; }
+
+# ── Args ─────────────────────────────────────────────────────────────────────
+RECORDING="${1:-}"
+if [ -z "$RECORDING" ] || [ ! -f "$RECORDING" ]; then
+  fail "Usage: $0 <path-to-mp4>"
+fi
+
+# ── Setup ────────────────────────────────────────────────────────────────────
+BENCH_DIR="/tmp/sinain-bench-$(date +%s)"
+mkdir -p "$BENCH_DIR"
+log "Benchmark directory: ${CYAN}${BENCH_DIR}${RESET}"
+
+# Source .env for API keys and audio config (safe parser from start-local.sh)
+for _env_file in "$SINAIN_ROOT/.env" "$SINAIN_ROOT/sinain-core/.env" "$HOME/.sinain/.env"; do
+  if [ -f "$_env_file" ]; then
+    log "Loading $_env_file"
+    while IFS='=' read -r _k _v; do
+      [[ -z "$_k" || "$_k" =~ ^[[:space:]]*# ]] && continue
+      _k=$(echo "$_k" | xargs)
+      _v=$(echo "$_v" | xargs)
+      _v="${_v%%#*}"
+      _v=$(echo "$_v" | xargs)
+      [[ -z "$_v" ]] && continue
+      if [ -z "${!_k+x}" ]; then export "$_k=$_v"; fi
+    done < "$_env_file"
+    break
+  fi
+done
+
+# Bench-specific overrides
+export SINAIN_MEMORY_DIR="$BENCH_DIR"
+export AGENT_ENABLED=false
+export ESCALATION_MODE=off
+
+# Local whisper setup (from start-local.sh)
+MODEL_DIR="$HOME/models"
+MODEL_NAME="ggml-large-v3-turbo.bin"
+export LOCAL_WHISPER_MODEL="${LOCAL_WHISPER_MODEL:-$MODEL_DIR/$MODEL_NAME}"
+export LOCAL_WHISPER_BIN="${LOCAL_WHISPER_BIN:-whisper-cli}"
+export TRANSCRIPTION_BACKEND=local
+
+# ── Get recording duration ───────────────────────────────────────────────────
+DURATION_RAW=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$RECORDING" 2>/dev/null || echo "")
+if [ -n "$DURATION_RAW" ]; then
+  DURATION=$(echo "$DURATION_RAW" | cut -d. -f1)
+else
+  DURATION=1620  # fallback: 27 min
+fi
+log "Recording duration: ${DURATION}s (~$((DURATION / 60))m)"
+
+# ── Cleanup handler ──────────────────────────────────────────────────────────
+CORE_PID=""
+SENSE_PID=""
+
+cleanup() {
+  log "Cleaning up..."
+  [ -n "$SENSE_PID" ] && kill "$SENSE_PID" 2>/dev/null || true
+  [ -n "$CORE_PID" ] && kill "$CORE_PID" 2>/dev/null || true
+  sleep 2
+  [ -n "$SENSE_PID" ] && kill -9 "$SENSE_PID" 2>/dev/null || true
+  [ -n "$CORE_PID" ] && kill -9 "$CORE_PID" 2>/dev/null || true
+  # Kill anything on port 9500
+  lsof -i :9500 -sTCP:LISTEN -t 2>/dev/null | xargs kill -9 2>/dev/null || true
+  # Close QuickTime
+  osascript -e 'tell application "QuickTime Player" to quit' 2>/dev/null || true
+}
+trap cleanup EXIT
+
+# ── Kill stale sinain processes ──────────────────────────────────────────────
+log "Killing stale processes..."
+pkill -f "tsx.*src/index.ts" 2>/dev/null || true
+pkill -f "python3 -m sense_client" 2>/dev/null || true
+pkill -f "Python -m sense_client" 2>/dev/null || true
+pkill -f "tools/sck-capture/sck-capture" 2>/dev/null || true
+lsof -i :9500 -sTCP:LISTEN -t 2>/dev/null | xargs kill -9 2>/dev/null || true
+sleep 2
+
+# ── Phase 1a: Open video fullscreen ─────────────────────────────────────────
+log "Opening recording in QuickTime (fullscreen)..."
+open -a "QuickTime Player" "$RECORDING"
+sleep 3
+osascript -e '
+tell application "QuickTime Player"
+  present front document
+  delay 1
+  play front document
+end tell
+' 2>/dev/null || warn "Could not auto-play — check QuickTime"
+ok "Video playing fullscreen"
+
+# ── Phase 1b: Start sinain-core ──────────────────────────────────────────────
+log "Starting sinain-core (capture-only, local whisper)..."
+(cd "$SINAIN_ROOT/sinain-core" && npx tsx src/index.ts 2>&1) | \
+  sed -u "s/^/$(printf "${CYAN}[core]${RESET}    ")/" &
+CORE_PID=$!
+
+# Wait for health
+CORE_OK=false
+for i in $(seq 1 20); do
+  if curl -sf http://localhost:9500/health >/dev/null 2>&1; then
+    CORE_OK=true
+    break
+  fi
+  sleep 1
+done
+if $CORE_OK; then
+  ok "sinain-core healthy on :9500"
+else
+  fail "sinain-core did not start"
+fi
+
+# ── Phase 1c: Start sense_client ─────────────────────────────────────────────
+log "Starting sense_client (screen capture + OCR)..."
+
+# Propagate privacy mode
+export PRIVACY_OCR_OPENROUTER="${PRIVACY_OCR_OPENROUTER:-full}"
+export PRIVACY_IMAGES_OPENROUTER="${PRIVACY_IMAGES_OPENROUTER:-full}"
+
+(cd "$SINAIN_ROOT" && python3 -m sense_client 2>&1) | \
+  sed -u "s/^/$(printf "${YELLOW}[sense]${RESET}   ")/" &
+SENSE_PID=$!
+sleep 2
+
+if kill -0 "$SENSE_PID" 2>/dev/null; then
+  ok "sense_client running"
+else
+  warn "sense_client failed to start — continuing with audio only"
+  SENSE_PID=""
+fi
+
+# ── Phase 1d: Wait for recording to finish ───────────────────────────────────
+BUFFER=60  # extra time for trailing transcription/OCR
+TOTAL_WAIT=$((DURATION + BUFFER))
+log "Waiting ${TOTAL_WAIT}s for recording + buffer..."
+log "  (recording ends at $(date -v+${DURATION}S '+%H:%M:%S'), buffer until $(date -v+${TOTAL_WAIT}S '+%H:%M:%S'))"
+
+# Progress updates every 5 minutes
+ELAPSED=0
+while [ $ELAPSED -lt $TOTAL_WAIT ]; do
+  SLEEP_CHUNK=300
+  if [ $((ELAPSED + SLEEP_CHUNK)) -gt $TOTAL_WAIT ]; then
+    SLEEP_CHUNK=$((TOTAL_WAIT - ELAPSED))
+  fi
+  sleep $SLEEP_CHUNK
+  ELAPSED=$((ELAPSED + SLEEP_CHUNK))
+  REMAINING=$((TOTAL_WAIT - ELAPSED))
+  if [ $REMAINING -gt 0 ]; then
+    # Check feed count
+    FEED_COUNT=$(curl -sf http://localhost:9500/feed 2>/dev/null | python3 -c "import sys,json; print(len(json.load(sys.stdin).get('messages',[])))" 2>/dev/null || echo "?")
+    log "  ${ELAPSED}s elapsed, ${REMAINING}s remaining — feed items: ${FEED_COUNT}"
+  fi
+done
+
+ok "Recording capture complete"
+
+# Check what we captured
+FEED_COUNT=$(curl -sf http://localhost:9500/feed 2>/dev/null | python3 -c "import sys,json; print(len(json.load(sys.stdin).get('messages',[])))" 2>/dev/null || echo "?")
+log "Captured ${FEED_COUNT} feed items"
+
+# ── Phase 1e: Stop sinain (saves pending session) ───────────────────────────
+log "Stopping sinain (saving pending session)..."
+[ -n "$SENSE_PID" ] && kill "$SENSE_PID" 2>/dev/null || true
+SENSE_PID=""
+
+# Send SIGINT directly to the tsx/node process (not the pipe wrapper)
+# The pipe means $CORE_PID is sed, not tsx — so we pkill the actual process
+pkill -INT -f "tsx src/index.ts" 2>/dev/null || true
+log "Sent SIGINT to tsx, waiting for graceful shutdown..."
+sleep 10
+
+# Force if still alive
+pkill -9 -f "tsx src/index.ts" 2>/dev/null || true
+kill -9 "$CORE_PID" 2>/dev/null || true
+CORE_PID=""
+lsof -i :9500 -sTCP:LISTEN -t 2>/dev/null | xargs kill -9 2>/dev/null || true
+sleep 2
+
+# Close QuickTime
+osascript -e 'tell application "QuickTime Player" to quit' 2>/dev/null || true
+
+# Verify pending session was saved (or inline distillation already consumed it)
+if [ -f "$BENCH_DIR/pending-session.json" ]; then
+  PENDING_ITEMS=$(python3 -c "import json; print(len(json.load(open('$BENCH_DIR/pending-session.json')).get('items',[])))" 2>/dev/null || echo "?")
+  ok "Pending session saved: ${PENDING_ITEMS} items"
+elif [ -f "$BENCH_DIR/knowledge-graph.db" ]; then
+  ok "Inline distillation completed (pending-session.json already consumed)"
+else
+  warn "No pending-session.json and no knowledge-graph.db — will retry with longer shutdown"
+  # Try again: start core briefly, let it capture a few items, then shut down gracefully
+  log "Starting core for a brief capture + shutdown cycle..."
+  (cd "$SINAIN_ROOT/sinain-core" && npx tsx src/index.ts 2>&1) > /tmp/sinain-bench-retry.log &
+  RETRY_PID=$!
+  sleep 15  # let it start and capture a few items
+  # Get the actual node PID and send SIGINT
+  NODE_PID=$(pgrep -f "tsx src/index.ts" 2>/dev/null | head -1 || true)
+  if [ -n "$NODE_PID" ]; then
+    kill -INT "$NODE_PID" 2>/dev/null || true
+    sleep 10
+    kill -9 "$NODE_PID" 2>/dev/null || true
+  fi
+  kill -9 "$RETRY_PID" 2>/dev/null || true
+  lsof -i :9500 -sTCP:LISTEN -t 2>/dev/null | xargs kill -9 2>/dev/null || true
+  sleep 2
+  if [ -f "$BENCH_DIR/pending-session.json" ] || [ -f "$BENCH_DIR/knowledge-graph.db" ]; then
+    ok "Recovery succeeded"
+  else
+    fail "Could not capture any session data"
+  fi
+fi
+
+# ── Phase 1f: Restart for distillation ───────────────────────────────────────
+log "Restarting sinain-core for distillation..."
+(cd "$SINAIN_ROOT/sinain-core" && npx tsx src/index.ts 2>&1) | \
+  sed -u "s/^/$(printf "${CYAN}[core]${RESET}    ")/" &
+CORE_PID=$!
+
+# Wait for health
+for i in $(seq 1 20); do
+  if curl -sf http://localhost:9500/health >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+
+# Wait for distillation to complete (knowledge-graph.db appears or grows)
+log "Waiting for distillation..."
+for i in $(seq 1 120); do
+  if [ -f "$BENCH_DIR/knowledge-graph.db" ]; then
+    DB_SIZE=$(stat -f%z "$BENCH_DIR/knowledge-graph.db" 2>/dev/null || echo "0")
+    if [ "$DB_SIZE" -gt 4096 ]; then
+      ok "Distillation complete (DB: ${DB_SIZE} bytes)"
+      break
+    fi
+  fi
+  # Also check if pending-session.json is gone (distillation consumed it)
+  if [ ! -f "$BENCH_DIR/pending-session.json" ] && [ -f "$BENCH_DIR/knowledge-graph.db" ]; then
+    DB_SIZE=$(stat -f%z "$BENCH_DIR/knowledge-graph.db" 2>/dev/null || echo "0")
+    ok "Distillation complete (DB: ${DB_SIZE} bytes)"
+    break
+  fi
+  sleep 5
+done
+
+# Keep core running for /embed endpoint during evaluation
+log "Keeping sinain-core running for embedding service during evaluation..."
+
+# ── Phase 2: Evaluate ────────────────────────────────────────────────────────
+log ""
+log "═══════════════════════════════════════════════"
+log "  Phase 2: Evaluation"
+log "═══════════════════════════════════════════════"
+log ""
+
+DB_PATH="$BENCH_DIR/knowledge-graph.db"
+if [ ! -f "$DB_PATH" ]; then
+  fail "No knowledge-graph.db found — distillation may have failed"
+fi
+
+# Show what's in the DB
+log "Knowledge graph contents:"
+cd "$KOOG_DIR"
+python3 -c "
+from triplestore import TripleStore
+ts = TripleStore('$DB_PATH')
+facts = ts.all_facts()
+print(f'  Total facts: {len(facts)}')
+entities = set()
+for f in facts:
+    entities.add(f.get('entity', ''))
+print(f'  Unique entities: {len(entities)}')
+for e in sorted(entities)[:10]:
+    print(f'    - {e}')
+if len(entities) > 10:
+    print(f'    ... and {len(entities) - 10} more')
+" 2>/dev/null || warn "Could not inspect DB"
+
+# Run evaluation
+log "Running QA evaluation..."
+python3 eval/benchmarks/meeting_runner.py \
+    --db "$DB_PATH" \
+    --conditions sinain-memory,full-context \
+    --format json,markdown
+
+log ""
+log "═══════════════════════════════════════════════"
+log "  Done!"
+log "  Results: eval/benchmarks/results/meeting_results.md"
+log "  DB: $DB_PATH"
+log "═══════════════════════════════════════════════"

package/sinain-memory/eval/benchmarks/runner.py

@@ -113,10 +113,17 @@ def run_benchmark(
     for idx, (inst, question) in enumerate(all_questions):
         qid = question.id
 
-        # Skip if already done
+        # Skip if already done (with all conditions scored)
         if qid in completed:
-            details.append(completed[qid])
-            continue
+            prev = completed[qid]
+            all_scored = all(
+                prev.get("answers", {}).get(c, {}).get("score") is not None
+                for c in conditions
+            )
+            if all_scored:
+                details.append(prev)
+                continue
+            # Otherwise re-run this question (previous attempt had failures)
 
         print(f"[{idx+1}/{total}] {qid} [{question.category}]")
 

package/sinain-memory/graph_query.py

@@ -129,27 +129,269 @@ def query_top_facts(db_path: str, limit: int = 30) -> list[dict]:
         return []
 
 
+def query_facts_fts(db_path: str, query: str, max_facts: int = 10) -> list[dict]:
+    """Full-text search on fact values via FTS5 index.
+
+    Returns facts whose value field matches the query keywords.
+    Falls back to LIKE search if FTS5 is not available.
+    """
+    if not Path(db_path).exists():
+        return []
+
+    try:
+        from triplestore import TripleStore
+        store = TripleStore(db_path)
+
+        # Try FTS5 first
+        try:
+            rows = store._conn.execute(
+                """SELECT DISTINCT t.entity_id
+                   FROM triples_fts fts
+                   JOIN triples t ON fts.rowid = t.id
+                   WHERE triples_fts MATCH ?
+                     AND t.attribute = 'value'
+                     AND NOT t.retracted
+                   LIMIT ?""",
+                (query, max_facts),
+            ).fetchall()
+        except Exception:
+            # FTS5 not available — fall back to LIKE search
+            keywords = [w.lower() for w in query.split() if len(w) > 2]
+            if not keywords:
+                store.close()
+                return []
+            # Match any keyword in value
+            conditions = " OR ".join(["LOWER(value) LIKE ?"] * len(keywords))
+            params = [f"%{k}%" for k in keywords] + [max_facts]
+            rows = store._conn.execute(
+                f"""SELECT DISTINCT entity_id
+                    FROM triples
+                    WHERE attribute = 'value'
+                      AND NOT retracted
+                      AND ({conditions})
+                    LIMIT ?""",
+                params,
+            ).fetchall()
+
+        entity_ids = [r["entity_id"] for r in rows]
+        if not entity_ids:
+            store.close()
+            return []
+
+        # Fetch full attributes for matched entities
+        facts = []
+        for eid in entity_ids:
+            attrs = store.entity(eid)
+            fact = {"entity_id": eid, "entity": eid.split(":")[-1].rsplit("-", 1)[0] if ":" in eid else eid}
+            for attr, values in attrs.items():
+                if attr == "tag":
+                    continue
+                fact[attr] = values[0] if len(values) == 1 else values
+            facts.append(fact)
+
+        store.close()
+        return facts[:max_facts]
+    except Exception:
+        return []
+
+
+def query_facts_by_entity_graph(
+    db_path: str,
+    entity_name: str,
+    max_facts: int = 10,
+) -> list[dict]:
+    """Find facts about an entity via VAET backref traversal.
+
+    Uses the entity graph layer: entity:* nodes linked to fact:* nodes
+    via 'about' ref edges. Also follows 'mentions' ref edges for
+    cross-entity context.
+    """
+    if not Path(db_path).exists():
+        return []
+
+    try:
+        from triplestore import TripleStore
+        store = TripleStore(db_path)
+
+        entity_node_id = f"entity:{entity_name.lower().replace(' ', '-')}"
+        if not store.entity(entity_node_id):
+            store.close()
+            return []
+
+        # Get all facts linked to this entity via "about" ref edge
+        fact_refs = store.backrefs(entity_node_id, attribute="about")
+        # Also get facts that "mention" this entity
+        mention_refs = store.backrefs(entity_node_id, attribute="mentions")
+        all_refs = fact_refs + mention_refs
+
+        # Load fact details
+        seen = set()
+        facts = []
+        for fact_eid, _ in all_refs:
+            if fact_eid in seen or not fact_eid.startswith("fact:"):
+                continue
+            seen.add(fact_eid)
+            attrs = store.entity(fact_eid)
+            if attrs and "value" in attrs:
+                fact = {"entity_id": fact_eid}
+                for attr, values in attrs.items():
+                    if attr == "tag":
+                        continue
+                    fact[attr] = values[0] if len(values) == 1 else values
+                facts.append(fact)
+
+        store.close()
+        return facts[:max_facts]
+    except Exception:
+        return []
+
+
+def query_facts_hybrid(
+    db_path: str,
+    query: str,
+    max_facts: int = 10,
+) -> list[dict]:
+    """Hybrid retrieval with Reciprocal Rank Fusion (Graphiti pattern).
+
+    Runs three independent retrieval methods, fuses via RRF, then
+    expands top results with 1-hop graph neighbors.
+    """
+    import re
+    keywords = [w.lower() for w in re.findall(r"[a-zA-Z][a-zA-Z0-9-]+", query) if len(w) > 2]
+
+    # Entity graph pre-filter: find facts linked to mentioned entities via backrefs.
+    # Used to BOOST relevant facts in RRF, not as a separate tier (avoids dilution).
+    graph_fact_ids: set[str] = set()
+    for kw in keywords:
+        for f in query_facts_by_entity_graph(db_path, kw, max_facts=50):
+            eid = f.get("entity_id", "")
+            if eid:
+                graph_fact_ids.add(eid)
+
+    # Run three retrieval methods independently
+    candidate_limit = max_facts * 3
+    fts_results = query_facts_fts(db_path, query, max_facts=candidate_limit)
+    tag_results = query_facts_by_entities(db_path, keywords, max_facts=candidate_limit) if keywords else []
+    top_results = query_top_facts(db_path, limit=candidate_limit)
+
+    # Build ranked lists by entity_id
+    def _ranked_ids(facts: list[dict]) -> list[str]:
+        seen = set()
+        out = []
+        for f in facts:
+            eid = f.get("entity_id", "")
+            if eid and eid not in seen:
+                seen.add(eid)
+                out.append(eid)
+        return out
+
+    fts_ranked = _ranked_ids(fts_results)
+    tag_ranked = _ranked_ids(tag_results)
+    top_ranked = _ranked_ids(top_results)
+
+    # Reciprocal Rank Fusion: RRF(d) = Σ 1/(k + rank_i(d))
+    K = 60  # standard RRF constant
+    rrf_scores: dict[str, float] = {}
+    for ranked_list in [fts_ranked, tag_ranked, top_ranked]:
+        for rank, eid in enumerate(ranked_list):
+            rrf_scores[eid] = rrf_scores.get(eid, 0.0) + 1.0 / (K + rank)
+
+    # Graph boost: facts linked to mentioned entities via backrefs get priority
+    if graph_fact_ids:
+        for eid in rrf_scores:
+            if eid in graph_fact_ids:
+                rrf_scores[eid] += 0.02  # significant boost — graph-linked facts rank higher
+
+    # Apply confidence decay as secondary signal (fresh facts rank above stale ones)
+    from triplestore import decayed_confidence
+    for facts_list in [fts_results, tag_results, top_results]:
+        for f in facts_list:
+            eid = f.get("entity_id", "")
+            if eid in rrf_scores:
+                conf = 0.5
+                created = ""
+                try:
+                    conf = float(f.get("confidence", 0.5))
+                    created = str(f.get("first_seen", ""))
+                except (ValueError, TypeError):
+                    pass
+                if created:
+                    effective = decayed_confidence(conf, created)
+                    rrf_scores[eid] += effective * 0.01  # small boost, preserves RRF rank
+
+    # Sort by RRF score descending
+    sorted_ids = sorted(rrf_scores, key=rrf_scores.get, reverse=True)
+
+    # Build fact lookup from all candidates
+    fact_map: dict[str, dict] = {}
+    for facts in [fts_results, tag_results, top_results]:
+        for f in facts:
+            eid = f.get("entity_id", "")
+            if eid and eid not in fact_map:
+                fact_map[eid] = f
+
+    results = [fact_map[eid] for eid in sorted_ids[:max_facts] if eid in fact_map]
+
+    # Expand top results with 1-hop graph neighbors
+    if results and len(results) < max_facts:
+        seen_ids = {f.get("entity_id", "") for f in results}
+        try:
+            from triplestore import TripleStore
+            store = TripleStore(db_path)
+            for fact in list(results):
+                eid = fact.get("entity_id", "")
+                if not eid:
+                    continue
+                neighbors = store.neighbors(eid, depth=1)
+                for nid, nattrs in neighbors.items():
+                    if nid not in seen_ids and len(results) < max_facts:
+                        seen_ids.add(nid)
+                        nfact = {"entity_id": nid, "entity": nid.split(":")[-1].rsplit("-", 1)[0] if ":" in nid else nid}
+                        for attr, values in nattrs.items():
+                            if attr != "tag":
+                                nfact[attr] = values[0] if len(values) == 1 else values
+                        results.append(nfact)
+            store.close()
+        except Exception:
+            pass
+
+    return results[:max_facts]
+
+
 def format_facts_text(facts: list[dict], max_chars: int = 500) -> str:
-    """Format facts as human-readable text for escalation message injection."""
+    """Format facts grouped by entity for better cross-fact reasoning.
+
+    Groups related facts under entity headers so the QA model sees
+    connected context (e.g., all Citibank facts together).
+    """
     if not facts:
         return ""
 
-    lines = []
-    total = 0
+    # Group by entity name (strip fact: prefix and hash suffix)
+    from collections import OrderedDict
+    groups: OrderedDict[str, list[dict]] = OrderedDict()
     for f in facts:
-        value = f.get("value", "")
-        conf = f.get("confidence", "?")
-        count = f.get("reinforce_count", "1")
-        domain = f.get("domain", "")
-
-        line = f"- {value} (confidence: {conf}, confirmed {count}x)"
-        if domain:
-            line = f"- [{domain}] {value} (confidence: {conf}, confirmed {count}x)"
+        entity = f.get("entity", "")
+        if isinstance(entity, list):
+            entity = entity[0] if entity else ""
+        if not entity:
+            eid = str(f.get("entity_id", ""))
+            entity = eid.split(":")[-1].rsplit("-", 1)[0] if ":" in eid else eid
+        groups.setdefault(str(entity), []).append(f)
 
-        if total + len(line) > max_chars:
-            break
-        lines.append(line)
-        total += len(line)
+    lines = []
+    total = 0
+    for entity, group_facts in groups.items():
+        for f in group_facts:
+            value = f.get("value", "")
+            conf = f.get("confidence", "?")
+            count = f.get("reinforce_count", "1")
+
+            line = f"- [{entity}] {value} (conf: {conf}, {count}x)"
+            if total + len(line) > max_chars:
+                return "\n".join(lines)
+            lines.append(line)
+            total += len(line)
 
     return "\n".join(lines)