nexo-brain 2.3.0 → 2.3.2

package/src/db/_schema 2.py

@@ -1,364 +0,0 @@
-"""NEXO DB — Schema module."""
-from db._core import get_db
-from db._fts import _migrate_add_column, _migrate_add_index
-
-# ── Formal Migration System ─────────────────────────────────────
-#
-# Each migration is (version, name, callable). Migrations run once
-# and are tracked in schema_migrations. The version number MUST be
-# strictly increasing. Add new migrations at the end of the list.
-#
-# For users upgrading via npm/git, init_db() calls run_migrations()
-# automatically — no manual steps needed.
-
-def _m1_learnings_columns(conn):
-    _migrate_add_column(conn, "learnings", "reasoning", "TEXT")
-    _migrate_add_column(conn, "learnings", "prevention", "TEXT DEFAULT ''")
-    _migrate_add_column(conn, "learnings", "applies_to", "TEXT DEFAULT ''")
-    _migrate_add_column(conn, "learnings", "status", "TEXT DEFAULT 'active'")
-    _migrate_add_column(conn, "learnings", "review_due_at", "REAL")
-    _migrate_add_column(conn, "learnings", "last_reviewed_at", "REAL")
-
-def _m2_followups_reasoning(conn):
-    _migrate_add_column(conn, "followups", "reasoning", "TEXT")
-    _migrate_add_column(conn, "task_history", "reasoning", "TEXT")
-
-def _m3_decisions_review(conn):
-    _migrate_add_column(conn, "decisions", "status", "TEXT DEFAULT 'pending_review'")
-    _migrate_add_column(conn, "decisions", "review_due_at", "TEXT")
-    _migrate_add_column(conn, "decisions", "last_reviewed_at", "TEXT")
-    _migrate_add_index(conn, "idx_decisions_domain", "decisions", "domain")
-    _migrate_add_index(conn, "idx_decisions_created", "decisions", "created_at")
-    _migrate_add_index(conn, "idx_decisions_review_due", "decisions", "review_due_at")
-
-def _m4_session_diary_columns(conn):
-    _migrate_add_index(conn, "idx_session_diary_sid", "session_diary", "session_id")
-    _migrate_add_column(conn, "session_diary", "mental_state", "TEXT")
-    _migrate_add_column(conn, "session_diary", "domain", "TEXT")
-    _migrate_add_column(conn, "session_diary", "user_signals", "TEXT")
-    _migrate_add_column(conn, "session_diary", "self_critique", "TEXT")
-
-def _m5_change_log_indexes(conn):
-    _migrate_add_index(conn, "idx_change_log_created", "change_log", "created_at")
-    _migrate_add_index(conn, "idx_change_log_files", "change_log", "files")
-    _migrate_add_index(conn, "idx_learnings_status", "learnings", "status")
-    _migrate_add_index(conn, "idx_learnings_review_due", "learnings", "review_due_at")
-
-def _m6_error_guard_tables(conn):
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS error_repetitions (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            new_learning_id INTEGER NOT NULL,
-            original_learning_id INTEGER NOT NULL,
-            similarity REAL NOT NULL,
-            area TEXT NOT NULL,
-            created_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS guard_checks (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            session_id TEXT,
-            files TEXT,
-            area TEXT,
-            learnings_returned INTEGER DEFAULT 0,
-            blocking_rules_returned INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    _migrate_add_index(conn, "idx_error_repetitions_area", "error_repetitions", "area")
-    _migrate_add_index(conn, "idx_guard_checks_session", "guard_checks", "session_id")
-
-def _m7_diary_source_and_draft(conn):
-    _migrate_add_column(conn, "session_diary", "source", "TEXT DEFAULT 'claude'")
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS session_diary_draft (
-            sid TEXT PRIMARY KEY,
-            summary_draft TEXT DEFAULT '',
-            tasks_seen TEXT DEFAULT '[]',
-            change_ids TEXT DEFAULT '[]',
-            decision_ids TEXT DEFAULT '[]',
-            last_context_hint TEXT DEFAULT '',
-            heartbeat_count INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now')),
-            updated_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-
-
-def _m8_adaptive_log_and_somatic(conn):
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS adaptive_log (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            timestamp TEXT DEFAULT (datetime('now')),
-            mode TEXT NOT NULL,
-            tension_score REAL NOT NULL,
-            sig_vibe REAL DEFAULT 0,
-            sig_corrections REAL DEFAULT 0,
-            sig_brevity REAL DEFAULT 0,
-            sig_topic REAL DEFAULT 0,
-            sig_tool_errors REAL DEFAULT 0,
-            sig_git_diff REAL DEFAULT 0,
-            context_hint TEXT DEFAULT '',
-            feedback_event TEXT DEFAULT NULL,
-            feedback_delta INTEGER DEFAULT NULL,
-            feedback_ts TEXT DEFAULT NULL
-        )
-    """)
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_adaptive_log_ts ON adaptive_log(timestamp)")
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS somatic_events (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            timestamp TEXT DEFAULT (datetime('now')),
-            target TEXT NOT NULL,
-            target_type TEXT NOT NULL,
-            event_type TEXT NOT NULL,
-            delta REAL NOT NULL,
-            source TEXT DEFAULT '',
-            projected INTEGER DEFAULT 0
-        )
-    """)
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_events_target ON somatic_events(target)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_somatic_events_projected ON somatic_events(projected)")
-
-
-def _m11_artifact_registry(conn):
-    """Artifact Registry — structured index of things NEXO creates/deploys.
-
-    Solves 'recent work amnesia': services, dashboards, scripts, APIs that
-    NEXO builds but can't find hours later because semantic search fails on
-    operational vocabulary mismatches (e.g., 'backend' vs 'FastAPI localhost:6174').
-
-    Design informed by 3-way AI debate (GPT-5.4 + Gemini 3.1 Pro + Claude Opus 4.6).
-    Key insight: operational facts need first-class structured storage, not just
-    vector embeddings buried in prose diaries.
-    """
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS artifact_registry (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            kind TEXT NOT NULL,
-            canonical_name TEXT NOT NULL,
-            aliases TEXT DEFAULT '[]',
-            description TEXT DEFAULT '',
-            uri TEXT DEFAULT '',
-            ports TEXT DEFAULT '[]',
-            paths TEXT DEFAULT '[]',
-            run_cmd TEXT DEFAULT '',
-            repo TEXT DEFAULT '',
-            domain TEXT DEFAULT '',
-            state TEXT DEFAULT 'active',
-            session_id TEXT DEFAULT '',
-            created_at TEXT DEFAULT (datetime('now')),
-            last_touched_at TEXT DEFAULT (datetime('now')),
-            last_verified_at TEXT DEFAULT NULL,
-            metadata TEXT DEFAULT '{}'
-        )
-    """)
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS artifact_aliases (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            artifact_id INTEGER NOT NULL REFERENCES artifact_registry(id) ON DELETE CASCADE,
-            phrase TEXT NOT NULL,
-            source TEXT DEFAULT 'manual',
-            confidence REAL DEFAULT 1.0,
-            created_at TEXT DEFAULT (datetime('now')),
-            UNIQUE(artifact_id, phrase)
-        )
-    """)
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_state ON artifact_registry(state)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_kind ON artifact_registry(kind)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_domain ON artifact_registry(domain)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_last_touched ON artifact_registry(last_touched_at)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_aliases_phrase ON artifact_aliases(phrase)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_artifact_aliases_aid ON artifact_aliases(artifact_id)")
-
-
-def _m10_diary_archive(conn):
-    """Permanent diary archive — diaries are never truly deleted, just moved here."""
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS diary_archive (
-            id INTEGER PRIMARY KEY,
-            session_id TEXT NOT NULL,
-            created_at TEXT NOT NULL,
-            decisions TEXT NOT NULL,
-            discarded TEXT,
-            pending TEXT,
-            context_next TEXT,
-            summary TEXT NOT NULL,
-            mental_state TEXT,
-            domain TEXT,
-            user_signals TEXT,
-            self_critique TEXT DEFAULT '',
-            source TEXT DEFAULT 'claude',
-            archived_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    conn.execute("""
-        CREATE INDEX IF NOT EXISTS idx_diary_archive_created
-        ON diary_archive (created_at)
-    """)
-    conn.execute("""
-        CREATE INDEX IF NOT EXISTS idx_diary_archive_domain
-        ON diary_archive (domain)
-    """)
-
-
-def _m9_maintenance_schedule(conn):
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS maintenance_schedule (
-            task_name TEXT PRIMARY KEY,
-            interval_hours REAL NOT NULL,
-            last_run_at TEXT DEFAULT NULL,
-            last_duration_ms INTEGER DEFAULT 0,
-            run_count INTEGER DEFAULT 0
-        )
-    """)
-    tasks = [
-        ('cognitive_decay', 20), ('synthesis', 20), ('self_audit', 144),
-        ('weight_learning', 20), ('somatic_projection', 20), ('somatic_decay', 20),
-        ('graph_maintenance', 48),
-    ]
-    for name, hours in tasks:
-        conn.execute(
-            "INSERT OR IGNORE INTO maintenance_schedule (task_name, interval_hours) VALUES (?, ?)",
-            (name, hours)
-        )
-
-
-def _m12_session_checkpoints(conn):
-    """Session checkpoints for intelligent auto-compaction.
-
-    PreCompact saves a checkpoint; PostCompact reads it to re-inject a
-    Core Memory Block that preserves continuity after context compression.
-    """
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS session_checkpoints (
-            sid TEXT PRIMARY KEY,
-            task TEXT DEFAULT '',
-            task_status TEXT DEFAULT 'active',
-            active_files TEXT DEFAULT '[]',
-            current_goal TEXT DEFAULT '',
-            decisions_summary TEXT DEFAULT '',
-            errors_found TEXT DEFAULT '',
-            reasoning_thread TEXT DEFAULT '',
-            next_step TEXT DEFAULT '',
-            compaction_count INTEGER DEFAULT 0,
-            created_at TEXT DEFAULT (datetime('now')),
-            updated_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-
-
-def _m13_claude_session_id(conn):
-    """Add claude_session_id to sessions for inter-terminal coordination (D+)."""
-    _migrate_add_column(conn, "sessions", "claude_session_id", "TEXT DEFAULT ''")
-    _migrate_add_index(conn, "idx_sessions_claude_sid", "sessions", "claude_session_id")
-    conn.commit()
-
-
-def _m14_learnings_priority_weight(conn):
-    """Add priority, weight, and guard usage tracking to learnings + followup priority."""
-    _migrate_add_column(conn, "learnings", "priority", "TEXT DEFAULT 'medium'")
-    _migrate_add_column(conn, "learnings", "weight", "REAL DEFAULT 0.5")
-    _migrate_add_column(conn, "learnings", "guard_hits", "INTEGER DEFAULT 0")
-    _migrate_add_column(conn, "learnings", "last_guard_hit_at", "REAL")
-    _migrate_add_column(conn, "followups", "priority", "TEXT DEFAULT 'medium'")
-
-
-def _m15_core_rules_tables(conn):
-    """Core rules and version tracking tables for the core_rules plugin."""
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS core_rules (
-            id TEXT PRIMARY KEY,
-            category TEXT NOT NULL,
-            rule TEXT NOT NULL,
-            why TEXT NOT NULL,
-            importance INTEGER NOT NULL DEFAULT 3,
-            type TEXT NOT NULL DEFAULT 'advisory',
-            added_in TEXT DEFAULT '',
-            removed_in TEXT DEFAULT NULL,
-            is_active INTEGER NOT NULL DEFAULT 1
-        )
-    """)
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS core_rules_version (
-            id INTEGER PRIMARY KEY,
-            version TEXT NOT NULL DEFAULT '0.0.0',
-            updated_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    # Seed the version row so UPDATE statements in the plugin always find it
-    conn.execute(
-        "INSERT OR IGNORE INTO core_rules_version (id, version) VALUES (1, '0.0.0')"
-    )
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_core_rules_category ON core_rules(category)")
-    conn.execute("CREATE INDEX IF NOT EXISTS idx_core_rules_active ON core_rules(is_active)")
-
-
-# Migration registry — APPEND ONLY, never reorder or delete
-MIGRATIONS = [
-    (1, "learnings_columns", _m1_learnings_columns),
-    (2, "followups_reasoning", _m2_followups_reasoning),
-    (3, "decisions_review", _m3_decisions_review),
-    (4, "session_diary_columns", _m4_session_diary_columns),
-    (5, "change_log_indexes", _m5_change_log_indexes),
-    (6, "error_guard_tables", _m6_error_guard_tables),
-    (7, "diary_source_and_draft", _m7_diary_source_and_draft),
-    (8, "adaptive_log_and_somatic", _m8_adaptive_log_and_somatic),
-    (9, "maintenance_schedule", _m9_maintenance_schedule),
-    (10, "diary_archive", _m10_diary_archive),
-    (11, "artifact_registry", _m11_artifact_registry),
-    (12, "session_checkpoints", _m12_session_checkpoints),
-    (13, "claude_session_id", _m13_claude_session_id),
-    (14, "learnings_priority_weight", _m14_learnings_priority_weight),
-    (15, "core_rules_tables", _m15_core_rules_tables),
-]
-
-
-def run_migrations(conn=None):
-    """Run pending migrations. Tracks applied versions in schema_migrations.
-
-    Safe to call multiple times — skips already-applied migrations.
-    Called automatically by init_db() on every server start.
-    """
-    if conn is None:
-        conn = get_db()
-
-    conn.execute("""
-        CREATE TABLE IF NOT EXISTS schema_migrations (
-            version INTEGER PRIMARY KEY,
-            name TEXT NOT NULL,
-            applied_at TEXT DEFAULT (datetime('now'))
-        )
-    """)
-    conn.commit()
-
-    applied = {r[0] for r in conn.execute("SELECT version FROM schema_migrations").fetchall()}
-
-    for version, name, fn in MIGRATIONS:
-        if version not in applied:
-            try:
-                fn(conn)
-                conn.execute(
-                    "INSERT INTO schema_migrations (version, name) VALUES (?, ?)",
-                    (version, name)
-                )
-                conn.commit()
-            except Exception as e:
-                # Log but don't crash — partial migration is better than no server
-                import sys
-                print(f"[MIGRATION] v{version} ({name}) failed: {e}", file=sys.stderr)
-
-    return len(MIGRATIONS) - len(applied)
-
-
-def get_schema_version() -> int:
-    """Return the highest applied migration version, or 0 if none."""
-    conn = get_db()
-    try:
-        row = conn.execute("SELECT MAX(version) FROM schema_migrations").fetchone()
-        return row[0] or 0
-    except Exception:
-        return 0
-
-

package/src/db/_sessions 2.py

@@ -1,300 +0,0 @@
-"""NEXO DB — Sessions module."""
-import time, secrets, string, sqlite3
-from datetime import datetime
-from db._core import get_db, _gen_id, now_epoch, local_time_str, SESSION_STALE_SECONDS, MESSAGE_TTL_SECONDS, QUESTION_TTL_SECONDS
-
-# ── Session operations ──────────────────────────────────────────────
-
-def now_epoch() -> float:
-    return time.time()
-
-
-def local_time_str() -> str:
-    from datetime import datetime
-    return datetime.now().strftime("%H:%M")
-
-
-def register_session(sid: str, task: str, claude_session_id: str = "") -> dict:
-    """Register or re-register a session."""
-    conn = get_db()
-    now = now_epoch()
-    conn.execute(
-        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id) "
-        "VALUES (?, ?, ?, ?, ?, ?)",
-        (sid, task, now, now, local_time_str(), claude_session_id)
-    )
-    conn.commit()
-    return {"sid": sid, "task": task}
-
-
-def update_session(sid: str, task: str | None) -> dict:
-    """Update session timestamp (and task if provided). Preserves started_epoch.
-
-    Args:
-        sid: Session ID.
-        task: New task description, or None to keep current task (keepalive touch).
-    """
-    conn = get_db()
-    now = now_epoch()
-    row = conn.execute("SELECT started_epoch, task FROM sessions WHERE sid = ?", (sid,)).fetchone()
-    if row:
-        effective_task = task if task is not None else row["task"]
-        conn.execute(
-            "UPDATE sessions SET task = ?, last_update_epoch = ?, local_time = ? WHERE sid = ?",
-            (effective_task, now, local_time_str(), sid)
-        )
-    else:
-        effective_task = task or "Unknown"
-        conn.execute(
-            "INSERT INTO sessions (sid, task, started_epoch, last_update_epoch, local_time) "
-            "VALUES (?, ?, ?, ?, ?)",
-            (sid, effective_task, now, now, local_time_str())
-        )
-    conn.commit()
-    return {"sid": sid, "task": effective_task}
-
-
-def complete_session(sid: str):
-    """Remove session and its tracked files."""
-    conn = get_db()
-    conn.execute("PRAGMA foreign_keys=ON")
-    conn.execute("DELETE FROM tracked_files WHERE sid = ?", (sid,))
-    conn.execute("DELETE FROM sessions WHERE sid = ?", (sid,))
-    conn.commit()
-
-
-def get_active_sessions() -> list[dict]:
-    """Get all sessions updated within STALE threshold."""
-    conn = get_db()
-    cutoff = now_epoch() - SESSION_STALE_SECONDS
-    rows = conn.execute(
-        "SELECT sid, task, started_epoch, last_update_epoch, local_time "
-        "FROM sessions WHERE last_update_epoch > ?",
-        (cutoff,)
-    ).fetchall()
-    return [dict(r) for r in rows]
-
-
-def clean_stale_sessions() -> int:
-    """Remove stale sessions. Returns count removed."""
-    conn = get_db()
-    cutoff = now_epoch() - SESSION_STALE_SECONDS
-    stale = conn.execute(
-        "SELECT sid FROM sessions WHERE last_update_epoch <= ?", (cutoff,)
-    ).fetchall()
-    for row in stale:
-        conn.execute("DELETE FROM tracked_files WHERE sid = ?", (row["sid"],))
-    result = conn.execute(
-        "DELETE FROM sessions WHERE last_update_epoch <= ?", (cutoff,)
-    )
-    count = result.rowcount
-    conn.commit()
-    return count
-
-
-def search_sessions(keyword: str) -> list[dict]:
-    """Find sessions whose task contains keyword (case-insensitive)."""
-    conn = get_db()
-    cutoff = now_epoch() - SESSION_STALE_SECONDS
-    rows = conn.execute(
-        "SELECT sid, task, last_update_epoch, local_time FROM sessions "
-        "WHERE last_update_epoch > ? AND LOWER(task) LIKE ?",
-        (cutoff, f"%{keyword.lower()}%")
-    ).fetchall()
-    return [dict(r) for r in rows]
-
-
-# ── File tracking ───────────────────────────────────────────────────
-
-def track_files(sid: str, paths: list[str]) -> dict:
-    """Track files for a session. Returns conflicts if any."""
-    conn = get_db()
-    now = now_epoch()
-    session = conn.execute("SELECT sid FROM sessions WHERE sid = ?", (sid,)).fetchone()
-    if not session:
-            return {"error": f"Session {sid} not found. Register first."}
-
-    for path in paths:
-        conn.execute(
-            "INSERT OR IGNORE INTO tracked_files (sid, path, tracked_at) VALUES (?, ?, ?)",
-            (sid, path, now)
-        )
-    conn.commit()
-    conflicts = _check_conflicts(conn, sid)
-    return {"tracked": paths, "conflicts": conflicts}
-
-
-def untrack_files(sid: str, paths: list[str] | None = None):
-    """Untrack files. If paths is None, untrack all."""
-    conn = get_db()
-    if paths:
-        for path in paths:
-            conn.execute(
-                "DELETE FROM tracked_files WHERE sid = ? AND path = ?",
-                (sid, path)
-            )
-    else:
-        conn.execute("DELETE FROM tracked_files WHERE sid = ?", (sid,))
-    conn.commit()
-
-
-def get_all_tracked_files() -> dict:
-    """Get all tracked files grouped by session."""
-    conn = get_db()
-    cutoff = now_epoch() - SESSION_STALE_SECONDS
-    rows = conn.execute(
-        "SELECT tf.sid, tf.path, s.task FROM tracked_files tf "
-        "JOIN sessions s ON tf.sid = s.sid "
-        "WHERE s.last_update_epoch > ?",
-        (cutoff,)
-    ).fetchall()
-    result = {}
-    for r in rows:
-        sid = r["sid"]
-        if sid not in result:
-            result[sid] = {"task": r["task"], "files": []}
-        result[sid]["files"].append(r["path"])
-    return result
-
-
-def _check_conflicts(conn: sqlite3.Connection, sid: str) -> list[dict]:
-    """Check if any of sid's files are tracked by other active sessions."""
-    cutoff = now_epoch() - SESSION_STALE_SECONDS
-    my_files = conn.execute(
-        "SELECT path FROM tracked_files WHERE sid = ?", (sid,)
-    ).fetchall()
-    my_paths = {r["path"] for r in my_files}
-    if not my_paths:
-        return []
-
-    conflicts = []
-    others = conn.execute(
-        "SELECT tf.sid, tf.path, s.task FROM tracked_files tf "
-        "JOIN sessions s ON tf.sid = s.sid "
-        "WHERE tf.sid != ? AND s.last_update_epoch > ?",
-        (sid, cutoff)
-    ).fetchall()
-    by_sid = {}
-    for r in others:
-        if r["path"] in my_paths:
-            osid = r["sid"]
-            if osid not in by_sid:
-                by_sid[osid] = {"sid": osid, "task": r["task"], "files": []}
-            by_sid[osid]["files"].append(r["path"])
-    return list(by_sid.values())
-
-
-# ── Messages ────────────────────────────────────────────────────────
-
-def send_message(from_sid: str, to_sid: str, text: str) -> str:
-    """Send a message. to_sid can be 'all' for broadcast."""
-    conn = get_db()
-    _clean_old_messages(conn)
-    msg_id = _gen_id("msg", 6)
-    conn.execute(
-        "INSERT INTO messages (id, from_sid, to_sid, text, created_epoch) "
-        "VALUES (?, ?, ?, ?, ?)",
-        (msg_id, from_sid, to_sid, text, now_epoch())
-    )
-    conn.commit()
-    return msg_id
-
-
-def get_inbox(sid: str) -> list[dict]:
-    """Get unread messages for a session."""
-    conn = get_db()
-    _clean_old_messages(conn)
-    rows = conn.execute(
-        "SELECT m.id, m.from_sid, m.to_sid, m.text, m.created_epoch "
-        "FROM messages m "
-        "WHERE (m.to_sid = 'all' OR m.to_sid = ?) "
-        "AND m.from_sid != ? "
-        "AND m.id NOT IN (SELECT message_id FROM message_reads WHERE sid = ?)",
-        (sid, sid, sid)
-    ).fetchall()
-    for r in rows:
-        conn.execute(
-            "INSERT OR IGNORE INTO message_reads (message_id, sid) VALUES (?, ?)",
-            (r["id"], sid)
-        )
-    conn.commit()
-    result = [dict(r) for r in rows]
-    return result
-
-
-def _clean_old_messages(conn: sqlite3.Connection):
-    """Remove expired messages and commit immediately."""
-    cutoff = now_epoch() - MESSAGE_TTL_SECONDS
-    conn.execute("DELETE FROM messages WHERE created_epoch < ?", (cutoff,))
-    conn.commit()
-
-
-# ── Questions ───────────────────────────────────────────────────────
-
-def ask_question(from_sid: str, to_sid: str, question: str) -> str:
-    """Create a pending question. Returns qid."""
-    conn = get_db()
-    _expire_old_questions(conn)
-    qid = _gen_id("q", 8)
-    conn.execute(
-        "INSERT INTO questions (qid, from_sid, to_sid, question, status, created_epoch) "
-        "VALUES (?, ?, ?, ?, 'pending', ?)",
-        (qid, from_sid, to_sid, question, now_epoch())
-    )
-    conn.commit()
-    return qid
-
-
-def answer_question(qid: str, answer: str) -> dict:
-    """Answer a pending question."""
-    conn = get_db()
-    row = conn.execute(
-        "SELECT * FROM questions WHERE qid = ?", (qid,)
-    ).fetchone()
-    if not row:
-            return {"error": f"Question {qid} not found"}
-    if row["status"] != "pending":
-            return {"error": f"Question {qid} is {row['status']}, not pending"}
-    conn.execute(
-        "UPDATE questions SET answer = ?, status = 'answered', answered_epoch = ? "
-        "WHERE qid = ?",
-        (answer, now_epoch(), qid)
-    )
-    conn.commit()
-    return {"qid": qid, "status": "answered"}
-
-
-def get_pending_questions(sid: str) -> list[dict]:
-    """Get pending questions addressed to this session."""
-    conn = get_db()
-    _expire_old_questions(conn)
-    rows = conn.execute(
-        "SELECT qid, from_sid, question, created_epoch FROM questions "
-        "WHERE to_sid = ? AND status = 'pending'",
-        (sid,)
-    ).fetchall()
-    conn.commit()
-    return [dict(r) for r in rows]
-
-
-def check_answer(qid: str) -> dict | None:
-    """Check if a question has been answered. Returns answer or None."""
-    conn = get_db()
-    row = conn.execute(
-        "SELECT qid, answer, status FROM questions WHERE qid = ?", (qid,)
-    ).fetchone()
-    if not row:
-        return None
-    return dict(row)
-
-
-def _expire_old_questions(conn: sqlite3.Connection):
-    """Mark old pending questions as expired."""
-    cutoff = now_epoch() - QUESTION_TTL_SECONDS
-    conn.execute(
-        "UPDATE questions SET status = 'expired' "
-        "WHERE status = 'pending' AND created_epoch < ?",
-        (cutoff,)
-    )
-
-