superlocalmemory 4.1.13 → 4.1.15

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

@@ -1,162 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-
-"""M037 — additive columns for HMAC manifest/receipt versioning.
-
-Adds ``manifest_version`` to ``completion_manifests`` and
-``receipt_version`` to ``erasure_receipts``.  Default value 1 means the
-existing rows were written with the unkeyed SHA-256 scheme (v1).  New rows
-are written with version 2 (HMAC-SHA256).  The verify path reads the
-version column and selects the appropriate verification algorithm.
-
-Dependency: M033 (completion_manifests), M035 (erasure_receipts).
-"""
-
-from __future__ import annotations
-
-import json
-import sqlite3
-
-NAME = "M037_manifest_hmac_version"
-DB_TARGET = "memory"
-
-_ADDED_COLUMNS: dict[str, tuple[str, str]] = {
-    "manifest_version_in_completion_manifests": (
-        "completion_manifests",
-        "manifest_version INTEGER NOT NULL DEFAULT 1",
-    ),
-    "receipt_version_in_erasure_receipts": (
-        "erasure_receipts",
-        "receipt_version INTEGER NOT NULL DEFAULT 1",
-    ),
-}
-
-DDL = "\n".join(
-    f"ALTER TABLE {tbl} ADD COLUMN {col_def};"
-    for _, (tbl, col_def) in _ADDED_COLUMNS.items()
-)
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    for _key, (table, col_def) in _ADDED_COLUMNS.items():
-        if not _table_exists(conn, table):
-            continue
-        col_name = col_def.split()[0]
-        if col_name not in _columns(conn, table):
-            conn.execute(f"ALTER TABLE {table} ADD COLUMN {col_def}")
-
-    # Re-seal pre-existing v1 rows to v2 HMAC so verify_manifest / verify_receipt
-    # continue to PASS post-migration.  Without re-seal, the verify path rejects
-    # v1 rows on v2 DBs as potential downgrade attacks, silently breaking every
-    # evidence chain written before M037 was applied.
-    _reseal_manifests(conn)
-    _reseal_receipts(conn)
-
-
-def _reseal_manifests(conn: sqlite3.Connection) -> None:
-    """Re-seal completion_manifests rows from v1 (unkeyed SHA) to v2 (HMAC)."""
-    if not _table_exists(conn, "completion_manifests"):
-        return
-    if "manifest_version" not in _columns(conn, "completion_manifests"):
-        return  # column not yet present — nothing to re-seal
-
-    from superlocalmemory.core.transactions.manifest import (
-        MANIFEST_V2,
-        _canonical_envelope,
-    )
-    from superlocalmemory.core.transactions.manifest_key import (
-        compute_hmac,
-        derive_manifest_hmac_key,
-    )
-
-    key = derive_manifest_hmac_key()
-    rows = conn.execute(
-        "SELECT operation_id, profile_id, state, all_met, obligation_count, "
-        "owner_evidence_json FROM completion_manifests WHERE manifest_version = 1"
-    ).fetchall()
-    for row in rows:
-        evidence_dicts = json.loads(row[5] or "[]")
-        canonical = _canonical_envelope(
-            operation_id=row[0],
-            profile_id=row[1],
-            state=row[2],
-            all_met=bool(row[3]),
-            obligation_count=int(row[4]),
-            evidence_dicts=evidence_dicts,
-            manifest_version=MANIFEST_V2,
-        )
-        new_hash = compute_hmac(key, canonical)
-        conn.execute(
-            "UPDATE completion_manifests SET manifest_hash = ?, manifest_version = ? "
-            "WHERE operation_id = ?",
-            (new_hash, MANIFEST_V2, row[0]),
-        )
-
-
-def _reseal_receipts(conn: sqlite3.Connection) -> None:
-    """Re-seal erasure_receipts rows from v1 (unkeyed SHA) to v2 (HMAC)."""
-    if not _table_exists(conn, "erasure_receipts"):
-        return
-    if "receipt_version" not in _columns(conn, "erasure_receipts"):
-        return  # column not yet present — nothing to re-seal
-
-    from superlocalmemory.core.transactions.erasure import (
-        _RECEIPT_V2,
-        _erasure_canonical,
-    )
-    from superlocalmemory.core.transactions.manifest_key import (
-        compute_hmac,
-        derive_receipt_hmac_key,
-    )
-
-    key = derive_receipt_hmac_key()
-    rows = conn.execute(
-        "SELECT erasure_id, profile_id, subject_type, subject_id, requested_by, "
-        "fact_count, state, all_erased, owner_evidence_json, requested_at, completed_at "
-        "FROM erasure_receipts WHERE receipt_version = 1"
-    ).fetchall()
-    for row in rows:
-        canonical = _erasure_canonical(
-            erasure_id=row[0],
-            profile_id=row[1],
-            subject_type=row[2],
-            subject_id=row[3],
-            requested_by=row[4],
-            fact_count=int(row[5]),
-            state=row[6],
-            all_erased=bool(row[7]),
-            evidence_json=row[8],
-            requested_at=float(row[9]),
-            completed_at=float(row[10]),
-            receipt_version=_RECEIPT_V2,
-        )
-        new_hash = compute_hmac(key, canonical)
-        conn.execute(
-            "UPDATE erasure_receipts SET audit_hash = ?, receipt_version = ? "
-            "WHERE erasure_id = ?",
-            (new_hash, _RECEIPT_V2, row[0]),
-        )
-
-
-def repair(conn: sqlite3.Connection) -> None:
-    apply(conn)
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    for _key, (table, col_def) in _ADDED_COLUMNS.items():
-        if not _table_exists(conn, table):
-            return False
-        col_name = col_def.split()[0]
-        if col_name not in _columns(conn, table):
-            return False
-    return True
-
-
-def _table_exists(conn: sqlite3.Connection, name: str) -> bool:
-    return conn.execute(
-        "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (name,),
-    ).fetchone() is not None
-
-
-def _columns(conn: sqlite3.Connection, table: str) -> set[str]:
-    return {row[1] for row in conn.execute(f"PRAGMA table_info({table})").fetchall()}

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

@@ -1,77 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Ported into the SuperLocalMemory V4 migration sequence.
-
-"""M038 — add the ``channel`` column to ``learning_feedback``.
-
-``pattern_miner._mine_channel_and_coretrieval`` has always executed::
-
-    SELECT channel, COUNT(*) AS cnt, AVG(signal_value) AS avg_signal
-    FROM learning_feedback GROUP BY channel
-
-but ``channel`` was never defined on the table. Every database therefore
-raised ``sqlite3.OperationalError: no such column: channel``. That error was
-caught by the miner's outer ``except Exception`` and logged at DEBUG, so the
-failure was invisible — and because the channel query runs FIRST inside that
-try block, it also aborted the co-retrieval mining below it. One missing
-column silently disabled two pattern types (issue #102, "Patterns learned
-remains 0" despite a restored backup: restoring rows cannot fix a schema gap).
-
-Additive only — ``ALTER TABLE ADD COLUMN`` with a default. No data loss and no
-type changes; existing rows get ``'unknown'``, which groups cleanly rather than
-being dropped by the miner's ``GROUP BY``.
-
-``learning_feedback`` is bootstrapped at runtime by
-``learning.feedback.FeedbackCollector._ensure_schema`` rather than by a
-migration, so the DDL below CREATEs it (without ``channel``) when absent
-before the ALTER. That keeps all three states correct:
-
-  - table missing            -> CREATE, then ALTER adds ``channel``
-  - table present, no column -> CREATE is a no-op, ALTER adds ``channel``
-  - table already migrated   -> ``verify()`` returns True, runner skips entirely
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M038_learning_feedback_channel"
-DB_TARGET = "learning"
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Return True if ``learning_feedback.channel`` already exists."""
-    try:
-        cols = {
-            row[1] for row in
-            conn.execute("PRAGMA table_info(learning_feedback)").fetchall()
-        }
-    except sqlite3.Error:
-        return False
-    # An empty set means the table does not exist yet — not migrated.
-    return bool(cols) and "channel" in cols
-
-
-DDL = """
-BEGIN IMMEDIATE;
-
-CREATE TABLE IF NOT EXISTS learning_feedback (
-    id           INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id   TEXT    NOT NULL,
-    fact_id      TEXT    NOT NULL,
-    signal_type  TEXT    NOT NULL,
-    signal_value REAL    NOT NULL,
-    query_hash   TEXT,
-    created_at   TEXT    NOT NULL,
-    metadata     TEXT
-);
-
-ALTER TABLE learning_feedback ADD COLUMN channel TEXT DEFAULT 'unknown';
-
-CREATE INDEX IF NOT EXISTS idx_feedback_profile
-    ON learning_feedback (profile_id, created_at DESC);
-CREATE INDEX IF NOT EXISTS idx_feedback_channel
-    ON learning_feedback (profile_id, channel);
-
-COMMIT;
-"""

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

@@ -1,137 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later
-
-"""M039 — normalized scene/fact membership for bounded assignment.
-
-``memory_scenes.fact_ids_json`` remains the public compatibility format. This
-additive projection provides the indexed reverse lookup needed to map nearest
-fact-vector hits back to candidate scenes without scanning every scene for
-every ingested fact. Triggers keep all existing scene write paths synchronized.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M039_scene_fact_members"
-DB_TARGET = "memory"
-
-DDL = """
-BEGIN IMMEDIATE;
-
--- Keep the deferred migration independently safe for partial/legacy installs.
--- On normal daemon startup MemoryEngine has already created this table.
-CREATE TABLE IF NOT EXISTS memory_scenes (
-    scene_id        TEXT PRIMARY KEY,
-    profile_id      TEXT NOT NULL DEFAULT 'default',
-    theme           TEXT NOT NULL DEFAULT '',
-    fact_ids_json   TEXT NOT NULL DEFAULT '[]',
-    entity_ids_json TEXT NOT NULL DEFAULT '[]',
-    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
-    last_updated    TEXT NOT NULL DEFAULT (datetime('now')),
-    FOREIGN KEY (profile_id) REFERENCES profiles(profile_id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_scenes_profile ON memory_scenes(profile_id);
-CREATE UNIQUE INDEX IF NOT EXISTS uq_scenes_profile_scene
-    ON memory_scenes (profile_id, scene_id);
-CREATE UNIQUE INDEX IF NOT EXISTS uq_facts_profile_fact
-    ON atomic_facts (profile_id, fact_id);
-
-CREATE TABLE IF NOT EXISTS scene_fact_members (
-    profile_id TEXT NOT NULL,
-    scene_id   TEXT NOT NULL,
-    fact_id    TEXT NOT NULL,
-    position   INTEGER NOT NULL DEFAULT 0,
-    PRIMARY KEY (scene_id, fact_id),
-    FOREIGN KEY (profile_id, scene_id)
-        REFERENCES memory_scenes(profile_id, scene_id) ON DELETE CASCADE,
-    FOREIGN KEY (profile_id, fact_id)
-        REFERENCES atomic_facts(profile_id, fact_id) ON DELETE CASCADE,
-    FOREIGN KEY (profile_id) REFERENCES profiles(profile_id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_scene_fact_members_lookup
-    ON scene_fact_members (profile_id, fact_id, scene_id);
-CREATE INDEX IF NOT EXISTS idx_scene_fact_members_order
-    ON scene_fact_members (scene_id, position);
-
-CREATE TRIGGER IF NOT EXISTS trg_scene_fact_members_insert
-AFTER INSERT ON memory_scenes
-BEGIN
-    DELETE FROM scene_fact_members WHERE scene_id = NEW.scene_id;
-    INSERT OR IGNORE INTO scene_fact_members
-        (profile_id, scene_id, fact_id, position)
-    SELECT NEW.profile_id, NEW.scene_id, af.fact_id, CAST(member.key AS INTEGER)
-    FROM json_each(
-        CASE WHEN json_valid(NEW.fact_ids_json)
-             THEN NEW.fact_ids_json ELSE '[]' END
-    ) AS member
-    JOIN atomic_facts AS af
-      ON af.fact_id = member.value
-     AND af.profile_id = NEW.profile_id;
-END;
-
-CREATE TRIGGER IF NOT EXISTS trg_scene_fact_members_update
-AFTER UPDATE OF profile_id, fact_ids_json ON memory_scenes
-BEGIN
-    DELETE FROM scene_fact_members WHERE scene_id = NEW.scene_id;
-    INSERT OR IGNORE INTO scene_fact_members
-        (profile_id, scene_id, fact_id, position)
-    SELECT NEW.profile_id, NEW.scene_id, af.fact_id, CAST(member.key AS INTEGER)
-    FROM json_each(
-        CASE WHEN json_valid(NEW.fact_ids_json)
-             THEN NEW.fact_ids_json ELSE '[]' END
-    ) AS member
-    JOIN atomic_facts AS af
-      ON af.fact_id = member.value
-     AND af.profile_id = NEW.profile_id;
-END;
-
-INSERT OR IGNORE INTO scene_fact_members
-    (profile_id, scene_id, fact_id, position)
-SELECT ms.profile_id, ms.scene_id, af.fact_id, CAST(member.key AS INTEGER)
-FROM memory_scenes AS ms
-JOIN json_each(
-    CASE WHEN json_valid(ms.fact_ids_json) THEN ms.fact_ids_json ELSE '[]' END
-) AS member
-JOIN atomic_facts AS af
-  ON af.fact_id = member.value
- AND af.profile_id = ms.profile_id;
-
-COMMIT;
-"""
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Verify the table, covering indexes, and synchronization triggers."""
-    objects = {
-        (str(row[0]), str(row[1]))
-        for row in conn.execute(
-            "SELECT name, type FROM sqlite_master "
-            "WHERE name IN (?, ?, ?, ?, ?, ?, ?)"
-            ,
-            (
-                "scene_fact_members",
-                "idx_scene_fact_members_lookup",
-                "idx_scene_fact_members_order",
-                "trg_scene_fact_members_insert",
-                "trg_scene_fact_members_update",
-                "uq_scenes_profile_scene",
-                "uq_facts_profile_fact",
-            ),
-        ).fetchall()
-    }
-    return objects == {
-        ("scene_fact_members", "table"),
-        ("idx_scene_fact_members_lookup", "index"),
-        ("idx_scene_fact_members_order", "index"),
-        ("trg_scene_fact_members_insert", "trigger"),
-        ("trg_scene_fact_members_update", "trigger"),
-        ("uq_scenes_profile_scene", "index"),
-        ("uq_facts_profile_fact", "index"),
-    }
-
-
-def repair(conn: sqlite3.Connection) -> None:
-    """Restore an accidentally dropped projection and re-backfill it."""
-    conn.executescript(DDL)

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

@@ -1,254 +0,0 @@
-"""M040 — profile-scoped Agent Experience receipts in ``learning.db``.
-
-The receipt plane deliberately has no foreign keys into ``memory.db``.  It is
-therefore not part of recall's lock domain: profile lifecycle coordinates its
-cross-store erasure as a retryable saga instead of using ``ATTACH``.
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M040_agent_experience_receipts"
-DB_TARGET = "learning"
-
-DDL = """
-BEGIN IMMEDIATE;
-CREATE TABLE IF NOT EXISTS agent_experiences (
-    profile_id TEXT NOT NULL,
-    experience_id TEXT NOT NULL,
-    occurred_at TEXT NOT NULL,
-    task_class TEXT NOT NULL,
-    project_scope TEXT NOT NULL,
-    route_json TEXT NOT NULL,
-    verification_authority TEXT NOT NULL,
-    verification_digest TEXT NOT NULL,
-    verification_reference TEXT,
-    producer_claim TEXT NOT NULL,
-    terminal_status TEXT NOT NULL,
-    failure_class TEXT,
-    human_intervention INTEGER CHECK (human_intervention IN (0, 1)),
-    lessons TEXT,
-    receipt_digest TEXT,
-    artifact_digests_json TEXT NOT NULL,
-    payload_sha256 TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    PRIMARY KEY (profile_id, experience_id)
-);
-CREATE TABLE IF NOT EXISTS cognitive_turn_receipts (
-    profile_id TEXT NOT NULL,
-    receipt_id TEXT NOT NULL,
-    task_id TEXT NOT NULL,
-    project_scope TEXT NOT NULL,
-    query_digest TEXT NOT NULL,
-    fact_decisions_json TEXT NOT NULL,
-    state TEXT NOT NULL CHECK (state IN ('open', 'finalized', 'abandoned', 'reconciled')),
-    outcome_json TEXT,
-    payload_sha256 TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile_id, receipt_id)
-);
-CREATE TABLE IF NOT EXISTS agent_receipt_profile_closures (
-    profile_id TEXT PRIMARY KEY,
-    closed_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_agent_experiences_profile_occurred
-    ON agent_experiences (profile_id, occurred_at DESC);
-CREATE INDEX IF NOT EXISTS idx_agent_experiences_profile_project_occurred
-    ON agent_experiences (profile_id, project_scope, occurred_at DESC);
-CREATE INDEX IF NOT EXISTS idx_cognitive_turns_profile_task_updated
-    ON cognitive_turn_receipts (profile_id, task_id, updated_at DESC);
-CREATE INDEX IF NOT EXISTS idx_cognitive_turns_profile_state_updated
-    ON cognitive_turn_receipts (profile_id, state, updated_at DESC);
-COMMIT;
-"""
-
-_TABLE_COLUMNS = {
-    "agent_experiences": (
-        "profile_id",
-        "experience_id",
-        "occurred_at",
-        "task_class",
-        "project_scope",
-        "route_json",
-        "verification_authority",
-        "verification_digest",
-        "verification_reference",
-        "producer_claim",
-        "terminal_status",
-        "failure_class",
-        "human_intervention",
-        "lessons",
-        "receipt_digest",
-        "artifact_digests_json",
-        "payload_sha256",
-        "created_at",
-    ),
-    "cognitive_turn_receipts": (
-        "profile_id",
-        "receipt_id",
-        "task_id",
-        "project_scope",
-        "query_digest",
-        "fact_decisions_json",
-        "state",
-        "outcome_json",
-        "payload_sha256",
-        "created_at",
-        "updated_at",
-    ),
-    "agent_receipt_profile_closures": ("profile_id", "closed_at"),
-}
-_PRIMARY_KEYS = {
-    "agent_experiences": ("profile_id", "experience_id"),
-    "cognitive_turn_receipts": ("profile_id", "receipt_id"),
-    "agent_receipt_profile_closures": ("profile_id",),
-}
-_COLUMN_TYPES = {
-    "agent_experiences": (
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "INTEGER",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-        "TEXT",
-    ),
-    "cognitive_turn_receipts": ("TEXT",) * len(_TABLE_COLUMNS["cognitive_turn_receipts"]),
-    "agent_receipt_profile_closures": ("TEXT", "TEXT"),
-}
-_REQUIRED_NOT_NULL = {
-    "agent_experiences": frozenset(_TABLE_COLUMNS["agent_experiences"])
-    - {
-        "verification_reference",
-        "failure_class",
-        "human_intervention",
-        "lessons",
-        "receipt_digest",
-    },
-    "cognitive_turn_receipts": frozenset(_TABLE_COLUMNS["cognitive_turn_receipts"])
-    - {"outcome_json"},
-    "agent_receipt_profile_closures": frozenset(_TABLE_COLUMNS["agent_receipt_profile_closures"]),
-}
-_INDEXES = {
-    "idx_agent_experiences_profile_occurred": ("agent_experiences", ("profile_id", "occurred_at")),
-    "idx_agent_experiences_profile_project_occurred": (
-        "agent_experiences",
-        ("profile_id", "project_scope", "occurred_at"),
-    ),
-    "idx_cognitive_turns_profile_task_updated": (
-        "cognitive_turn_receipts",
-        ("profile_id", "task_id", "updated_at"),
-    ),
-    "idx_cognitive_turns_profile_state_updated": (
-        "cognitive_turn_receipts",
-        ("profile_id", "state", "updated_at"),
-    ),
-}
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Atomically install M040 or leave the learning DB unchanged."""
-    if verify(conn):
-        return
-    if _tables_are_malformed(conn):
-        raise sqlite3.OperationalError("M040 receipt tables are malformed; refusing rebuild")
-    if all(name in _tables(conn) for name in _TABLE_COLUMNS):
-        repair(conn)
-        return
-    conn.executescript(DDL)
-    if not verify(conn):
-        # A pre-existing same-named index can make CREATE INDEX IF NOT EXISTS
-        # a no-op even though that index belongs to another table. Rebuild the
-        # derived index set transactionally after all required tables exist.
-        repair(conn)
-    if not verify(conn):
-        raise sqlite3.OperationalError("M040 schema did not reach its required end-state")
-
-
-def repair(conn: sqlite3.Connection) -> None:
-    """Restore missing/wrong indexes only; never rebuild user evidence."""
-    if _tables_are_malformed(conn):
-        raise sqlite3.OperationalError("M040 receipt tables are malformed; refusing rebuild")
-    if not all(name in _tables(conn) for name in _TABLE_COLUMNS):
-        apply(conn)
-        return
-    drops = "\n".join(f"DROP INDEX IF EXISTS {name};" for name in _INDEXES)
-    creates = "\n".join(
-        f"CREATE INDEX {name} ON {table} ({', '.join(columns)});"
-        for name, (table, columns) in _INDEXES.items()
-    )
-    conn.executescript(f"BEGIN IMMEDIATE;\n{drops}\n{creates}\nCOMMIT;")
-    if not verify(conn):
-        raise sqlite3.OperationalError("M040 index repair did not restore required end-state")
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    return not _tables_are_malformed(conn) and all(
-        _index_columns(conn, name) == columns for name, (_, columns) in _INDEXES.items()
-    )
-
-
-def _tables_are_malformed(conn: sqlite3.Connection) -> bool:
-    tables = _tables(conn)
-    for table, columns in _TABLE_COLUMNS.items():
-        if table not in tables:
-            continue
-        info = conn.execute(f"PRAGMA table_info({table})").fetchall()
-        actual = tuple(row[1] for row in info)
-        types = tuple(str(row[2]).upper() for row in info)
-        primary_key = tuple(row[1] for row in sorted(info, key=lambda row: row[5]) if row[5])
-        not_null = {row[1] for row in info if row[3] or row[5]}
-        if (
-            actual != columns
-            or types != _COLUMN_TYPES[table]
-            or primary_key != _PRIMARY_KEYS[table]
-            or not_null != _REQUIRED_NOT_NULL[table]
-            or not _required_checks_present(conn, table)
-        ):
-            return True
-        if conn.execute(f"PRAGMA foreign_key_list({table})").fetchone() is not None:
-            return True
-    return False
-
-
-def _tables(conn: sqlite3.Connection) -> set[str]:
-    return {row[0] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")}
-
-
-def _index_columns(conn: sqlite3.Connection, name: str) -> tuple[str, ...] | None:
-    row = conn.execute(
-        "SELECT tbl_name FROM sqlite_master WHERE type='index' AND name=?", (name,)
-    ).fetchone()
-    expected = _INDEXES.get(name)
-    if row is None or expected is None or row[0] != expected[0]:
-        return None
-    return tuple(
-        row[2]
-        for row in conn.execute(f"PRAGMA index_xinfo({name})")
-        if row[5] and row[2] is not None
-    )
-
-
-def _required_checks_present(conn: sqlite3.Connection, table: str) -> bool:
-    sql_row = conn.execute(
-        "SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table,)
-    ).fetchone()
-    sql = "" if sql_row is None or sql_row[0] is None else "".join(str(sql_row[0]).lower().split())
-    if table == "agent_experiences":
-        return "check(human_interventionin(0,1))" in sql
-    if table == "cognitive_turn_receipts":
-        return "check(statein('open','finalized','abandoned','reconciled'))" in sql
-    return True