lorebase-store 0.2.3__py3-none-any.whl

lorebase_store/_migrations/versions/0024_embedding_template_keys.py

@@ -0,0 +1,205 @@
+"""Vectors keyed by embedding template fingerprint (design 9.3).
+
+`embeddings.fingerprint` holds the fingerprint of the embedding template the vector's text was
+rendered with (`KindTemplate.fingerprint`) and joins the primary key, now `(domain_id,
+object_hash, model, fingerprint)`: branches whose templates differ for the same content keep a
+vector each, and readers look a vector up with the fingerprint of the template of the branch
+they read.
+
+Existing rows. The fingerprint of a vector is set when it can be told: the live Records
+holding its object hash, in every materialized branch whose schema gives their Kind an
+embedding template, all have a template of the same fingerprint. Other vectors keep the empty
+fingerprint, which no reader looks up and garbage collection deletes. Every
+`embedding_cursors` row loses its fingerprints, so the next pass of each branch renders each
+Record's text once more: a Record whose text hash matches its vector costs nothing, one whose
+text matches another stored text gets that vector copied without a model call (vectors left
+without a fingerprint included, unless a collection deleted them first), and only texts
+embedded nowhere go to the model. Until that pass, semantic search finds the vectors whose
+fingerprint was set.
+
+The downgrade keeps one vector per `(domain_id, object_hash, model)` and clears the cursors'
+fingerprints the same way.
+
+Revision ID: 0024
+Revises: 0023
+Create Date: 2026-10-27 09:00:00.000000
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "0024"
+down_revision: str | Sequence[str] | None = "0023"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+TEMPLATES = "lb_migration_templates"
+
+_FILL = sa.text(
+    f"INSERT INTO {TEMPLATES} (schema_hash, kind_id, fingerprint) "
+    "SELECT :h, k, f FROM unnest(CAST(:kinds AS text[]), CAST(:fps AS text[])) AS t(k, f)"
+).bindparams(
+    sa.bindparam("kinds", type_=postgresql.ARRAY(sa.Text())),
+    sa.bindparam("fps", type_=postgresql.ARRAY(sa.Text())),
+)
+
+_BACKFILL = sa.text(
+    f"""
+    UPDATE embeddings e SET fingerprint = known.fingerprint
+    FROM (
+        SELECT m.domain_id, m.object_hash, min(t.fingerprint) AS fingerprint
+        FROM mat_records m
+        JOIN mat_schema s ON s.domain_id = m.domain_id AND s.branch = m.branch
+        JOIN {TEMPLATES} t ON t.schema_hash = s.schema_hash AND t.kind_id = m.kind_id
+        WHERE NOT m.deleted
+        GROUP BY m.domain_id, m.object_hash
+        HAVING count(DISTINCT t.fingerprint) = 1
+    ) AS known
+    WHERE e.domain_id = known.domain_id AND e.object_hash = known.object_hash
+    """
+)
+"""A vector gets the fingerprint every live Record holding its object hash agrees on."""
+
+
+# Fingerprints as `lorebase_core.model.embedding` computed them at this revision (rendering
+# version 1), on the stored compiled schema document. Frozen here so the backfill does not
+# change with the application code.
+_RENDERING_VERSION = 1
+_KIND_FIELD = "_kind"
+_SPECIAL_FIELDS = frozenset({_KIND_FIELD, "_key"})
+_TOKEN = re.compile(r"\{\{|\}\}|\{([^{}]*)\}|[{}]")
+
+
+def _template_fields(source: str) -> tuple[str, ...] | None:
+    """Placeholder names in order of first use; `None` when the template cannot be parsed."""
+    names: list[str] = []
+    for match in _TOKEN.finditer(source):
+        token = match.group(0)
+        if token in ("{{", "}}"):
+            continue
+        name = match.group(1)
+        if name is None or not name.strip():
+            return None
+        names.append(name.strip())
+    return tuple(dict.fromkeys(names)) or None
+
+
+def _kind_fingerprint(kind: Mapping[str, Any]) -> str | None:
+    """Fingerprint of the Kind's embedding template; `None` without a usable one."""
+    search = kind.get("search") or {}
+    source = search.get("embedding_template")
+    if source is None or not source.strip():
+        return None
+    fields = _template_fields(source)
+    if fields is None:
+        return None
+    allow_sensitive = bool(search.get("embedding_sensitive"))
+    attributes: dict[str, str] = {}
+    for name in fields:
+        if name in _SPECIAL_FIELDS:
+            continue
+        attribute = next(
+            (a for a in (kind.get("attributes") or {}).values() if a["api_name"] == name), None
+        )
+        if (
+            attribute is None
+            or attribute.get("derivation_id") is not None
+            or attribute.get("vault") is True
+            or (attribute.get("sensitivity") and not allow_sensitive)
+        ):
+            return None
+        attributes[name] = attribute["id"]
+    label = kind.get("display_name") or kind["api_name"]
+    return hashlib.sha256(
+        json.dumps(
+            {
+                "v": _RENDERING_VERSION,
+                "kind": kind["id"],
+                "template": source,
+                "attributes": attributes,
+                "label": label if _KIND_FIELD in fields else None,
+            },
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode("utf-8")
+    ).hexdigest()
+
+
+def _template_fingerprints(compiled: Mapping[str, Any]) -> dict[str, str]:
+    """Fingerprint by Kind id of each Kind of a compiled schema with a usable template."""
+    found: dict[str, str] = {}
+    for kind in (compiled.get("kinds") or {}).values():
+        fingerprint = _kind_fingerprint(kind)
+        if fingerprint is not None:
+            found[kind["id"]] = fingerprint
+    return found
+
+
+def _templates(bind: sa.Connection) -> None:
+    bind.execute(
+        sa.text(
+            f"CREATE TEMP TABLE {TEMPLATES} (schema_hash bytea NOT NULL, kind_id text NOT NULL, "
+            "fingerprint text NOT NULL, PRIMARY KEY (schema_hash, kind_id)) ON COMMIT DROP"
+        )
+    )
+    schemas = bind.execute(
+        sa.text("SELECT DISTINCT ON (schema_hash) schema_hash, compiled FROM mat_schema")
+    ).all()
+    for schema_hash, compiled in schemas:
+        fingerprints = _template_fingerprints(compiled)
+        if fingerprints:
+            bind.execute(
+                _FILL,
+                {
+                    "h": bytes(schema_hash),
+                    "kinds": list(fingerprints),
+                    "fps": list(fingerprints.values()),
+                },
+            )
+
+
+def _clear_cursor_fingerprints() -> None:
+    op.execute("UPDATE embedding_cursors SET fingerprints = '{}'::jsonb")
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    # Row-level security is forced on the owner too: read and write the rows of every Domain.
+    bind.execute(sa.text("SELECT set_config('lorebase.bypass_rls', 'on', true)"))
+    op.add_column(
+        "embeddings",
+        sa.Column("fingerprint", sa.Text(), nullable=False, server_default=sa.text("''")),
+    )
+    op.alter_column("embeddings", "fingerprint", server_default=None)
+    op.drop_constraint(op.f("pk_embeddings"), "embeddings", type_="primary")
+    op.create_primary_key(
+        op.f("pk_embeddings"), "embeddings", ["domain_id", "object_hash", "model", "fingerprint"]
+    )
+    _templates(bind)
+    bind.execute(_BACKFILL)
+    _clear_cursor_fingerprints()
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    bind.execute(sa.text("SELECT set_config('lorebase.bypass_rls', 'on', true)"))
+    op.execute(
+        "DELETE FROM embeddings e USING embeddings other "
+        "WHERE other.domain_id = e.domain_id AND other.object_hash = e.object_hash "
+        "AND other.model = e.model AND other.fingerprint > e.fingerprint"
+    )
+    op.drop_constraint(op.f("pk_embeddings"), "embeddings", type_="primary")
+    op.drop_column("embeddings", "fingerprint")
+    op.create_primary_key(
+        op.f("pk_embeddings"), "embeddings", ["domain_id", "object_hash", "model"]
+    )
+    _clear_cursor_fingerprints()

lorebase_store/_migrations/versions/0025_snapshot_refs.py

@@ -0,0 +1,35 @@
+"""Snapshot refs.
+
+Adds `snapshot` to `ref_kind`: a snapshot ref holds the materialized rows of a past Revision
+for reads at it (`lorebase_store.materialize.snapshot`). The value is added outside the
+migration transaction, as Postgres requires before it can be used.
+
+Downgrade deletes the snapshot refs (their rows go with them) and keeps the enum value:
+Postgres cannot drop a value from an enum type, and no other ref uses it. The deletion is one
+statement: snapshots are bounded (`read.time_travel.snapshot_max_per_domain` per Domain, each
+at most `snapshot_max_entries` Records and Links plus its history), so it is not batched.
+
+Revision ID: 0025
+Revises: 0024
+Create Date: 2026-10-27 09:00:00.000000
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from alembic import op
+
+revision: str = "0025"
+down_revision: str | Sequence[str] | None = "0024"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    with op.get_context().autocommit_block():
+        op.execute("ALTER TYPE ref_kind ADD VALUE IF NOT EXISTS 'snapshot'")
+
+
+def downgrade() -> None:
+    op.execute("DELETE FROM refs WHERE kind = 'snapshot'")

lorebase_store/_migrations/versions/0026_plain_reverse_link_index.py

@@ -0,0 +1,112 @@
+"""The plain reverse Link index again.
+
+An earlier version of this revision replaced `ix_mat_links_reverse` with a covering index
+(`INCLUDE (from_key, "values", ...)`) so that inbound Link hops of the neighborhood would be
+index-only scans. It was withdrawn: a B-tree entry is limited to about 2.7 KB, so a Link with
+large `values` could no longer be written ("index row size exceeds maximum"), and without
+`values` the hop, which returns them, reads the heap anyway while the index doubles in size.
+On a database that ran the withdrawn version this restores the plain index (built
+concurrently per partition, revision 0011 style) and drops the covering one; elsewhere it
+changes nothing.
+
+Revision ID: 0026
+Revises: 0025
+Create Date: 2026-10-22 18:00:00.000000
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import NamedTuple
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0026"
+down_revision: str | Sequence[str] | None = "0025"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+PARENT = "mat_links"
+
+
+class BtreeIndex(NamedTuple):
+    name: str
+    definition: str
+    suffix: str
+    """Partition indexes are named `<partition>_<suffix>`."""
+
+
+OLD = BtreeIndex(
+    "ix_mat_links_reverse",
+    "(domain_id, branch, relation_id, to_key)",
+    "domain_id_branch_relation_id_to_key_idx",
+)
+NEW = BtreeIndex(
+    "ix_mat_links_reverse_covering",
+    '(domain_id, branch, relation_id, to_key) INCLUDE (from_key, "values", object_hash, '
+    "revision_generation, deleted)",
+    "reverse_covering_idx",
+)
+
+
+def _partitions() -> list[str]:
+    found = op.get_bind().execute(
+        sa.text(
+            "SELECT c.relname FROM pg_inherits i JOIN pg_class c ON c.oid = i.inhrelid "
+            "WHERE i.inhparent = CAST(:parent AS regclass) ORDER BY c.relname"
+        ),
+        {"parent": PARENT},
+    )
+    return list(found.scalars())
+
+
+def _state(name: str) -> tuple[bool, bool] | None:
+    """`(valid, attached)` of an index, `None` when it does not exist."""
+    row = (
+        op.get_bind()
+        .execute(
+            sa.text(
+                "SELECT x.indisvalid, EXISTS (SELECT 1 FROM pg_inherits i "
+                "WHERE i.inhrelid = c.oid) FROM pg_class c JOIN pg_index x "
+                "ON x.indexrelid = c.oid WHERE c.relname = :name "
+                "AND c.relnamespace = (SELECT relnamespace FROM pg_class "
+                "WHERE oid = CAST(:parent AS regclass))"
+            ),
+            {"name": name, "parent": PARENT},
+        )
+        .first()
+    )
+    return None if row is None else (bool(row[0]), bool(row[1]))
+
+
+def _build(index: BtreeIndex) -> None:
+    """Build the index on every partition without blocking writes."""
+    op.execute(f"CREATE INDEX IF NOT EXISTS {index.name} ON ONLY {PARENT} {index.definition}")
+    with op.get_context().autocommit_block():
+        for partition in _partitions():
+            name = f"{partition}_{index.suffix}"
+            state = _state(name)
+            if state is not None and not state[0]:
+                op.execute(f"DROP INDEX CONCURRENTLY IF EXISTS {name}")
+                state = None
+            if state is None:
+                op.execute(f"CREATE INDEX CONCURRENTLY {name} ON {partition} {index.definition}")
+            if state is None or not state[1]:
+                op.execute(f"ALTER INDEX {index.name} ATTACH PARTITION {name}")
+    if _state(index.name) != (True, False):
+        raise RuntimeError(f"index {index.name} is not valid after attaching every partition")
+
+
+def _swap(old: BtreeIndex, new: BtreeIndex) -> None:
+    """Build `new`, then drop `old` once `new` is valid."""
+    _build(new)
+    op.execute(f"DROP INDEX IF EXISTS {old.name}")
+
+
+def upgrade() -> None:
+    _swap(NEW, OLD)
+
+
+def downgrade() -> None:
+    """Nothing to undo: the plain index is the one revision 0025 had."""

lorebase_store/_migrations/versions/0027_vault_rotation_and_tombstones.py

@@ -0,0 +1,145 @@
+"""Vault key rotation, erasure tombstones and lineage, installation secrets (design 13.5).
+
+- `vault.fingerprint_key` names the token key and scheme a row's fingerprint was made under
+  (`<token_key_id>/<scheme>`); rows stored before have none and are made again by the rotation
+  job (`lorebase_store.vault.rotation`).
+- `vault_tombstones` keeps the fingerprints of erased values, so a later write of one is stored
+  erased or refused (`vault.erased_values`).
+- `vault_lineage` records a Record that took over the vaulted values of another key of its Kind
+  (a key change), so erasing one erases both.
+- `installation_secrets` holds a random secret made here: the key of the keyed digests
+  (Operation parameters, erased Record keys in the audit log) when no `vault.digest_key` and no
+  vault keys are configured.
+
+Revision ID: 0027
+Revises: 0026
+Create Date: 2026-10-27 09:00:00.000000
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "0027"
+down_revision: str | Sequence[str] | None = "0026"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+TOMBSTONES = "vault_tombstones"
+LINEAGE = "vault_lineage"
+SECRETS = "installation_secrets"
+
+DOMAIN_VISIBLE = (
+    "current_setting('lorebase.bypass_rls', true) = 'on' "
+    "OR domain_id = ANY (string_to_array(current_setting('lorebase.domain_ids', true), ','))"
+)
+
+
+def _isolate(table: str) -> None:
+    op.execute(f"ALTER TABLE {table} ENABLE ROW LEVEL SECURITY")
+    op.execute(f"ALTER TABLE {table} FORCE ROW LEVEL SECURITY")
+    op.execute(
+        f"CREATE POLICY domain_isolation ON {table} "
+        f"USING ({DOMAIN_VISIBLE}) WITH CHECK ({DOMAIN_VISIBLE})"
+    )
+
+
+def upgrade() -> None:
+    op.add_column("vault", sa.Column("fingerprint_key", sa.Text(), nullable=True))
+
+    op.create_table(
+        TOMBSTONES,
+        sa.Column("domain_id", sa.Text(), nullable=False),
+        sa.Column("seq", sa.BigInteger(), sa.Identity(always=True), nullable=False),
+        sa.Column("kind_id", sa.Text(), nullable=False),
+        sa.Column("attribute_id", sa.Text(), nullable=False),
+        sa.Column("record_key", sa.Text(), nullable=True),
+        sa.Column("fingerprint", sa.LargeBinary(), nullable=False),
+        sa.Column("fingerprint_key", sa.Text(), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(
+            ["domain_id"],
+            ["domains.id"],
+            name=op.f("fk_vault_tombstones_domain_id_domains"),
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint("domain_id", "seq", name=op.f("pk_vault_tombstones")),
+    )
+    op.create_index(
+        op.f("ix_vault_tombstones_domain_id_fingerprint"), TOMBSTONES, ["domain_id", "fingerprint"]
+    )
+    _isolate(TOMBSTONES)
+
+    op.create_table(
+        LINEAGE,
+        sa.Column("domain_id", sa.Text(), nullable=False),
+        sa.Column("kind_id", sa.Text(), nullable=False),
+        sa.Column("record_key", sa.Text(), nullable=False),
+        sa.Column("previous_key", sa.Text(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(
+            ["domain_id"],
+            ["domains.id"],
+            name=op.f("fk_vault_lineage_domain_id_domains"),
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint(
+            "domain_id", "kind_id", "record_key", "previous_key", name=op.f("pk_vault_lineage")
+        ),
+    )
+    op.create_index(
+        op.f("ix_vault_lineage_domain_id_kind_id_previous_key"),
+        LINEAGE,
+        ["domain_id", "kind_id", "previous_key"],
+    )
+    _isolate(LINEAGE)
+
+    op.create_table(
+        SECRETS,
+        sa.Column("name", sa.Text(), nullable=False),
+        sa.Column("secret", sa.Text(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.PrimaryKeyConstraint("name", name=op.f("pk_installation_secrets")),
+    )
+    # 244 random bits from the server's cryptographic generator (gen_random_uuid, Postgres 13+).
+    op.execute(
+        f"INSERT INTO {SECRETS} (name, secret) "
+        "VALUES ('digest', replace(gen_random_uuid()::text || gen_random_uuid()::text, '-', ''))"
+    )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    # Row-level security is forced on the owner too: count the rows of every Domain.
+    bind.execute(sa.text("SELECT set_config('lorebase.bypass_rls', 'on', true)"))
+    for table in (TOMBSTONES, LINEAGE):
+        stored = bind.execute(sa.text(f"SELECT count(*) FROM {table}")).scalar_one()
+        if stored:
+            raise RuntimeError(
+                f"{stored} row(s) in {table}: without them erased values could be stored again "
+                "and erasure would miss earlier keys; keep this revision"
+            )
+    op.drop_table(SECRETS)
+    op.drop_index(op.f("ix_vault_lineage_domain_id_kind_id_previous_key"), table_name=LINEAGE)
+    op.drop_table(LINEAGE)
+    op.drop_index(op.f("ix_vault_tombstones_domain_id_fingerprint"), table_name=TOMBSTONES)
+    op.drop_table(TOMBSTONES)
+    op.drop_column("vault", "fingerprint_key")

lorebase_store/_migrations/versions/0028_operation_deferred_events.py

@@ -0,0 +1,71 @@
+"""Deferred Operation events.
+
+`operation_deferred_events` holds the `operation.<side effect>` events of executions committed
+on a branch whose Proposal is their review (agent writes). The merge that brings the execution
+into its target writes them to the outbox and deletes them, in its transaction. Under the
+`domain_isolation` policy like every table with a `domain_id`.
+
+Revision ID: 0028
+Revises: 0027
+Create Date: 2026-10-27 10:00:00.000000
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "0028"
+down_revision: str | Sequence[str] | None = "0027"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+DEFERRED = "operation_deferred_events"
+
+DOMAIN_VISIBLE = (
+    "current_setting('lorebase.bypass_rls', true) = 'on' "
+    "OR domain_id = ANY (string_to_array(current_setting('lorebase.domain_ids', true), ','))"
+)
+
+
+def upgrade() -> None:
+    op.create_table(
+        DEFERRED,
+        sa.Column("id", sa.BigInteger(), sa.Identity(always=True), nullable=False),
+        sa.Column("domain_id", sa.Text(), nullable=False),
+        sa.Column("branch", sa.Text(), nullable=False),
+        sa.Column("revision_id", sa.LargeBinary(), nullable=False),
+        sa.Column("invocation_id", sa.Text(), nullable=False),
+        sa.Column("event_type", sa.Text(), nullable=False),
+        sa.Column("payload", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(
+            ["domain_id"],
+            ["domains.id"],
+            name=op.f("fk_operation_deferred_events_domain_id_domains"),
+            ondelete="CASCADE",
+        ),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_operation_deferred_events")),
+    )
+    op.create_index(
+        op.f("ix_operation_deferred_events_domain_id_branch"), DEFERRED, ["domain_id", "branch"]
+    )
+    op.execute(f"ALTER TABLE {DEFERRED} ENABLE ROW LEVEL SECURITY")
+    op.execute(f"ALTER TABLE {DEFERRED} FORCE ROW LEVEL SECURITY")
+    op.execute(
+        f"CREATE POLICY domain_isolation ON {DEFERRED} "
+        f"USING ({DOMAIN_VISIBLE}) WITH CHECK ({DOMAIN_VISIBLE})"
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(op.f("ix_operation_deferred_events_domain_id_branch"), table_name=DEFERRED)
+    op.drop_table(DEFERRED)

lorebase_store/_migrations/versions/0029_agent_trace_sessions.py

@@ -0,0 +1,108 @@
+"""Agent trace session rows.
+
+`agent_trace_sessions` holds the number of steps of each session and actor: the trace writer
+raises it under the row lock in the transaction writing the steps, so the per-session cap holds
+across Keepers. `agent_trace_session_domains` summarizes the steps of a session per Domain
+(calls, notes, first and last step, tools, Proposals); sessions are listed from it instead of
+grouping the steps of the retention period. Both are filled from the existing steps.
+
+Revision ID: 0029
+Revises: 0028
+Create Date: 2026-10-27 11:00:00.000000
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "0029"
+down_revision: str | Sequence[str] | None = "0028"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+SESSIONS = "agent_trace_sessions"
+DOMAINS = "agent_trace_session_domains"
+
+BYPASS = "current_setting('lorebase.bypass_rls', true) = 'on'"
+
+DOMAIN_VISIBLE = (
+    "current_setting('lorebase.bypass_rls', true) = 'on' "
+    "OR domain_id = ANY (string_to_array(current_setting('lorebase.domain_ids', true), ','))"
+)
+
+
+def upgrade() -> None:
+    op.create_table(
+        SESSIONS,
+        sa.Column("actor", sa.Text(), nullable=False),
+        sa.Column("session_id", sa.Text(), nullable=False),
+        sa.Column("steps", sa.Integer(), nullable=False),
+        sa.Column("last_at", sa.DateTime(timezone=True), nullable=False),
+        sa.PrimaryKeyConstraint("actor", "session_id", name=op.f("pk_agent_trace_sessions")),
+    )
+    op.create_table(
+        DOMAINS,
+        sa.Column("id", sa.BigInteger(), sa.Identity(always=True), nullable=False),
+        sa.Column("actor", sa.Text(), nullable=False),
+        sa.Column("session_id", sa.Text(), nullable=False),
+        sa.Column("domain_id", sa.Text(), nullable=True),
+        sa.Column("started_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("last_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("calls", sa.Integer(), nullable=False),
+        sa.Column("notes", sa.Integer(), nullable=False),
+        sa.Column("inferred", sa.Boolean(), nullable=False),
+        sa.Column("tools", postgresql.ARRAY(sa.Text()), nullable=False),
+        sa.Column("proposals", postgresql.ARRAY(sa.Text()), nullable=False),
+        sa.PrimaryKeyConstraint("id", name=op.f("pk_agent_trace_session_domains")),
+        sa.UniqueConstraint(
+            "actor",
+            "session_id",
+            "domain_id",
+            name=op.f("uq_agent_trace_session_domains_actor_session_id_domain_id"),
+            postgresql_nulls_not_distinct=True,
+        ),
+    )
+    op.create_index(
+        op.f("ix_agent_trace_session_domains_actor_last_at"), DOMAINS, ["actor", "last_at"]
+    )
+    op.create_index(
+        op.f("ix_agent_trace_session_domains_domain_id_last_at"), DOMAINS, ["domain_id", "last_at"]
+    )
+    # No Domain: readable and writable only with row-level security bypassed, as the trace
+    # repository does.
+    op.execute(f"ALTER TABLE {SESSIONS} ENABLE ROW LEVEL SECURITY")
+    op.execute(f"ALTER TABLE {SESSIONS} FORCE ROW LEVEL SECURITY")
+    op.execute(f"CREATE POLICY bypass_only ON {SESSIONS} USING ({BYPASS}) WITH CHECK ({BYPASS})")
+    op.execute(f"ALTER TABLE {DOMAINS} ENABLE ROW LEVEL SECURITY")
+    op.execute(f"ALTER TABLE {DOMAINS} FORCE ROW LEVEL SECURITY")
+    op.execute(
+        f"CREATE POLICY domain_isolation ON {DOMAINS} "
+        f"USING ({DOMAIN_VISIBLE}) WITH CHECK ({DOMAIN_VISIBLE})"
+    )
+    op.execute("SELECT set_config('lorebase.bypass_rls', 'on', true)")
+    op.execute(
+        f"INSERT INTO {SESSIONS} (actor, session_id, steps, last_at) "
+        "SELECT actor, session_id, count(*), max(at) FROM agent_trace_steps "
+        "GROUP BY actor, session_id"
+    )
+    op.execute(
+        f"INSERT INTO {DOMAINS} (actor, session_id, domain_id, started_at, last_at, calls, "
+        "notes, inferred, tools, proposals) "
+        "SELECT actor, session_id, domain_id, min(at), max(at), "
+        "count(*) FILTER (WHERE type = 'call'), count(*) FILTER (WHERE type = 'note'), "
+        "bool_or(inferred), "
+        "array_remove(array_agg(DISTINCT tool), NULL), "
+        "array_remove(array_agg(DISTINCT proposal_id), NULL) "
+        "FROM agent_trace_steps GROUP BY actor, session_id, domain_id"
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(op.f("ix_agent_trace_session_domains_domain_id_last_at"), table_name=DOMAINS)
+    op.drop_index(op.f("ix_agent_trace_session_domains_actor_last_at"), table_name=DOMAINS)
+    op.drop_table(DOMAINS)
+    op.drop_table(SESSIONS)