superlocalmemory 3.8.13 → 4.0.0

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

@@ -26,6 +26,46 @@ _REQUIRED_COLS = frozenset({
     "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:

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

@@ -0,0 +1,148 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M033_projection_transactions"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE TABLE IF NOT EXISTS projection_obligations (
+    obligation_id   INTEGER PRIMARY KEY AUTOINCREMENT,
+    operation_id    TEXT NOT NULL,
+    profile_id      TEXT NOT NULL,
+    owner           TEXT NOT NULL,
+    kind            TEXT NOT NULL CHECK (kind IN ('apply', 'erase')),
+    subject_id      TEXT NOT NULL,
+    revision        INTEGER NOT NULL DEFAULT 0,
+    state           TEXT NOT NULL DEFAULT 'pending' CHECK (
+                        state IN (
+                            'pending', 'applied', 'verified',
+                            'failed', 'compensated', 'erased'
+                        )
+                    ),
+    checksum        TEXT,
+    detail          TEXT,
+    attempts        INTEGER NOT NULL DEFAULT 0,
+    created_at      REAL NOT NULL,
+    updated_at      REAL NOT NULL,
+    UNIQUE (operation_id, owner, kind)
+);
+CREATE INDEX IF NOT EXISTS idx_projection_obligations_operation
+    ON projection_obligations (operation_id);
+CREATE INDEX IF NOT EXISTS idx_projection_obligations_profile_state
+    ON projection_obligations (profile_id, state);
+CREATE INDEX IF NOT EXISTS idx_projection_obligations_state_updated
+    ON projection_obligations (state, updated_at);
+CREATE TABLE IF NOT EXISTS completion_manifests (
+    operation_id        TEXT PRIMARY KEY,
+    profile_id          TEXT NOT NULL,
+    state               TEXT NOT NULL CHECK (
+                            state IN ('COMPLETE', 'DEGRADED', 'FAILED')
+                        ),
+    all_met             INTEGER NOT NULL DEFAULT 0 CHECK (all_met IN (0, 1)),
+    obligation_count    INTEGER NOT NULL DEFAULT 0,
+    owner_evidence_json TEXT NOT NULL,
+    manifest_hash       TEXT NOT NULL,
+    created_at          REAL NOT NULL,
+    updated_at          REAL NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_completion_manifests_profile_state
+    ON completion_manifests (profile_id, state);
+"""
+
+_REQUIRED_OBLIGATION_COLUMNS = frozenset({
+    "obligation_id",
+    "operation_id",
+    "profile_id",
+    "owner",
+    "kind",
+    "subject_id",
+    "revision",
+    "state",
+    "checksum",
+    "detail",
+    "attempts",
+    "created_at",
+    "updated_at",
+})
+
+_REQUIRED_MANIFEST_COLUMNS = frozenset({
+    "operation_id",
+    "profile_id",
+    "state",
+    "all_met",
+    "obligation_count",
+    "owner_evidence_json",
+    "manifest_hash",
+    "created_at",
+    "updated_at",
+})
+
+_REQUIRED_OBJECTS = frozenset({
+    "projection_obligations",
+    "completion_manifests",
+    "idx_projection_obligations_operation",
+    "idx_projection_obligations_profile_state",
+    "idx_projection_obligations_state_updated",
+    "idx_completion_manifests_profile_state",
+})
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    if verify(conn):
+        return
+    conn.executescript(DDL)
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    apply(conn)
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    if not _table_exists(conn, "projection_obligations"):
+        return False
+    if not _table_exists(conn, "completion_manifests"):
+        return False
+    if not _REQUIRED_OBLIGATION_COLUMNS <= _columns(conn, "projection_obligations"):
+        return False
+    if not _REQUIRED_MANIFEST_COLUMNS <= _columns(conn, "completion_manifests"):
+        return False
+    if not _has_unique_index(conn, "projection_obligations", ("operation_id", "owner", "kind")):
+        return False
+    present = {
+        row[0]
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE name IN "
+            "(?, ?, ?, ?, ?, ?)",
+            tuple(sorted(_REQUIRED_OBJECTS)),
+        ).fetchall()
+    }
+    return _REQUIRED_OBJECTS <= present
+
+
+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()}
+
+
+def _has_unique_index(
+    conn: sqlite3.Connection, table: str, columns: tuple[str, ...],
+) -> bool:
+    for index in conn.execute(f"PRAGMA index_list({table})").fetchall():
+        if not index[2]:
+            continue
+        index_columns = tuple(
+            row[2] for row in conn.execute(f"PRAGMA index_info({index[1]})").fetchall()
+        )
+        if index_columns == columns:
+            return True
+    return False

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

@@ -0,0 +1,58 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M034_obligation_integrity"
+DB_TARGET = "memory"
+
+DDL = """
+ALTER TABLE projection_obligations ADD COLUMN context_digest TEXT;
+ALTER TABLE projection_obligations ADD COLUMN verify_attempts INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE projection_obligations ADD COLUMN last_verified_at REAL;
+"""
+
+_ADDED_COLUMNS = {
+    "context_digest": "ALTER TABLE projection_obligations ADD COLUMN context_digest TEXT",
+    "verify_attempts": (
+        "ALTER TABLE projection_obligations "
+        "ADD COLUMN verify_attempts INTEGER NOT NULL DEFAULT 0"
+    ),
+    "last_verified_at": (
+        "ALTER TABLE projection_obligations ADD COLUMN last_verified_at REAL"
+    ),
+}
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    if not _table_exists(conn):
+        return
+    existing = _columns(conn)
+    for column, statement in _ADDED_COLUMNS.items():
+        if column not in existing:
+            conn.execute(statement)
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    apply(conn)
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    if not _table_exists(conn):
+        return False
+    return set(_ADDED_COLUMNS) <= _columns(conn)
+
+
+def _table_exists(conn: sqlite3.Connection) -> bool:
+    return conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='projection_obligations'"
+    ).fetchone() is not None
+
+
+def _columns(conn: sqlite3.Connection) -> set[str]:
+    return {
+        row[1]
+        for row in conn.execute("PRAGMA table_info(projection_obligations)").fetchall()
+    }

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

@@ -0,0 +1,113 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M035_erasure_receipts"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE TABLE IF NOT EXISTS erasure_receipts (
+    erasure_id          TEXT PRIMARY KEY,
+    profile_id          TEXT NOT NULL,
+    subject_type        TEXT NOT NULL CHECK (
+                            subject_type IN ('fact', 'entity', 'profile')
+                        ),
+    subject_id          TEXT NOT NULL,
+    requested_by        TEXT NOT NULL DEFAULT '',
+    fact_count          INTEGER NOT NULL DEFAULT 0,
+    state               TEXT NOT NULL CHECK (state IN ('COMPLETE', 'FAILED')),
+    all_erased          INTEGER NOT NULL DEFAULT 0 CHECK (all_erased IN (0, 1)),
+    owner_evidence_json TEXT NOT NULL DEFAULT '[]',
+    audit_hash          TEXT NOT NULL,
+    requested_at        REAL NOT NULL,
+    completed_at        REAL NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_erasure_receipts_profile
+    ON erasure_receipts (profile_id);
+CREATE INDEX IF NOT EXISTS idx_erasure_receipts_state
+    ON erasure_receipts (state);
+CREATE TABLE IF NOT EXISTS projection_tombstones (
+    profile_id  TEXT NOT NULL,
+    fact_id     TEXT NOT NULL,
+    erasure_id  TEXT NOT NULL,
+    memory_id   TEXT,
+    created_at  REAL NOT NULL,
+    PRIMARY KEY (profile_id, fact_id)
+);
+CREATE INDEX IF NOT EXISTS idx_projection_tombstones_fact
+    ON projection_tombstones (fact_id);
+"""
+
+_REQUIRED_RECEIPT_COLUMNS = frozenset({
+    "erasure_id",
+    "profile_id",
+    "subject_type",
+    "subject_id",
+    "requested_by",
+    "fact_count",
+    "state",
+    "all_erased",
+    "owner_evidence_json",
+    "audit_hash",
+    "requested_at",
+    "completed_at",
+})
+
+_REQUIRED_TOMBSTONE_COLUMNS = frozenset({
+    "profile_id",
+    "fact_id",
+    "erasure_id",
+    "memory_id",
+    "created_at",
+})
+
+_REQUIRED_OBJECTS = frozenset({
+    "erasure_receipts",
+    "projection_tombstones",
+    "idx_erasure_receipts_profile",
+    "idx_erasure_receipts_state",
+    "idx_projection_tombstones_fact",
+})
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    if verify(conn):
+        return
+    conn.executescript(DDL)
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    apply(conn)
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    if not _table_exists(conn, "erasure_receipts"):
+        return False
+    if not _table_exists(conn, "projection_tombstones"):
+        return False
+    if not _REQUIRED_RECEIPT_COLUMNS <= _columns(conn, "erasure_receipts"):
+        return False
+    if not _REQUIRED_TOMBSTONE_COLUMNS <= _columns(conn, "projection_tombstones"):
+        return False
+    present = {
+        row[0]
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE name IN (?, ?, ?, ?, ?)",
+            tuple(sorted(_REQUIRED_OBJECTS)),
+        ).fetchall()
+    }
+    return _REQUIRED_OBJECTS <= present
+
+
+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/M036_vector_row_map.py

@@ -0,0 +1,107 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M036_vector_row_map"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE TABLE IF NOT EXISTS vector_row_map (
+    fact_id    TEXT NOT NULL,
+    profile_id TEXT NOT NULL,
+    vec_rowid  INTEGER NOT NULL,
+    PRIMARY KEY (fact_id)
+);
+CREATE INDEX IF NOT EXISTS idx_vector_row_map_profile
+    ON vector_row_map (profile_id);
+"""
+
+_REQUIRED_COLUMNS = frozenset({"fact_id", "profile_id", "vec_rowid"})
+
+_REQUIRED_OBJECTS = frozenset({
+    "vector_row_map",
+    "idx_vector_row_map_profile",
+})
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    _reconcile(conn)
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    _reconcile(conn)
+
+
+def _reconcile(conn: sqlite3.Connection) -> None:
+    _rebuild_if_malformed(conn)
+    conn.executescript(DDL)
+    _backfill(conn)
+
+
+def _rebuild_if_malformed(conn: sqlite3.Connection) -> None:
+    if not _table_exists(conn, "vector_row_map"):
+        return
+    if _REQUIRED_COLUMNS <= _columns(conn, "vector_row_map"):
+        return
+    conn.execute("DROP TABLE vector_row_map")
+
+
+def _backfill(conn: sqlite3.Connection) -> None:
+    if not _table_exists(conn, "embedding_metadata"):
+        return
+    if not {"fact_id", "profile_id", "vec_rowid"} <= _columns(conn, "embedding_metadata"):
+        return
+    conn.execute(
+        "INSERT INTO vector_row_map (fact_id, profile_id, vec_rowid) "
+        "SELECT em.fact_id, em.profile_id, em.vec_rowid FROM embedding_metadata em "
+        "WHERE em.fact_id IS NOT NULL AND em.vec_rowid IS NOT NULL "
+        "AND NOT EXISTS ("
+        "SELECT 1 FROM vector_row_map vrm WHERE vrm.fact_id = em.fact_id"
+        ")"
+    )
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    if not _table_exists(conn, "vector_row_map"):
+        return False
+    if not _REQUIRED_COLUMNS <= _columns(conn, "vector_row_map"):
+        return False
+    present = {
+        row[0]
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE name IN (?, ?)",
+            tuple(sorted(_REQUIRED_OBJECTS)),
+        ).fetchall()
+    }
+    if not _REQUIRED_OBJECTS <= present:
+        return False
+    return _backfill_complete(conn)
+
+
+def _backfill_complete(conn: sqlite3.Connection) -> bool:
+    if not _table_exists(conn, "embedding_metadata"):
+        return True
+    if not {"fact_id", "vec_rowid"} <= _columns(conn, "embedding_metadata"):
+        return True
+    uncovered = conn.execute(
+        "SELECT 1 FROM embedding_metadata em "
+        "WHERE em.fact_id IS NOT NULL AND em.vec_rowid IS NOT NULL "
+        "AND NOT EXISTS ("
+        "SELECT 1 FROM vector_row_map vrm WHERE vrm.fact_id = em.fact_id"
+        ") LIMIT 1"
+    ).fetchone()
+    return uncovered is None
+
+
+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/M037_manifest_hmac_version.py

@@ -0,0 +1,162 @@
+# 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/{M033_learning_feedback_channel.py → M038_learning_feedback_channel.py}

@@ -1,8 +1,8 @@
 # Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
 # Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.8.11
+# Ported into the SuperLocalMemory V4 migration sequence.
 
-"""M033 — add the ``channel`` column to ``learning_feedback``.
+"""M038 — add the ``channel`` column to ``learning_feedback``.
 
 ``pattern_miner._mine_channel_and_coretrieval`` has always executed::
 
@@ -35,7 +35,7 @@ from __future__ import annotations
 
 import sqlite3
 
-NAME = "M033_learning_feedback_channel"
+NAME = "M038_learning_feedback_channel"
 DB_TARGET = "learning"