superlocalmemory 4.1.13 → 4.1.14

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

@@ -1,194 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory — per-profile isolation (I-6 / C2)
-
-"""M023 — profile_id on all mesh coordination tables (memory.db, deferred).
-
-The mesh broker is a per-agent coordination bus (peers, notification messages,
-shared key/value state, file locks, event log). Every mesh table was GLOBAL —
-no ``profile_id`` — so in a multi-tenant deployment (profiles = individual /
-team / company tenants) tenant A could see tenant B's peers, receive B's
-broadcast messages, read/overwrite B's shared state by key collision, and be
-blocked by B's file locks. That is a concrete cross-tenant isolation leak.
-
-This migration makes the mesh namespace per-profile:
-
-  * mesh_peers, mesh_messages, mesh_events — additive ``profile_id`` column +
-    profile-leading indexes (no primary-key change).
-  * mesh_state — rebuilt with PRIMARY KEY(profile_id, key) so the same key can
-    exist independently per tenant.
-  * mesh_locks — rebuilt with PRIMARY KEY(profile_id, file_path) so one tenant's
-    lock on a path never blocks another tenant.
-
-mesh_reads is intentionally left unchanged: it is (message_id, peer_id), both of
-which are already profile-scoped by their parent rows, so a cross-profile read
-row is unreachable.
-
-Existing rows backfill to the 'default' profile (the default active profile).
-Idempotent and tolerant of missing tables; deferred because the mesh tables are
-created at engine init (apply_v343_schema), after ``apply_all`` runs — same
-reason as M021.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M023_mesh_profile_isolation"
-DB_TARGET = "memory"
-
-# Documentation + drift hash. apply() below is the authoritative executor.
-DDL = (
-    "ALTER TABLE mesh_peers ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'default';"
-    "ALTER TABLE mesh_messages ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'default';"
-    "ALTER TABLE mesh_events ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'default';"
-    "-- rebuild mesh_state PK(profile_id, key); mesh_locks PK(profile_id, file_path)"
-)
-
-_NEW_STATE = """
-CREATE TABLE mesh_state (
-    profile_id TEXT NOT NULL DEFAULT 'default',
-    key TEXT NOT NULL,
-    value TEXT NOT NULL,
-    set_by TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY (profile_id, key)
-)
-"""
-
-_NEW_LOCKS = """
-CREATE TABLE mesh_locks (
-    profile_id TEXT NOT NULL DEFAULT 'default',
-    file_path TEXT NOT NULL,
-    locked_by TEXT NOT NULL,
-    locked_at TEXT NOT NULL,
-    expires_at TEXT NOT NULL DEFAULT '9999-12-31T23:59:59Z',
-    PRIMARY KEY (profile_id, file_path)
-)
-"""
-
-
-def _cols(conn: sqlite3.Connection, table: str) -> set[str]:
-    return {r[1] for r in conn.execute(f"PRAGMA table_info({table})").fetchall()}
-
-
-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 _add_profile_column(conn: sqlite3.Connection, table: str) -> None:
-    """Additive profile_id on a table whose primary key does not change."""
-    if not _table_exists(conn, table):
-        return
-    if "profile_id" not in _cols(conn, table):
-        conn.execute(
-            f"ALTER TABLE {table} "
-            "ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'default'"
-        )
-        # New column defaults 'default' for every legacy row; no extra UPDATE
-        # needed. (NOT NULL DEFAULT is applied to existing rows by SQLite.)
-
-
-def _atomic_rebuild(conn: sqlite3.Connection, table: str, create_sql: str,
-                    insert_sql: str) -> None:
-    """RENAME→CREATE→copy→DROP as ONE transaction.
-
-    Uses conn.execute (NOT executescript, which force-commits mid-rebuild and
-    could leave a zombie *_old table with the only copy of the data if a later
-    step fails). BEGIN IMMEDIATE + explicit COMMIT/ROLLBACK guarantees the
-    rebuild is all-or-nothing even under the runner's autocommit connection.
-    """
-    if not _table_exists(conn, table):
-        return
-    if "profile_id" in _cols(conn, table):
-        return
-    old = f"_{table}_old"
-    conn.execute("BEGIN IMMEDIATE")
-    try:
-        conn.execute(f"ALTER TABLE {table} RENAME TO {old}")
-        conn.execute(create_sql.strip().rstrip(";"))
-        conn.execute(insert_sql.replace("__OLD__", old))
-        conn.execute(f"DROP TABLE {old}")
-        conn.execute("COMMIT")
-    except Exception:
-        conn.execute("ROLLBACK")
-        raise
-
-
-def _rebuild_state(conn: sqlite3.Connection) -> None:
-    _atomic_rebuild(
-        conn, "mesh_state", _NEW_STATE,
-        "INSERT INTO mesh_state (profile_id, key, value, set_by, updated_at) "
-        "SELECT 'default', key, value, set_by, updated_at FROM __OLD__",
-    )
-
-
-def _rebuild_locks(conn: sqlite3.Connection) -> None:
-    _atomic_rebuild(
-        conn, "mesh_locks", _NEW_LOCKS,
-        "INSERT INTO mesh_locks "
-        "(profile_id, file_path, locked_by, locked_at, expires_at) "
-        "SELECT 'default', file_path, locked_by, locked_at, expires_at FROM __OLD__",
-    )
-
-
-def _indexes(conn: sqlite3.Connection) -> None:
-    """Profile-leading indexes. Created here (not in schema_v343) so an upgrade
-    never runs CREATE INDEX on a column that does not exist yet."""
-    if _table_exists(conn, "mesh_peers") and "profile_id" in _cols(conn, "mesh_peers"):
-        peer_cols = _cols(conn, "mesh_peers")
-        if "session_id" in peer_cols:
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_mesh_peers_profile "
-                "ON mesh_peers(profile_id, session_id)"
-            )
-        if "status" in peer_cols:
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_mesh_peers_profile_status "
-                "ON mesh_peers(profile_id, status)"
-            )
-    if _table_exists(conn, "mesh_messages") and "profile_id" in _cols(conn, "mesh_messages"):
-        msg_cols = _cols(conn, "mesh_messages")
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_mesh_messages_profile_to "
-            "ON mesh_messages(profile_id, to_peer, read)"
-        )
-        # target_type / project_path are v3.4.6 additions. In the normal upgrade
-        # path they exist (schema_v343 applies its ALTERs before deferred
-        # migrations run), but guard anyway so M023 is robust on any DB.
-        if {"target_type", "project_path"} <= msg_cols:
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_mesh_messages_profile_target "
-                "ON mesh_messages(profile_id, target_type, project_path)"
-            )
-    if _table_exists(conn, "mesh_events") and "profile_id" in _cols(conn, "mesh_events"):
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_mesh_events_profile "
-            "ON mesh_events(profile_id, id)"
-        )
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Profile-scope every mesh table. Idempotent; no-op on a fresh/migrated DB.
-
-    Existing rows backfill to the 'default' profile.
-    """
-    _add_profile_column(conn, "mesh_peers")
-    _add_profile_column(conn, "mesh_messages")
-    _add_profile_column(conn, "mesh_events")
-    _rebuild_state(conn)
-    _rebuild_locks(conn)
-    _indexes(conn)
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Applied once every mesh table carries profile_id (or is absent)."""
-    for table in ("mesh_peers", "mesh_messages", "mesh_events",
-                  "mesh_state", "mesh_locks"):
-        if _table_exists(conn, table) and "profile_id" not in _cols(conn, table):
-            return False
-    return True

package/src/superlocalmemory/storage/migrations/M024_rbac_users_roles.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 — RBAC / teams (C3)
-
-"""M024 — user identity + role-based access control tables (memory.db).
-
-SLM's tenancy boundary is the profile (individual / team / company). Until now
-the daemon had no *user* identity — access was machine-level (install token /
-daemon capability). For team and company deployments an org needs real users,
-each with a role on a profile, managed from the dashboard.
-
-Adopts the Cognee reference model (Tenant -> User -> Role):
-  * rbac_users        — a person/agent identity with a hashed password.
-  * rbac_memberships  — (profile_id, user_id) -> role, the tenant/role grant.
-  * rbac_sessions     — dashboard login sessions (hashed bearer token + expiry).
-
-RBAC is additive: with zero users the daemon stays single-operator (the machine
-operator over loopback is the implicit owner). Once users + memberships exist,
-logged-in users are enforced against their role. Brand-new independent tables,
-so this is a normal (pre-engine-init) migration with an idempotent apply().
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M024_rbac_users_roles"
-DB_TARGET = "memory"
-
-DDL = """
-CREATE TABLE IF NOT EXISTS rbac_users (
-    user_id TEXT PRIMARY KEY,
-    username TEXT NOT NULL UNIQUE,
-    display_name TEXT DEFAULT '',
-    password_hash TEXT NOT NULL,
-    status TEXT NOT NULL DEFAULT 'active',
-    created_at TEXT NOT NULL,
-    created_by TEXT DEFAULT 'owner'
-);
-CREATE TABLE IF NOT EXISTS rbac_memberships (
-    profile_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    role TEXT NOT NULL,
-    added_at TEXT NOT NULL,
-    added_by TEXT DEFAULT 'owner',
-    PRIMARY KEY (profile_id, user_id)
-);
-CREATE TABLE IF NOT EXISTS rbac_sessions (
-    token_hash TEXT PRIMARY KEY,
-    user_id TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    expires_at TEXT NOT NULL,
-    last_seen TEXT NOT NULL
-);
-CREATE TABLE IF NOT EXISTS rbac_settings (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_rbac_memberships_user
-    ON rbac_memberships(user_id);
-CREATE INDEX IF NOT EXISTS idx_rbac_sessions_user
-    ON rbac_sessions(user_id);
-CREATE INDEX IF NOT EXISTS idx_rbac_sessions_expiry
-    ON rbac_sessions(expires_at);
-"""
-
-
-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 apply(conn: sqlite3.Connection) -> None:
-    """Create the RBAC tables. Idempotent (CREATE TABLE IF NOT EXISTS)."""
-    conn.executescript(DDL)
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Applied once all RBAC tables exist."""
-    return all(
-        _table_exists(conn, t)
-        for t in ("rbac_users", "rbac_memberships", "rbac_sessions",
-                  "rbac_settings")
-    )

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

@@ -1,90 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 — performance indexes
-
-"""M025 — hot-path indexes confirmed missing by EXPLAIN QUERY PLAN.
-
-* atomic_facts(profile_id, content) — the store_fact dedup check runs on every
-  ingest; without this it scans all profile facts for a lifecycle match.
-* mesh_events(created_at) — the 7-day cleanup range-scanned the whole table.
-* mesh_peers(status, last_heartbeat) — stale-peer cleanup full-scanned.
-* mesh_peers(profile_id, last_heartbeat) — list_peers sorted in a temp b-tree.
-
-All additive CREATE INDEX IF NOT EXISTS — idempotent, no data change. Deferred
-so the target tables (mesh_* via schema_v343, atomic_facts via engine init)
-exist first.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M025_perf_indexes"
-DB_TARGET = "memory"
-
-DDL = (
-    "CREATE INDEX IF NOT EXISTS idx_facts_content_dedup "
-    "ON atomic_facts(profile_id, content);"
-    "CREATE INDEX IF NOT EXISTS idx_mesh_events_created_at ON mesh_events(created_at);"
-    "CREATE INDEX IF NOT EXISTS idx_mesh_peers_status_heartbeat "
-    "ON mesh_peers(status, last_heartbeat);"
-    "CREATE INDEX IF NOT EXISTS idx_mesh_peers_profile_heartbeat "
-    "ON mesh_peers(profile_id, last_heartbeat);"
-)
-
-
-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 _cols(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:
-    """Create the perf indexes, each guarded so a non-standard schema cannot
-    abort the migration (and leave verify() falsely reporting done)."""
-    if _table_exists(conn, "atomic_facts") and {"profile_id", "content"} <= _cols(conn, "atomic_facts"):
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_facts_content_dedup "
-            "ON atomic_facts(profile_id, content)"
-        )
-    if _table_exists(conn, "mesh_events") and "created_at" in _cols(conn, "mesh_events"):
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_mesh_events_created_at "
-            "ON mesh_events(created_at)"
-        )
-    if _table_exists(conn, "mesh_peers"):
-        pc = _cols(conn, "mesh_peers")
-        if {"status", "last_heartbeat"} <= pc:
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_mesh_peers_status_heartbeat "
-                "ON mesh_peers(status, last_heartbeat)"
-            )
-        if {"profile_id", "last_heartbeat"} <= pc:
-            conn.execute(
-                "CREATE INDEX IF NOT EXISTS idx_mesh_peers_profile_heartbeat "
-                "ON mesh_peers(profile_id, last_heartbeat)"
-            )
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Applied once the two always-creatable indexes exist (mesh_peers/events
-    are always present via schema_v343; atomic_facts always via engine init)."""
-    names = {
-        r[0] for r in conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='index'"
-        ).fetchall()
-    }
-    required = {"idx_facts_content_dedup", "idx_mesh_events_created_at"}
-    # Only require indexes whose tables exist (fresh vs partial installs).
-    ok = True
-    if _table_exists(conn, "atomic_facts"):
-        ok = ok and "idx_facts_content_dedup" in names
-    if _table_exists(conn, "mesh_events"):
-        ok = ok and "idx_mesh_events_created_at" in names
-    return ok

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

@@ -1,136 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 — RBAC hardening (SEC-H-01, audit-02)
-
-"""M026 — add FK on rbac_memberships → profiles ON DELETE CASCADE (memory.db).
-
-SEC-H-01: ``rbac_memberships`` (created by M024) had no foreign key to
-``profiles``. Deleting a profile therefore left its role grants behind; a
-profile later recreated with the same ``profile_id`` silently re-inherited
-them — a privilege-persistence bug.
-
-The runtime path (``delete_profile_from_db``) already purges memberships
-explicitly. This migration is the *defense-in-depth* half: a real FK with
-``ON DELETE CASCADE`` so that ANY path deleting a ``profiles`` row — not just
-that one helper — cannot leave orphaned grants.
-
-SQLite cannot add a constraint in place, so the table is rebuilt (the
-recommended safe-alter dance): rename → create canonical table with the FK →
-copy rows → drop old → recreate the user index. Wrapped in BEGIN IMMEDIATE /
-COMMIT for atomicity; the runner connects with ``foreign_keys = OFF`` so the
-rename/copy/drop never trips a constraint action mid-rebuild.
-
-Idempotent: skips when the FK is already present (fresh installs still get the
-FK because this always rebuilds M024's FK-less table on first run). Tolerant of
-a missing table (nothing to migrate).
-
-Deferred because the FK target ``profiles`` is created at engine init
-(``storage.schema``), after ``apply_all`` runs — same ordering constraint as
-M021 / M023.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M026_rbac_memberships_fk"
-DB_TARGET = "memory"
-
-# Documentation + drift-hash fingerprint. apply() below is the authoritative
-# executor (a static DDL string cannot express the conditional rebuild).
-DDL = (
-    "-- rebuild rbac_memberships with "
-    "FOREIGN KEY (profile_id) REFERENCES profiles(profile_id) ON DELETE CASCADE"
-)
-
-# Canonical rebuilt table. Column set is byte-identical to M024's, plus the FK.
-# The index is created separately AFTER the old table is dropped: RENAME keeps
-# the old index's name, so an inline/early CREATE INDEX would collide.
-_NEW_TABLE = """
-CREATE TABLE rbac_memberships (
-    profile_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    role TEXT NOT NULL,
-    added_at TEXT NOT NULL,
-    added_by TEXT DEFAULT 'owner',
-    PRIMARY KEY (profile_id, user_id),
-    FOREIGN KEY (profile_id) REFERENCES profiles(profile_id) ON DELETE CASCADE
-)
-"""
-
-
-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 _cols(conn: sqlite3.Connection, table: str) -> set[str]:
-    return {r[1] for r in conn.execute(f"PRAGMA table_info({table})").fetchall()}
-
-
-def _has_profiles_fk(conn: sqlite3.Connection, table: str) -> bool:
-    """True when ``table`` already declares a foreign key onto ``profiles``."""
-    try:
-        rows = conn.execute(f"PRAGMA foreign_key_list({table})").fetchall()
-    except sqlite3.OperationalError:  # pragma: no cover — table absent
-        return False
-    # PRAGMA foreign_key_list row layout: (id, seq, table, from, to, ...).
-    return any(r[2] == "profiles" for r in rows)
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Rebuild rbac_memberships with the profiles FK.
-
-    No-op when the table is absent (nothing to migrate) or the FK already
-    exists (idempotent re-run). Existing grants are preserved verbatim.
-    """
-    if not _table_exists(conn, "rbac_memberships"):
-        return
-    if _has_profiles_fk(conn, "rbac_memberships"):
-        return
-
-    has_added_by = "added_by" in _cols(conn, "rbac_memberships")
-
-    conn.execute("BEGIN IMMEDIATE")
-    try:
-        conn.execute("ALTER TABLE rbac_memberships RENAME TO _rbac_memberships_old")
-        # NB: single statement via execute(), not executescript() — the latter
-        # force-commits the pending transaction, breaking our BEGIN/COMMIT.
-        conn.execute(_NEW_TABLE)
-        if has_added_by:
-            conn.execute(
-                "INSERT INTO rbac_memberships "
-                "(profile_id, user_id, role, added_at, added_by) "
-                "SELECT profile_id, user_id, role, added_at, added_by "
-                "FROM _rbac_memberships_old"
-            )
-        else:  # exotic/older install missing the column — default it
-            conn.execute(
-                "INSERT INTO rbac_memberships "
-                "(profile_id, user_id, role, added_at) "
-                "SELECT profile_id, user_id, role, added_at "
-                "FROM _rbac_memberships_old"
-            )
-        # Dropping the old table also drops its index, freeing the name.
-        conn.execute("DROP TABLE _rbac_memberships_old")
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_rbac_memberships_user "
-            "ON rbac_memberships(user_id)"
-        )
-        conn.execute("COMMIT")
-    except sqlite3.Error:
-        try:
-            conn.execute("ROLLBACK")
-        except sqlite3.Error:  # pragma: no cover — best-effort
-            pass
-        raise
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """Applied once rbac_memberships carries the profiles FK (or is absent)."""
-    if not _table_exists(conn, "rbac_memberships"):
-        return True  # nothing to migrate; fresh install rebuilds it on apply
-    return _has_profiles_fk(conn, "rbac_memberships")

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

@@ -1,163 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 — isolation correctness (H-01, cycle-3 audit)
-
-"""M027 — add profile_id to transferable_patterns + rebuild UNIQUE constraint (learning.db).
-
-H-01: ``transferable_patterns`` had no ``profile_id`` column; every profile's
-consolidation wrote to the same (pattern_type, key) row.  The last writer won,
-so any profile's ``get_preferences()`` call returned patterns contaminated by
-other profiles' consolidation runs.
-
-Fix:
-  1. Add ``profile_id TEXT NOT NULL DEFAULT 'default'`` to the table.
-  2. Change the UNIQUE constraint from ``(pattern_type, key)`` to
-     ``(profile_id, pattern_type, key)`` so each profile owns its own rows.
-  3. Backfill existing rows to ``profile_id = 'default'`` (the only valid value
-     before this migration — they are legacy/unattributed patterns).
-
-SQLite cannot ALTER a UNIQUE constraint in place; the table must be rebuilt
-(rename → create canonical form → copy → drop old).  Wrapped in
-``BEGIN IMMEDIATE / COMMIT`` for atomicity.
-
-Idempotent:
-  * If ``profile_id`` already exists with the correct UNIQUE constraint
-    (fresh install after the code change), ``apply()`` is a no-op.
-  * If the table is absent entirely (CrossProjectAggregator was never run
-    against learning.db), ``apply()`` is a no-op — the new _SCHEMA in
-    cross_project.py will create it in its canonical form on first use.
-
-DB target: ``learning`` — CrossProjectAggregator is under the learning/
-package and is expected to share the learning database.
-
-Author: Varun Pratap Bhardwaj / Qualixar
-"""
-
-from __future__ import annotations
-
-import sqlite3
-
-NAME = "M027_transferable_patterns_profile"
-DB_TARGET = "learning"
-
-DDL = (
-    "-- rebuild transferable_patterns with "
-    "profile_id TEXT NOT NULL DEFAULT 'default' "
-    "and UNIQUE(profile_id, pattern_type, key)"
-)
-
-_NEW_TABLE = """
-CREATE TABLE transferable_patterns (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    profile_id TEXT NOT NULL DEFAULT 'default',
-    pattern_type TEXT NOT NULL DEFAULT 'preference',
-    key TEXT NOT NULL,
-    value TEXT NOT NULL,
-    confidence REAL DEFAULT 0.0,
-    evidence_count INTEGER DEFAULT 0,
-    profiles_seen INTEGER DEFAULT 1,
-    decay_factor REAL DEFAULT 1.0,
-    contradictions TEXT DEFAULT '[]',
-    first_seen TEXT,
-    last_seen TEXT,
-    UNIQUE(profile_id, pattern_type, key)
-)
-"""
-
-
-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 _cols(conn: sqlite3.Connection, table: str) -> set[str]:
-    return {r[1] for r in conn.execute(f"PRAGMA table_info({table})").fetchall()}
-
-
-def _unique_index_covers_profile(conn: sqlite3.Connection) -> bool:
-    """True when transferable_patterns already has the UNIQUE(profile_id, …) constraint."""
-    indexes = conn.execute(
-        "SELECT name, sql FROM sqlite_master "
-        "WHERE type='index' AND tbl_name='transferable_patterns'"
-    ).fetchall()
-    for idx in indexes:
-        sql = (idx[1] or "").lower()
-        if "profile_id" in sql and "pattern_type" in sql and "key" in sql:
-            return True
-    # SQLite stores the UNIQUE constraint on the CREATE TABLE statement as well.
-    tbl_sql = conn.execute(
-        "SELECT sql FROM sqlite_master "
-        "WHERE type='table' AND name='transferable_patterns'"
-    ).fetchone()
-    if tbl_sql:
-        sql = (tbl_sql[0] or "").lower()
-        if "unique(profile_id" in sql or "unique (profile_id" in sql:
-            return True
-    return False
-
-
-def apply(conn: sqlite3.Connection) -> None:
-    """Rebuild transferable_patterns with profile_id column and correct UNIQUE constraint.
-
-    No-op when the table is absent or already in canonical form.
-    Existing data is preserved; legacy rows get profile_id = 'default'.
-    """
-    if not _table_exists(conn, "transferable_patterns"):
-        return  # Table was never created against this DB — fresh install handles it.
-
-    if (
-        "profile_id" in _cols(conn, "transferable_patterns")
-        and _unique_index_covers_profile(conn)
-    ):
-        return  # Already in canonical form.
-
-    has_profile_col = "profile_id" in _cols(conn, "transferable_patterns")
-
-    conn.execute("BEGIN IMMEDIATE")
-    try:
-        conn.execute(
-            "ALTER TABLE transferable_patterns RENAME TO _tp_old"
-        )
-        conn.execute(_NEW_TABLE)
-
-        if has_profile_col:
-            # Column exists but UNIQUE constraint is wrong — copy as-is.
-            conn.execute(
-                "INSERT INTO transferable_patterns "
-                "(profile_id, pattern_type, key, value, confidence, evidence_count, "
-                " profiles_seen, decay_factor, contradictions, first_seen, last_seen) "
-                "SELECT profile_id, pattern_type, key, value, confidence, evidence_count, "
-                "       profiles_seen, decay_factor, contradictions, first_seen, last_seen "
-                "FROM _tp_old"
-            )
-        else:
-            # No profile_id yet — backfill legacy rows to 'default'.
-            conn.execute(
-                "INSERT INTO transferable_patterns "
-                "(profile_id, pattern_type, key, value, confidence, evidence_count, "
-                " profiles_seen, decay_factor, contradictions, first_seen, last_seen) "
-                "SELECT 'default', pattern_type, key, value, confidence, evidence_count, "
-                "       profiles_seen, decay_factor, contradictions, first_seen, last_seen "
-                "FROM _tp_old"
-            )
-
-        conn.execute("DROP TABLE _tp_old")
-        conn.execute("COMMIT")
-    except sqlite3.Error:
-        try:
-            conn.execute("ROLLBACK")
-        except sqlite3.Error:
-            pass
-        raise
-
-
-def verify(conn: sqlite3.Connection) -> bool:
-    """True when transferable_patterns has profile_id with the correct UNIQUE,
-    or when the table is absent (fresh install will create it correctly).
-    """
-    if not _table_exists(conn, "transferable_patterns"):
-        return True  # absent — first run of _ensure_schema creates canonical form
-    if "profile_id" not in _cols(conn, "transferable_patterns"):
-        return False
-    return _unique_index_covers_profile(conn)