@geravant/sinain 1.13.0 → 1.14.0

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

@@ -1,193 +0,0 @@
-"""Query pipeline — benchmark questions → LLM answers under 3 conditions.
-
-Condition A (sinain-memory): answer from knowledge graph facts
-Condition B (full-context):  answer from full conversation history
-Condition C (knowledge-doc): answer from portable knowledge document
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-# Add sinain-memory to path
-_koog_dir = str(Path(__file__).resolve().parent.parent.parent)
-if _koog_dir not in sys.path:
-    sys.path.insert(0, _koog_dir)
-
-from common import call_llm  # noqa: E402
-
-from .base_adapter import BenchmarkQuestion
-from .config import QA_MODEL, MAX_FACTS_PER_QUERY
-
-
-def _extract_keywords(query: str) -> list[str]:
-    """Extract search keywords (reuses logic from retrieval_evaluator)."""
-    import re
-    words = re.findall(r"[a-zA-Z][a-zA-Z0-9-]+", query.lower())
-    stopwords = {
-        "the", "is", "in", "on", "for", "and", "or", "of", "to", "a", "an",
-        "it", "was", "not", "how", "what", "when", "does", "did", "do", "my",
-        "your", "their", "have", "has", "had", "are", "were", "been", "being",
-        "about", "from", "with", "that", "this", "which", "who", "whom",
-        "where", "why", "can", "could", "would", "should",
-    }
-    return [w for w in words if len(w) > 2 and w not in stopwords]
-
-
-def _get_all_facts_text(db_path: str) -> str:
-    """Dump ALL facts from the knowledge graph as formatted text.
-
-    Sinain triplestores are small (10-50 facts per session), so including
-    everything is feasible and avoids tag-matching failures.
-    """
-    from graph_query import query_top_facts, format_facts_text
-
-    facts = query_top_facts(db_path, limit=50)
-    if not facts:
-        return "(no knowledge available)"
-    return format_facts_text(facts, max_chars=6000)
-
-
-def _query_knowledge(db_path: str, question: str) -> str:
-    """Query sinain knowledge graph for facts relevant to a question.
-
-    Strategy: retrieve broadly, then re-rank by keyword overlap with the question.
-    This ensures specific facts (CTO background) beat generic ones (meeting schedule)
-    when the question asks about the CTO.
-    """
-    from graph_query import query_facts_hybrid, query_top_facts, format_facts_text
-
-    # Retrieve a broad candidate set
-    candidates = query_facts_hybrid(db_path, question, max_facts=30)
-    if not candidates:
-        candidates = query_top_facts(db_path, limit=30)
-    if not candidates:
-        return "(no knowledge available)"
-
-    # Re-rank by embedding similarity if available, fall back to keyword overlap
-    try:
-        from embed_client import rank_by_similarity
-        fact_texts = [str(f.get("value", "")) for f in candidates]
-        ranked_indices = rank_by_similarity(question, fact_texts)
-        if ranked_indices is not None:
-            ranked = [candidates[i] for i, _ in ranked_indices[:MAX_FACTS_PER_QUERY]]
-            return format_facts_text(ranked, max_chars=3000)
-    except Exception:
-        pass
-
-    # Fallback: keyword overlap ranking
-    q_keywords = set(_extract_keywords(question))
-    def _relevance(fact: dict) -> float:
-        value = str(fact.get("value", "")).lower()
-        entity = str(fact.get("entity", "")).lower()
-        fact_words = set(_extract_keywords(value + " " + entity))
-        if not q_keywords:
-            return 0.0
-        return len(q_keywords & fact_words) / len(q_keywords)
-
-    ranked = sorted(candidates, key=_relevance, reverse=True)
-    return format_facts_text(ranked[:MAX_FACTS_PER_QUERY], max_chars=3000)
-
-
-def _get_retrieved_facts(db_path: str, question: str, k: int = 10) -> list[dict]:
-    """Get facts retrieved for a question (for retrieval evaluation)."""
-    from graph_query import query_facts_hybrid, query_top_facts
-
-    facts = query_facts_hybrid(db_path, question, max_facts=k)
-    if facts:
-        return facts
-
-    # Fallback: top facts by confidence
-    return query_top_facts(db_path, limit=k)
-
-
-def compute_content_recall(
-    retrieved_facts: list[dict],
-    gold_answer: str,
-    k_values: list[int] | None = None,
-) -> dict:
-    """Content-based retrieval metric: do retrieved facts contain the answer?
-
-    Instead of matching entity IDs (which don't align between LongMemEval
-    session IDs and sinain entity IDs), we check whether the gold answer's
-    key terms appear in any retrieved fact's content.
-    """
-    from .config import K_VALUES
-    ks = k_values or K_VALUES
-
-    gold_terms = set(_extract_keywords(str(gold_answer)))
-    if not gold_terms:
-        return {f"content_recall@{k}": 0.0 for k in ks}
-
-    result = {}
-    for k in ks:
-        top_k = retrieved_facts[:k]
-        # Check if any fact in top-k contains gold answer terms
-        for fact in top_k:
-            fact_text = f"{fact.get('entity', '')} {fact.get('value', '')}".lower()
-            fact_terms = set(_extract_keywords(fact_text))
-            overlap = gold_terms & fact_terms
-            if len(overlap) >= max(1, len(gold_terms) // 2):  # ≥50% of gold terms
-                result[f"content_recall@{k}"] = 1.0
-                break
-        else:
-            result[f"content_recall@{k}"] = 0.0
-
-    return result
-
-
-def answer_question(
-    question: BenchmarkQuestion,
-    condition: str,
-    *,
-    db_path: str | None = None,
-    full_context: str | None = None,
-    knowledge_doc: str | None = None,
-    model: str | None = None,
-) -> str:
-    """Generate an answer for a benchmark question under a specific condition.
-
-    Returns the LLM's answer text.
-    """
-    qa_model = model or QA_MODEL
-
-    if condition == "sinain-memory":
-        assert db_path, "db_path required for sinain-memory condition"
-        facts = _query_knowledge(db_path, question.text)
-        system = (
-            "Answer the question using ONLY the provided knowledge facts. "
-            "If the facts don't contain enough information to answer, say \"I don't know.\""
-        )
-        user = f"## Knowledge Facts\n{facts}\n\n## Question\n{question.text}"
-
-    elif condition == "full-context":
-        assert full_context, "full_context required for full-context condition"
-        system = (
-            "Answer the question based on the conversation history below. "
-            "Be concise and specific."
-        )
-        # Truncate context if too large (some models have limits)
-        ctx = full_context[:100_000] if len(full_context) > 100_000 else full_context
-        user = f"## Conversation History\n{ctx}\n\n## Question\n{question.text}"
-
-    elif condition == "knowledge-doc":
-        assert knowledge_doc, "knowledge_doc required for knowledge-doc condition"
-        system = (
-            "Answer the question using ONLY the knowledge document provided. "
-            "If the document doesn't contain enough information, say \"I don't know.\""
-        )
-        user = f"## Knowledge Document\n{knowledge_doc}\n\n## Question\n{question.text}"
-
-    else:
-        raise ValueError(f"Unknown condition: {condition}")
-
-    try:
-        return call_llm(
-            system_prompt=system,
-            user_prompt=user,
-            model=qa_model,
-            max_tokens=300,
-        ).strip()
-    except Exception as e:
-        return f"(error: {e})"

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

@@ -1,87 +0,0 @@
-"""Report generation — markdown, JSON, and LaTeX output."""
-
-from __future__ import annotations
-
-import json
-from datetime import datetime, timezone
-
-
-def generate_markdown(benchmark_name: str, summary: dict, details: list[dict]) -> str:
-    """Generate a publishable markdown report."""
-    lines = [
-        f"# Sinain Knowledge Graph — {benchmark_name} Results",
-        f"\nGenerated: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')}",
-        "",
-    ]
-
-    # Headline IPR
-    ipr = summary.get("ipr")
-    if ipr:
-        lines.append(f"**Information Preservation Rate (IPR)**: {ipr:.1%}")
-        lines.append("")
-
-    # Condition scores table
-    conditions = summary.get("conditions", {})
-    if conditions:
-        cond_names = sorted(conditions.keys())
-        header = "| Condition | Mean Score (1-5) | Mean F1 | N |"
-        sep = "|-----------|------------------|---------|---|"
-        lines.extend([header, sep])
-        for cond in cond_names:
-            c = conditions[cond]
-            lines.append(f"| {cond} | {c['mean_score']:.2f} | {c.get('mean_f1', 0):.2f} | {c['n']} |")
-        lines.append("")
-
-    # Retrieval metrics
-    retrieval = summary.get("retrieval", {})
-    if retrieval:
-        lines.append("## Retrieval Quality")
-        lines.append("| Metric | Score |")
-        lines.append("|--------|-------|")
-        for k, v in sorted(retrieval.items()):
-            lines.append(f"| {k} | {v:.1%} |")
-        lines.append("")
-
-    # Category breakdown
-    categories = summary.get("categories", {})
-    if categories:
-        lines.append("## By Category")
-        cond_names = sorted(set(c for cat in categories.values() for c in cat))
-        header = "| Category | " + " | ".join(cond_names) + " |"
-        sep = "|----------|" + "|".join(["------"] * len(cond_names)) + "|"
-        lines.extend([header, sep])
-        for cat in sorted(categories):
-            cells = []
-            for cond in cond_names:
-                if cond in categories[cat]:
-                    cells.append(f"{categories[cat][cond]['mean_score']:.2f} (n={categories[cat][cond]['n']})")
-                else:
-                    cells.append("-")
-            lines.append(f"| {cat} | " + " | ".join(cells) + " |")
-        lines.append("")
-
-    # Failures (worst questions)
-    if details:
-        sm_details = [d for d in details if d.get("answers", {}).get("sinain-memory", {}).get("score") is not None]
-        sm_details.sort(key=lambda d: d["answers"]["sinain-memory"]["score"])
-        if sm_details:
-            lines.append("## Hardest Questions for sinain-memory (bottom 5)")
-            for d in sm_details[:5]:
-                sm = d["answers"]["sinain-memory"]
-                fc = d["answers"].get("full-context", {})
-                lines.append(f"- **{d['id']}** [{d['category']}]: score={sm['score']}/5 "
-                             f"(full-context: {fc.get('score', '?')}/5)")
-                lines.append(f"  Q: {d['question'][:100]}...")
-            lines.append("")
-
-    return "\n".join(lines)
-
-
-def generate_json(benchmark_name: str, summary: dict, details: list[dict]) -> str:
-    """Generate JSON report."""
-    return json.dumps({
-        "benchmark": benchmark_name,
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "summary": summary,
-        "details": details,
-    }, indent=2, ensure_ascii=False)

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

@@ -1,318 +0,0 @@
-#!/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 "═══════════════════════════════════════════════"