superlocalmemory 4.1.13 → 4.1.14

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

@@ -1,94 +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.3 + LLD-10
-
-"""M009 — learning_model_state lineage columns (learning.db).
-
-LLD-10 online retrain + shadow test + auto-rollback needs to track
-three models concurrently: the live active model, the previously
-active (for rollback), and a candidate under A/B shadow validation.
-
-This migration extends ``learning_model_state`` (created by M002) with
-six additive columns and two partial unique indexes that enforce
-single-active + single-candidate per profile. All additive — no
-existing behaviour changes.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M009_model_lineage"
-DB_TARGET = "learning"
-
-_REQUIRED_COLS = frozenset({
-    "is_previous", "is_rollback", "is_candidate",
-    "shadow_results_json", "promoted_at", "rollback_reason",
-})
-
-# Column definitions in application order: name → SQLite type fragment.
-_COLUMN_ADDITIONS: tuple[tuple[str, str], ...] = (
-    ("is_previous",         "INTEGER DEFAULT 0"),
-    ("is_rollback",         "INTEGER DEFAULT 0"),
-    ("is_candidate",        "INTEGER DEFAULT 0"),
-    ("shadow_results_json", "TEXT"),
-    ("promoted_at",         "TEXT"),
-    ("rollback_reason",     "TEXT"),
-)
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Idempotent, column-by-column ALTER for crash-safe recovery.
-
-    Each column is only added when absent, so any committed prefix from a
-    prior interrupted run is handled transparently.  Indexes use the standard
-    IF NOT EXISTS guard.  Callers must not call commit/rollback — the runner
-    owns the transaction boundary.
-    """
-    existing_cols: set[str] = {
-        r[1]
-        for r in conn.execute(
-            "PRAGMA table_info(learning_model_state)"
-        ).fetchall()
-    }
-    for col_name, col_def in _COLUMN_ADDITIONS:
-        if col_name not in existing_cols:
-            conn.execute(
-                f"ALTER TABLE learning_model_state ADD COLUMN {col_name} {col_def}"
-            )
-    # Partial-index creation: IF NOT EXISTS guards idempotency.
-    conn.execute(
-        "CREATE UNIQUE INDEX IF NOT EXISTS idx_model_active_one "
-        "ON learning_model_state(profile_id) WHERE is_active=1"
-    )
-    conn.execute(
-        "CREATE UNIQUE INDEX IF NOT EXISTS idx_model_candidate_one "
-        "ON learning_model_state(profile_id) WHERE is_candidate=1"
-    )
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        cols = {
-            r[1]
-            for r in conn.execute(
-                "PRAGMA table_info(learning_model_state)"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_COLS.issubset(cols)
-
-
-DDL = """
-ALTER TABLE learning_model_state ADD COLUMN is_previous INTEGER DEFAULT 0;
-ALTER TABLE learning_model_state ADD COLUMN is_rollback INTEGER DEFAULT 0;
-ALTER TABLE learning_model_state ADD COLUMN is_candidate INTEGER DEFAULT 0;
-ALTER TABLE learning_model_state ADD COLUMN shadow_results_json TEXT;
-ALTER TABLE learning_model_state ADD COLUMN promoted_at TEXT;
-ALTER TABLE learning_model_state ADD COLUMN rollback_reason TEXT;
-CREATE UNIQUE INDEX IF NOT EXISTS idx_model_active_one
-    ON learning_model_state(profile_id) WHERE is_active=1;
-CREATE UNIQUE INDEX IF NOT EXISTS idx_model_candidate_one
-    ON learning_model_state(profile_id) WHERE is_candidate=1;
-"""

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

@@ -1,80 +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.6 + LLD-11
-
-"""M010 — evolution_config + evolution_llm_cost_log tables (learning.db).
-
-LLD-11 skill evolution is opt-in by default (MASTER-PLAN D3). This
-migration creates the two tables the evolution subsystem needs:
-
-- ``evolution_config`` — per-profile feature flag + LLM backend choice.
-  The default row is created lazily by the installer; this migration
-  only creates the table so the installer's INSERT can land.
-- ``evolution_llm_cost_log`` — every LLM call the evolution cycle makes
-  is logged here so the cost-accounting widget on the dashboard can
-  report tokens + USD spend.
-
-Target DB: learning.db. Additive only.
-
-SEC-L2 — ``cost_usd`` is IEEE-754 REAL (double). This loses precision
-when summing thousands of sub-cent rows (rounding drift < 0.5 ¢ per
-10k rows in practice). The schema is additive and therefore locked
-for v3.4.22 — dashboards MUST compute aggregate cost as
-``SUM(cost_usd)`` with explicit ``ROUND(x, 4)`` at display time, and
-MUST NOT branch on sub-cent equality. A follow-on migration is
-scheduled to switch the column to INTEGER millicents (see FINAL
-board). The ``cost_usd >= 0`` non-negativity invariant is enforced
-application-side by ``evolution.llm_dispatch._log_cost``.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M010_evolution_config"
-DB_TARGET = "learning"
-
-_REQUIRED_TABLES = frozenset({"evolution_config", "evolution_llm_cost_log"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        names = {
-            r[0]
-            for r in conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table'"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_TABLES.issubset(names)
-
-
-def repair(conn: sqlite3.Connection) -> None:
-    """Restore additive Skill Evolution tables without replaying other migrations."""
-    conn.executescript(DDL)
-
-
-DDL = """
-CREATE TABLE IF NOT EXISTS evolution_config (
-    profile_id        TEXT PRIMARY KEY,
-    enabled           INTEGER NOT NULL DEFAULT 0,
-    llm_backend       TEXT NOT NULL DEFAULT 'haiku',
-    llm_model         TEXT NOT NULL DEFAULT 'claude-haiku-4-5',
-    last_cycle_at     TEXT,
-    cycles_this_week  INTEGER NOT NULL DEFAULT 0,
-    disabled_until    TEXT
-);
-CREATE TABLE IF NOT EXISTS evolution_llm_cost_log (
-    id            INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id    TEXT NOT NULL,
-    ts            TEXT NOT NULL,
-    model         TEXT NOT NULL,
-    tokens_in     INTEGER NOT NULL DEFAULT 0,
-    tokens_out    INTEGER NOT NULL DEFAULT 0,
-    cost_usd      REAL NOT NULL DEFAULT 0.0,
-    cycle_id      TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_cost_profile_ts
-    ON evolution_llm_cost_log(profile_id, ts);
-"""

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

@@ -1,87 +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.4 + LLD-12
-
-"""M011 — archive + merge log (memory.db, DEFERRED).
-
-LLD-12 real consolidation uses hnswlib to find near-duplicate atomic
-facts, then archives or merges them reversibly. This migration:
-
-- Extends ``atomic_facts`` with four lifecycle columns:
-    * ``archive_status`` — 'live' | 'archived' | 'merged'
-    * ``archive_reason`` — tag explaining why (cosine_dup, reward_gate, ...)
-    * ``merged_into`` — fact_id of the canonical survivor when merged
-    * ``retrieval_prior`` — reward-derived boost factor used by ranker
-- Creates ``memory_archive`` — payload-preserving archive table.
-  Consolidation NEVER deletes from atomic_facts; it only flips status
-  and writes a payload snapshot here.
-- Creates ``memory_merge_log`` — merge decisions are reversible via
-  ``slm memory unmerge <merge_id>``. Records the canonical + duplicate
-  fact_ids plus the cosine + jaccard scores that drove the merge.
-
-Deferred like M006 — ``atomic_facts`` is bootstrapped at engine init,
-not by the migration runner. DEFERRED_MIGRATIONS runs after
-``MemoryEngine.initialize()``.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M011_archive_and_merge"
-DB_TARGET = "memory"
-
-_REQUIRED_ATOMIC = frozenset({
-    "archive_status", "archive_reason", "merged_into", "retrieval_prior",
-})
-_REQUIRED_TABLES = frozenset({"memory_archive", "memory_merge_log"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        atomic_cols = {
-            r[1]
-            for r in conn.execute(
-                "PRAGMA table_info(atomic_facts)"
-            ).fetchall()
-        }
-        names = {
-            r[0]
-            for r in conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table'"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_ATOMIC.issubset(atomic_cols) and _REQUIRED_TABLES.issubset(names)
-
-
-DDL = """
-ALTER TABLE atomic_facts ADD COLUMN archive_status TEXT DEFAULT 'live';
-ALTER TABLE atomic_facts ADD COLUMN archive_reason TEXT;
-ALTER TABLE atomic_facts ADD COLUMN merged_into TEXT;
-ALTER TABLE atomic_facts ADD COLUMN retrieval_prior REAL DEFAULT 0.0;
-
-CREATE TABLE IF NOT EXISTS memory_archive (
-    archive_id    TEXT PRIMARY KEY,
-    fact_id       TEXT NOT NULL,
-    profile_id    TEXT NOT NULL,
-    payload_json  TEXT NOT NULL,
-    archived_at   TEXT NOT NULL,
-    reason        TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_archive_profile
-    ON memory_archive(profile_id, archived_at);
-
-CREATE TABLE IF NOT EXISTS memory_merge_log (
-    merge_id          TEXT PRIMARY KEY,
-    profile_id        TEXT NOT NULL,
-    canonical_fact_id TEXT NOT NULL,
-    merged_fact_id    TEXT NOT NULL,
-    cosine_sim        REAL,
-    entity_jaccard    REAL,
-    merged_at         TEXT NOT NULL,
-    reversible        INTEGER DEFAULT 1
-);
-CREATE INDEX IF NOT EXISTS idx_merge_profile ON memory_merge_log(profile_id);
-"""

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

@@ -1,72 +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
-
-"""M012 — shadow_observations table (learning.db).
-
-Persists the paired NDCG@10 observations accumulated by
-``ShadowTest`` so a daemon restart during an in-flight shadow test
-does NOT throw away the 6-hour observation window. Without this
-table the candidate_id was re-attached on restart (Stage 9 W4
-H-ARC-01) but the observation list restarted from zero.
-
-Schema (additive only; no existing tables touched):
-
-    shadow_observations(
-      id            INTEGER PRIMARY KEY AUTOINCREMENT,
-      profile_id    TEXT NOT NULL,
-      candidate_id  INTEGER NOT NULL,
-      query_id      TEXT NOT NULL,
-      arm           TEXT NOT NULL CHECK (arm IN ('active','candidate')),
-      ndcg_at_10    REAL NOT NULL,
-      recorded_at   TEXT NOT NULL,
-      UNIQUE(candidate_id, query_id, arm)
-    )
-
-The ``UNIQUE(candidate_id, query_id, arm)`` constraint means a
-query_id is scored at most once per arm per candidate — if the
-daemon crashes mid-write and restarts, re-ingesting the same
-observation is an INSERT-OR-IGNORE no-op.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M012_shadow_observations"
-DB_TARGET = "learning"
-
-_REQUIRED_TABLES = frozenset({"shadow_observations"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        names = {
-            r[0]
-            for r in conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table'"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_TABLES.issubset(names)
-
-
-DDL = """
-CREATE TABLE IF NOT EXISTS shadow_observations (
-    id            INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id    TEXT NOT NULL,
-    candidate_id  INTEGER NOT NULL,
-    query_id      TEXT NOT NULL,
-    arm           TEXT NOT NULL,
-    ndcg_at_10    REAL NOT NULL,
-    recorded_at   TEXT NOT NULL,
-    UNIQUE(candidate_id, query_id, arm)
-);
-CREATE INDEX IF NOT EXISTS idx_shadow_obs_candidate
-    ON shadow_observations(candidate_id, recorded_at);
-CREATE INDEX IF NOT EXISTS idx_shadow_obs_profile
-    ON shadow_observations(profile_id, recorded_at);
-"""

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

@@ -1,55 +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
-
-"""M013 — bi-temporal columns on ``atomic_facts`` (memory.db, deferred).
-
-Adds two NULLable columns that let SLM capture fact validity windows
-WITHOUT changing the retrieval path today. Wiring the retrieval
-consumer is a later-cycle item; what we ship in v3.4.22 is the
-data-capture surface so existing user memories start accumulating
-temporal metadata on every new fact.
-
-Columns (both nullable, no default so existing rows stay NULL):
-
-    valid_from     TEXT  — ISO-8601 instant from which the fact is
-                           considered valid. NULL ⇒ "valid since
-                           creation" (the current default semantics).
-    valid_until    TEXT  — ISO-8601 instant after which the fact is
-                           considered superseded. NULL ⇒ still valid.
-
-Deferred like M006 and M011 because ``atomic_facts`` is bootstrapped
-at engine init, not at migration time. Daemon lifespan calls
-``apply_deferred`` right after engine init so these columns materialise
-on first boot after upgrade.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M013_bi_temporal_columns"
-DB_TARGET = "memory"
-
-_REQUIRED_COLS = frozenset({"valid_from", "valid_until"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        cols = {
-            r[1]
-            for r in conn.execute(
-                "PRAGMA table_info(atomic_facts)"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_COLS.issubset(cols)
-
-
-DDL = """
-ALTER TABLE atomic_facts ADD COLUMN valid_from TEXT;
-ALTER TABLE atomic_facts ADD COLUMN valid_until TEXT;
-"""

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

@@ -1,45 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.5 — Scale-Ready
-
-"""M014 — v3.4.5 Scale-Ready schema extensions (memory.db).
-
-Adds:
-  - atomic_facts.access_count_30d: rolling 30-day access window
-  - idx_graph_edges_source_id / idx_graph_edges_target_id: bulk import perf (F-20)
-
-Idempotent: ALTER TABLE ADD COLUMN with DEFAULT, CREATE INDEX IF NOT EXISTS.
-Verify checks for access_count_30d column presence on atomic_facts.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M014_v345_scale_ready"
-DB_TARGET = "memory"
-
-_REQUIRED_COLS = frozenset({"access_count_30d"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        cols = {
-            r[1]
-            for r in conn.execute(
-                "PRAGMA table_info(atomic_facts)"
-            ).fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_COLS.issubset(cols)
-
-
-DDL = """
-ALTER TABLE atomic_facts ADD COLUMN access_count_30d INTEGER DEFAULT 0;
-
-CREATE INDEX IF NOT EXISTS idx_graph_edges_source_id
-    ON graph_edges(source_id);
-CREATE INDEX IF NOT EXISTS idx_graph_edges_target_id
-    ON graph_edges(target_id);
-"""

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

@@ -1,58 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.65 — Context Injection v2
-
-"""M015 — add `pinned` column to atomic_facts (v3.4.65, core-memory explicit pins).
-
-Additive only — ALTER TABLE ADD COLUMN, default 0. No data loss, no type
-changes. Idempotent via verify() + migration_log. Mirrors M001 pattern.
-
-Backward-compat: old code that doesn't know about the column simply gets
-DEFAULT 0 on SELECT *, which is the safe "not-pinned" state.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M015_add_pinned_column"
-DB_TARGET = "memory"
-
-_REQUIRED_COLS = frozenset({"pinned"})
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    try:
-        cols = {r[1] for r in conn.execute(
-            "PRAGMA table_info(atomic_facts)"
-        ).fetchall()}
-    except sqlite3.Error:
-        return False
-    return _REQUIRED_COLS <= cols
-
-
-DDL = """
-BEGIN IMMEDIATE;
-ALTER TABLE atomic_facts ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0;
-CREATE INDEX IF NOT EXISTS idx_facts_pinned
-    ON atomic_facts(profile_id, pinned);
-COMMIT;
-"""
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Apply M015 safely when a fresh schema already contains ``pinned``.
-
-    New installations are created from the current base schema, whereas
-    upgrades need the additive ALTER. SQLite has no ``ADD COLUMN IF NOT
-    EXISTS``, so the old static migration failed on fresh databases.
-    """
-    cols = {row[1] for row in conn.execute("PRAGMA table_info(atomic_facts)")}
-    if "pinned" not in cols:
-        conn.execute(
-            "ALTER TABLE atomic_facts ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0"
-        )
-    conn.execute(
-        "CREATE INDEX IF NOT EXISTS idx_facts_pinned "
-        "ON atomic_facts(profile_id, pinned)"
-    )

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

@@ -1,120 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.6.15
-
-"""M016 — scope and shared_with columns on core tables (memory.db, deferred).
-
-Adds two columns to each of the 5 core tables for multi-scope memory support:
-
-    scope       TEXT NOT NULL DEFAULT 'personal'  — personal | global
-    shared_with TEXT                             — JSON array of profile_ids
-
-Existing data retains scope='personal' (backward compatible). Indexes on
-``scope`` and ``(profile_id, scope)`` speed up scope-filtered queries and are
-created HERE (not in schema.create_all_tables) so an upgrading DB whose tables
-predate the scope column doesn't hit "no such column: scope" when the boot-time
-index DDL runs before this migration.
-
-Applied via a conditional apply(conn) rather than static DDL because SQLite has
-no ``ADD COLUMN IF NOT EXISTS``: a static ALTER fails on a fresh install (the
-column already exists from create_all_tables) and on a deferred boot where a
-table isn't created yet. apply() guards every step so it is idempotent and
-tolerant of partial/missing tables.
-
-Deferred like M006, M011, and M013 because the core tables are bootstrapped
-at engine init, not at migration time. Daemon lifespan calls ``apply_deferred``
-right after engine init so these columns materialise on first boot after upgrade.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M016_add_scope_support"
-DB_TARGET = "memory"
-
-TABLES = [
-    "memories",
-    "atomic_facts",
-    "canonical_entities",
-    "graph_edges",
-    "temporal_events",
-]
-
-# Retained for the migration log's drift hash and as documentation of intent.
-# apply() below is the authoritative, idempotent executor.
-DDL = ";".join(
-    [f"ALTER TABLE {t} ADD COLUMN scope TEXT NOT NULL DEFAULT 'personal'" for t in TABLES]
-    + [f"ALTER TABLE {t} ADD COLUMN shared_with TEXT" for t in TABLES]
-    + [f"CREATE INDEX IF NOT EXISTS idx_{t}_scope ON {t}(scope)" for t in TABLES]
-    + [
-        f"CREATE INDEX IF NOT EXISTS idx_{t}_profile_scope ON {t}(profile_id, scope)"
-        for t in TABLES
-    ]
-)
-
-
-def _table_exists(conn: sqlite3.Connection, table: str) -> bool:
-    return conn.execute(
-        "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (table,)
-    ).fetchone() is not None
-
-
-def _column_names(conn: sqlite3.Connection, table: str) -> set[str]:
-    return {r[1] for r in conn.execute(f"PRAGMA table_info({table})").fetchall()}
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Idempotently add scope/shared_with columns + indexes to every core table.
-
-    Per table: skip if the table doesn't exist yet; add each column only if
-    missing (SQLite has no ADD COLUMN IF NOT EXISTS); create indexes with
-    IF NOT EXISTS. Safe to run on fresh installs (columns already present),
-    upgrades (columns missing), and partial/repeat applies.
-    """
-    for t in TABLES:
-        if not _table_exists(conn, t):
-            continue
-        cols = _column_names(conn, t)
-        if "scope" not in cols:
-            conn.execute(
-                f"ALTER TABLE {t} ADD COLUMN scope TEXT NOT NULL DEFAULT 'personal'"
-            )
-        if "shared_with" not in cols:
-            conn.execute(f"ALTER TABLE {t} ADD COLUMN shared_with TEXT")
-        conn.execute(f"CREATE INDEX IF NOT EXISTS idx_{t}_scope ON {t}(scope)")
-        conn.execute(
-            f"CREATE INDEX IF NOT EXISTS idx_{t}_profile_scope ON {t}(profile_id, scope)"
-        )
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Applied only when atomic_facts has the scope column AND its scope index.
-
-    Checking the index (not just the column) ensures apply() still runs on a
-    fresh install where create_all_tables created the column but not the index.
-    """
-    # v3.6.15: verify EVERY core table apply() touches — not just atomic_facts.
-    # A partial apply (scope added to atomic_facts but not the other tables) must
-    # NOT false-pass, or M016 is marked done and the remaining tables are left
-    # permanently without the scope column. Absent tables are skipped, matching
-    # apply()'s own skip-missing-table contract.
-    for t in TABLES:
-        try:
-            info = conn.execute(f"PRAGMA table_info({t})").fetchall()
-        except sqlite3.Error:
-            return False
-        if not info:
-            continue  # table absent on this DB — apply() skips it too
-        cols = {r[1] for r in info}
-        if "scope" not in cols:
-            return False
-        idx = conn.execute(
-            "SELECT 1 FROM sqlite_master WHERE type='index' AND name=?",
-            (f"idx_{t}_scope",),
-        ).fetchone()
-        if idx is None:
-            return False
-    return True