superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/storage/migration_v33.py

@@ -1,140 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""SLM 3.2.3 -> 3.3 migration: idempotent schema upgrade.
-
-Detects a 3.2.3 database (missing 3.3 tables) and creates
-new tables via CREATE TABLE IF NOT EXISTS. Safe to call on
-any DB version — existing tables are never altered.
-
-New tables in 3.3 (all from Phases A-G):
-  - fact_retention           (Phase A: Ebbinghaus forgetting)
-  - polar_embeddings         (Phase B: PolarQuant quantization)
-  - embedding_quantization_metadata  (Phase B: EAP bit-width tracking)
-  - ccq_consolidated_blocks  (Phase E: Cognitive Consolidation)
-  - ccq_audit_log            (Phase E: CCQ audit trail)
-  - soft_prompt_templates    (Phase F: Learning Brain)
-
-All six are already defined in schema_v32.py V32_DDL and created
-by create_all_tables(). This migration module detects their absence
-and creates them for databases that were created before SLM 3.3.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: AGPL-3.0-or-later
-"""
-
-from __future__ import annotations
-
-import logging
-import sqlite3
-from dataclasses import dataclass, field
-from typing import Final
-
-logger = logging.getLogger(__name__)
-
-
-# Tables introduced or required by SLM 3.3 phases
-_V33_TABLES: Final[tuple[str, ...]] = (
-    "fact_retention",
-    "polar_embeddings",
-    "embedding_quantization_metadata",
-    "ccq_consolidated_blocks",
-    "ccq_audit_log",
-    "soft_prompt_templates",
-)
-
-
-@dataclass(frozen=True)
-class MigrationReport:
-    """Report of migration actions taken."""
-
-    tables_checked: int = 0
-    tables_created: tuple[str, ...] = ()
-    tables_existed: tuple[str, ...] = ()
-    errors: tuple[str, ...] = ()
-
-    @property
-    def is_clean(self) -> bool:
-        return len(self.errors) == 0
-
-
-def _get_existing_tables(conn: sqlite3.Connection) -> frozenset[str]:
-    """Return set of all table names in the database."""
-    rows = conn.execute(
-        "SELECT name FROM sqlite_master WHERE type='table'"
-    ).fetchall()
-    return frozenset(row[0] for row in rows)
-
-
-def detect_v323_database(conn: sqlite3.Connection) -> bool:
-    """Detect if this is a pre-3.3 database missing new tables.
-
-    Returns True if at least one V33 table is missing.
-    """
-    existing = _get_existing_tables(conn)
-    return any(table not in existing for table in _V33_TABLES)
-
-
-def migrate_v323_to_v33(conn: sqlite3.Connection) -> MigrationReport:
-    """Idempotent migration from SLM 3.2.3 to 3.3.
-
-    Creates missing 3.3 tables via the canonical DDL from schema_v32.py.
-    Uses CREATE TABLE IF NOT EXISTS — safe to run on any DB version.
-
-    Args:
-        conn: Open SQLite connection. Caller manages commit.
-
-    Returns:
-        MigrationReport with details of actions taken.
-    """
-    from superlocalmemory.storage.schema_v32 import V32_DDL
-
-    existing = _get_existing_tables(conn)
-    created: list[str] = []
-    existed: list[str] = []
-    errors: list[str] = []
-
-    for table in _V33_TABLES:
-        if table in existing:
-            existed.append(table)
-            logger.debug("Table %s already exists — skipping", table)
-            continue
-
-        # Find the DDL statement that creates this table
-        ddl_found = False
-        for ddl in V32_DDL:
-            if f"CREATE TABLE IF NOT EXISTS {table}" in ddl:
-                try:
-                    conn.executescript(ddl)
-                    created.append(table)
-                    ddl_found = True
-                    logger.info("Created table: %s", table)
-                except sqlite3.Error as exc:
-                    msg = f"Failed to create {table}: {exc}"
-                    errors.append(msg)
-                    logger.error(msg)
-                    ddl_found = True
-                break
-
-        if not ddl_found:
-            msg = f"No DDL found for table: {table}"
-            errors.append(msg)
-            logger.warning(msg)
-
-    report = MigrationReport(
-        tables_checked=len(_V33_TABLES),
-        tables_created=tuple(created),
-        tables_existed=tuple(existed),
-        errors=tuple(errors),
-    )
-
-    logger.info(
-        "Migration report: checked=%d, created=%d, existed=%d, errors=%d",
-        report.tables_checked,
-        len(report.tables_created),
-        len(report.tables_existed),
-        len(report.errors),
-    )
-
-    return report

package/src/superlocalmemory/storage/migrations/M001_add_signal_features_columns.py

@@ -1,67 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-07 §3.1
-
-"""M001 — add rich-signal columns to learning_signals + learning_features.
-
-Additive only — uses ``ALTER TABLE ADD COLUMN``. No data loss, no type
-changes. Every ADD is guarded by the runner's idempotency check against
-``migration_log``; on rerun the migration is skipped outright so duplicate
-ALTER errors never surface.
-
-The runner wraps this DDL in ``BEGIN IMMEDIATE`` / ``COMMIT`` when needed.
-SQLite DDL is transactional except for schema-version bumps, so the BEGIN
-here is defense-in-depth against partial application on crash.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M001_add_signal_features_columns"
-DB_TARGET = "learning"
-
-_REQUIRED_SIGNAL_COLS = frozenset({
-    "query_id", "query_text_hash", "position", "channel_scores", "cross_encoder",
-})
-_REQUIRED_FEATURE_COLS = frozenset({"signal_id", "is_synthetic"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Return True if the migration's end-state is already present."""
-    try:
-        sig_cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(learning_signals)"
-        ).fetchall()}
-        feat_cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(learning_features)"
-        ).fetchall()}
-    except sqlite3.Error:
-        return False
-    return (_REQUIRED_SIGNAL_COLS <= sig_cols
-            and _REQUIRED_FEATURE_COLS <= feat_cols)
-
-DDL = """
-BEGIN IMMEDIATE;
-
-ALTER TABLE learning_signals ADD COLUMN query_id        TEXT DEFAULT '';
-ALTER TABLE learning_signals ADD COLUMN query_text_hash TEXT DEFAULT '';
-ALTER TABLE learning_signals ADD COLUMN position        INTEGER DEFAULT 0;
-ALTER TABLE learning_signals ADD COLUMN channel_scores  TEXT DEFAULT '{}';
-ALTER TABLE learning_signals ADD COLUMN cross_encoder   REAL;
-
-CREATE INDEX IF NOT EXISTS idx_signals_profile_time
-    ON learning_signals(profile_id, created_at);
-CREATE INDEX IF NOT EXISTS idx_signals_query_id
-    ON learning_signals(query_id);
-
-ALTER TABLE learning_features ADD COLUMN signal_id    INTEGER DEFAULT 0;
-ALTER TABLE learning_features ADD COLUMN is_synthetic INTEGER NOT NULL DEFAULT 0;
-
-CREATE INDEX IF NOT EXISTS idx_features_signal
-    ON learning_features(signal_id);
-CREATE INDEX IF NOT EXISTS idx_features_synthetic
-    ON learning_features(is_synthetic) WHERE is_synthetic = 0;
-
-COMMIT;
-"""

package/src/superlocalmemory/storage/migrations/M002_model_state_history.py

@@ -1,107 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-07 §3.2
-
-"""M002 — rebuild learning_model_state without UNIQUE(profile_id).
-
-Enables shadow testing (old + new model live side-by-side). SQLite cannot
-drop a UNIQUE constraint directly, so we use the new-table-rename pattern
-wrapped in a single transaction. Existing rows are copied forward and
-marked ``is_active = 1``.
-
-SEC-02-02: ``bytes_sha256`` integrity column added. The daemon will
-compute and verify this on every load to block corrupted model BLOBs from
-reaching the LightGBM deserialiser.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M002_model_state_history"
-DB_TARGET = "learning"
-
-_REQUIRED_COLS = frozenset({
-    "model_version", "bytes_sha256", "trained_on_count",
-    "feature_names", "metrics_json", "is_active",
-    "trained_at", "updated_at",
-})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Verify columns plus both indexes promised by this migration."""
-    try:
-        cols = {r[1]: r for r in conn.execute(
-            "PRAGMA table_info(learning_model_state)"
-        ).fetchall()}
-        index_rows = conn.execute(
-            "PRAGMA index_list(learning_model_state)"
-        ).fetchall()
-    except sqlite3.Error:
-        return False
-    if not _REQUIRED_COLS <= set(cols):
-        return False
-
-    indexes = {row[1]: row for row in index_rows}
-    active = indexes.get("idx_model_active")
-    profile_time = indexes.get("idx_model_profile_time")
-    if active is None or profile_time is None:
-        return False
-    # idx_model_active must remain a UNIQUE partial index.
-    if int(active[2]) != 1 or int(active[4]) != 1:
-        return False
-    active_cols = [row[2] for row in conn.execute(
-        "PRAGMA index_info(idx_model_active)"
-    ).fetchall()]
-    time_cols = [row[2] for row in conn.execute(
-        "PRAGMA index_info(idx_model_profile_time)"
-    ).fetchall()]
-    if active_cols != ["profile_id"]:
-        return False
-    if time_cols != ["profile_id", "trained_at"]:
-        return False
-    sql_row = conn.execute(
-        "SELECT sql FROM sqlite_master WHERE type='index' AND name=?",
-        ("idx_model_active",),
-    ).fetchone()
-    normalized = " ".join(str(sql_row[0] if sql_row else "").lower().split())
-    return "where is_active = 1" in normalized
-
-
-# IMPORTANT: this DDL shipped in V3.4.21.  Migration hashes are immutable
-# upgrade contracts, so later improvements belong in a new forward migration
-# (M020), never in this historical definition.
-DDL = """
-BEGIN IMMEDIATE;
-
-CREATE TABLE learning_model_state_new (
-    id                INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id        TEXT NOT NULL,
-    model_version     TEXT NOT NULL DEFAULT '3.4.21',
-    state_bytes       BLOB NOT NULL,
-    bytes_sha256      TEXT NOT NULL DEFAULT '',
-    trained_on_count  INTEGER NOT NULL DEFAULT 0,
-    feature_names     TEXT NOT NULL DEFAULT '[]',
-    metrics_json      TEXT NOT NULL DEFAULT '{}',
-    is_active         INTEGER NOT NULL DEFAULT 0,
-    trained_at        TEXT NOT NULL,
-    updated_at        TEXT NOT NULL
-);
-
-INSERT INTO learning_model_state_new
-    (profile_id, state_bytes, is_active, trained_at, updated_at)
-SELECT profile_id, state_bytes, 1, updated_at, updated_at
-FROM learning_model_state;
-
-DROP TABLE learning_model_state;
-ALTER TABLE learning_model_state_new RENAME TO learning_model_state;
-
-CREATE UNIQUE INDEX idx_model_active
-    ON learning_model_state(profile_id)
-    WHERE is_active = 1;
-
-CREATE INDEX idx_model_profile_time
-    ON learning_model_state(profile_id, trained_at);
-
-COMMIT;
-"""

package/src/superlocalmemory/storage/migrations/M003_migration_log.py

@@ -1,38 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-07 §3.3
-
-"""M003 — bootstrap migration_log table.
-
-Runs FIRST on both DBs. Purely idempotent ``CREATE TABLE IF NOT EXISTS``.
-No transaction needed — a single DDL statement on SQLite is atomic.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M003_migration_log"
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Return True if migration_log already exists with expected columns."""
-    try:
-        cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(migration_log)"
-        ).fetchall()}
-    except sqlite3.Error:
-        return False
-    return {"name", "applied_at", "ddl_sha256",
-            "rows_affected", "status"} <= cols
-DB_TARGET = "learning"  # Also gets replicated to memory DB by the runner.
-
-DDL = """
-CREATE TABLE IF NOT EXISTS migration_log (
-    name           TEXT PRIMARY KEY,
-    applied_at     TEXT NOT NULL,
-    ddl_sha256     TEXT NOT NULL,
-    rows_affected  INTEGER NOT NULL DEFAULT 0,
-    status         TEXT NOT NULL
-);
-"""

package/src/superlocalmemory/storage/migrations/M004_cross_platform_sync_log.py

@@ -1,46 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-07 §3.4
-
-"""M004 — cross-platform adapter sync log (memory.db).
-
-LLD-05 requirement. SEC-05-04: stores target paths as SHA-256 digests, not
-raw strings — keeps plaintext filesystem paths out of the DB. A separate
-``target_basename`` column keeps the last path segment for the dashboard
-without exposing the full path.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M004_cross_platform_sync_log"
-DB_TARGET = "memory"
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Return True if cross_platform_sync_log table is in place."""
-    try:
-        cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(cross_platform_sync_log)"
-        ).fetchall()}
-    except sqlite3.Error:
-        return False
-    return {"adapter_name", "profile_id", "target_path_sha256",
-            "target_basename", "last_sync_at", "bytes_written",
-            "content_sha256", "success"} <= cols
-
-DDL = """
-CREATE TABLE IF NOT EXISTS cross_platform_sync_log (
-    adapter_name       TEXT NOT NULL,
-    profile_id         TEXT NOT NULL,
-    target_path_sha256 TEXT NOT NULL,
-    target_basename    TEXT NOT NULL,
-    last_sync_at       TEXT NOT NULL,
-    bytes_written      INTEGER NOT NULL,
-    content_sha256     TEXT NOT NULL,
-    success            INTEGER NOT NULL,
-    error_msg          TEXT,
-    PRIMARY KEY (adapter_name, target_path_sha256)
-);
-"""

package/src/superlocalmemory/storage/migrations/M005_bandit_tables.py

@@ -1,75 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-07 §3.5
-
-"""M005 — Thompson-sampling bandit tables (learning.db, LLD-03).
-
-Two tables:
-  - ``bandit_arms`` — per (profile, stratum, arm) Beta-distribution state.
-    ``WITHOUT ROWID`` since primary key is a natural composite.
-  - ``bandit_plays`` — individual play events with delayed-reward settlement.
-
-All indexes are ``IF NOT EXISTS`` so reapply is a no-op.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M005_bandit_tables"
-DB_TARGET = "learning"
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Return True if bandit tables exist with expected columns."""
-    try:
-        arms_cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(bandit_arms)"
-        ).fetchall()}
-        plays_cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(bandit_plays)"
-        ).fetchall()}
-    except sqlite3.Error:
-        return False
-    return (
-        {"profile_id", "stratum", "arm_id", "alpha",
-         "beta", "plays"} <= arms_cols
-        and {"play_id", "profile_id", "query_id", "stratum",
-             "arm_id", "played_at"} <= plays_cols
-    )
-
-DDL = """
-CREATE TABLE IF NOT EXISTS bandit_arms (
-    profile_id      TEXT NOT NULL,
-    stratum         TEXT NOT NULL,
-    arm_id          TEXT NOT NULL,
-    alpha           REAL NOT NULL DEFAULT 1.0,
-    beta            REAL NOT NULL DEFAULT 1.0,
-    plays           INTEGER NOT NULL DEFAULT 0,
-    last_played_at  TEXT,
-    PRIMARY KEY (profile_id, stratum, arm_id)
-) WITHOUT ROWID;
-
-CREATE INDEX IF NOT EXISTS idx_bandit_profile_strat
-    ON bandit_arms(profile_id, stratum);
-
-CREATE TABLE IF NOT EXISTS bandit_plays (
-    play_id          INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id       TEXT NOT NULL,
-    query_id         TEXT NOT NULL,
-    stratum          TEXT NOT NULL,
-    arm_id           TEXT NOT NULL,
-    played_at        TEXT NOT NULL,
-    reward           REAL,
-    settled_at       TEXT,
-    settlement_type  TEXT
-);
-
-CREATE INDEX IF NOT EXISTS idx_plays_query
-    ON bandit_plays(query_id);
-CREATE INDEX IF NOT EXISTS idx_plays_unsettled
-    ON bandit_plays(profile_id, played_at)
-    WHERE settled_at IS NULL;
-CREATE INDEX IF NOT EXISTS idx_plays_retention
-    ON bandit_plays(settled_at);
-"""

package/src/superlocalmemory/storage/migrations/M006_action_outcomes_reward.py

@@ -1,75 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-07 §3.6
-
-"""M006 — action_outcomes reward + settlement columns (memory.db).
-
-Extends ``action_outcomes`` with the four columns the learning trainer
-needs in order to swap off the position proxy onto the real reward
-label:
-
-  * ``reward REAL`` — numeric reward (usually in [-1, 1]).
-  * ``settled INTEGER DEFAULT 0`` — 1 when the outcome has been settled.
-  * ``settled_at TEXT`` — ISO-8601 timestamp of settlement.
-  * ``recall_query_id TEXT`` — links the outcome back to the recall that
-    produced the candidate facts (so the trainer can join against
-    ``learning_signals.query_id``).
-
-The gate in ``learning.database.fetch_training_examples``
-(``_migration_applied("M006_action_outcomes_reward")``) already falls
-back to the position proxy when this migration hasn't completed, so a
-skipped/failed apply never crashes the trainer.
-
-Deferred: this migration is NOT in ``MIGRATIONS``. It ships via
-``DEFERRED_MIGRATIONS`` and runs from the daemon lifespan immediately
-after ``MemoryEngine.initialize()`` has bootstrapped the
-``action_outcomes`` table. Idempotent — ``verify(conn)`` returns True
-once all four columns are present, so reapply is a no-op.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M006_action_outcomes_reward"
-# action_outcomes lives in memory.db (see storage.schema).
-DB_TARGET = "memory"
-
-_REQUIRED_COLS = frozenset({"reward", "settled", "settled_at", "recall_query_id"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Return True once every M006 column is present on ``action_outcomes``.
-
-    Lets the migration runner detect "already applied" state when a retry
-    would otherwise hit a duplicate-column error mid-script.
-    """
-    try:
-        cols = {
-            r[1]
-            for r in conn.execute("PRAGMA table_info(action_outcomes)").fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_COLS.issubset(cols)
-
-
-# DDL. Runs inside an explicit transaction opened by the migration runner.
-# SQLite doesn't support ``ALTER TABLE IF EXISTS`` — if the table is missing
-# this raises sqlite3.OperationalError which the runner catches and records
-# as ``failed``; the gate in ``fetch_training_examples`` keeps the trainer
-# on the position proxy in that case, so the daemon is still healthy.
-DDL = """
-ALTER TABLE action_outcomes ADD COLUMN reward REAL;
-ALTER TABLE action_outcomes ADD COLUMN settled INTEGER NOT NULL DEFAULT 0;
-ALTER TABLE action_outcomes ADD COLUMN settled_at TEXT;
-ALTER TABLE action_outcomes ADD COLUMN recall_query_id TEXT;
-
-CREATE INDEX IF NOT EXISTS idx_action_outcomes_settled_reward
-    ON action_outcomes(settled, settled_at)
-    WHERE reward IS NOT NULL;
-
-CREATE INDEX IF NOT EXISTS idx_action_outcomes_recall_query
-    ON action_outcomes(recall_query_id)
-    WHERE recall_query_id IS NOT NULL;
-"""

package/src/superlocalmemory/storage/migrations/M007_pending_outcomes.py

@@ -1,63 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.22 — LLD-00 §1.2 + LLD-08
-
-"""M007 — pending_outcomes table (memory.db).
-
-LLD-00 §1.2 makes ``pending_outcomes`` the single source of truth for
-in-flight recall outcomes awaiting reward settlement. An earlier draft
-split pending state across a cache.db table which has been retired
-(see LLD-00 §1.2 for the name of the predecessor). All pending rows
-are now crash-safe, profile-scoped, and one-row-per-recall — signals
-live in the ``signals_json`` blob, not separate rows.
-
-Target DB: memory.db. Schema follows LLD-00 §1.2 verbatim. Idempotent:
-``verify(conn)`` returns True once every required column is present on
-the ``pending_outcomes`` table.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M007_pending_outcomes"
-DB_TARGET = "memory"
-
-_REQUIRED_COLS = frozenset({
-    "outcome_id", "profile_id", "session_id", "recall_query_id",
-    "fact_ids_json", "query_text_hash", "created_at_ms", "expires_at_ms",
-    "signals_json", "status",
-})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        cols = {
-            r[1]
-            for r in conn.execute(
-                "PRAGMA table_info(pending_outcomes)"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_COLS.issubset(cols)
-
-
-DDL = """
-CREATE TABLE IF NOT EXISTS pending_outcomes (
-    outcome_id       TEXT PRIMARY KEY,
-    profile_id       TEXT NOT NULL,
-    session_id       TEXT NOT NULL,
-    recall_query_id  TEXT NOT NULL,
-    fact_ids_json    TEXT NOT NULL,
-    query_text_hash  TEXT NOT NULL,
-    created_at_ms    INTEGER NOT NULL,
-    expires_at_ms    INTEGER NOT NULL,
-    signals_json     TEXT NOT NULL DEFAULT '{}',
-    status           TEXT NOT NULL DEFAULT 'pending'
-);
-CREATE INDEX IF NOT EXISTS idx_pending_profile_expires
-    ON pending_outcomes(profile_id, expires_at_ms);
-CREATE INDEX IF NOT EXISTS idx_pending_status
-    ON pending_outcomes(status, expires_at_ms);
-"""