flock-core 0.5.10__py3-none-any.whl → 0.5.20__py3-none-any.whl

flock/{store.py → core/store.py}

@@ -10,12 +10,11 @@ contract expected by the REST layer and dashboard.
 
 import asyncio
 import json
-import re
 from asyncio import Lock
 from collections import defaultdict
 from collections.abc import Iterable
 from dataclasses import dataclass, field
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, TypeVar
 from uuid import UUID
@@ -23,59 +22,16 @@ from uuid import UUID
 import aiosqlite
 from opentelemetry import trace
 
-from flock.artifacts import Artifact
+from flock.core.artifacts import Artifact
 from flock.registry import type_registry
-from flock.visibility import (
-    AfterVisibility,
-    LabelledVisibility,
-    PrivateVisibility,
-    PublicVisibility,
-    TenantVisibility,
-    Visibility,
-)
+from flock.storage.artifact_aggregator import ArtifactAggregator
+from flock.utils.type_resolution import TypeResolutionHelper
+from flock.utils.visibility_utils import deserialize_visibility
 
 
 T = TypeVar("T")
 tracer = trace.get_tracer(__name__)
 
-ISO_DURATION_RE = re.compile(
-    r"^P(?:T?(?:(?P<hours>\d+)H)?(?:(?P<minutes>\d+)M)?(?:(?P<seconds>\d+)S)?)$"
-)
-
-
-def _parse_iso_duration(value: str | None) -> timedelta:
-    if not value:
-        return timedelta(0)
-    match = ISO_DURATION_RE.match(value)
-    if not match:
-        return timedelta(0)
-    hours = int(match.group("hours") or 0)
-    minutes = int(match.group("minutes") or 0)
-    seconds = int(match.group("seconds") or 0)
-    return timedelta(hours=hours, minutes=minutes, seconds=seconds)
-
-
-def _deserialize_visibility(data: Any) -> Visibility:
-    if isinstance(data, Visibility):
-        return data
-    if not data:
-        return PublicVisibility()
-    kind = data.get("kind") if isinstance(data, dict) else None
-    if kind == "Public":
-        return PublicVisibility()
-    if kind == "Private":
-        return PrivateVisibility(agents=set(data.get("agents", [])))
-    if kind == "Labelled":
-        return LabelledVisibility(required_labels=set(data.get("required_labels", [])))
-    if kind == "Tenant":
-        return TenantVisibility(tenant_id=data.get("tenant_id"))
-    if kind == "After":
-        ttl = _parse_iso_duration(data.get("ttl"))
-        then_data = data.get("then") if isinstance(data, dict) else None
-        then_visibility = _deserialize_visibility(then_data) if then_data else None
-        return AfterVisibility(ttl=ttl, then=then_visibility)
-    return PublicVisibility()
-
 
 @dataclass(slots=True)
 class ConsumptionRecord:
@@ -232,6 +188,12 @@ class InMemoryBlackboardStore(BlackboardStore):
         )
         self._agent_snapshots: dict[str, AgentSnapshotRecord] = {}
 
+        # Initialize helper subsystems
+        from flock.storage.in_memory.history_aggregator import HistoryAggregator
+
+        self._aggregator = ArtifactAggregator()
+        self._history_aggregator = HistoryAggregator()
+
     async def publish(self, artifact: Artifact) -> None:
         async with self._lock:
             self._by_id[artifact.id] = artifact
@@ -278,39 +240,19 @@ class InMemoryBlackboardStore(BlackboardStore):
         offset: int = 0,
         embed_meta: bool = False,
     ) -> tuple[list[Artifact | ArtifactEnvelope], int]:
+        """Query artifacts using artifact filter helper."""
         async with self._lock:
             artifacts = list(self._by_id.values())
 
+        # Use artifact filter helper for filtering logic
         filters = filters or FilterConfig()
-        canonical: set[str] | None = None
-        if filters.type_names:
-            canonical = {
-                type_registry.resolve_name(name) for name in filters.type_names
-            }
+        from flock.storage.in_memory.artifact_filter import ArtifactFilter
 
-        visibility_filter = filters.visibility or set()
-
-        def _matches(artifact: Artifact) -> bool:
-            if canonical and artifact.type not in canonical:
-                return False
-            if filters.produced_by and artifact.produced_by not in filters.produced_by:
-                return False
-            if filters.correlation_id and (
-                artifact.correlation_id is None
-                or str(artifact.correlation_id) != filters.correlation_id
-            ):
-                return False
-            if filters.tags and not filters.tags.issubset(artifact.tags):
-                return False
-            if visibility_filter and artifact.visibility.kind not in visibility_filter:
-                return False
-            if filters.start and artifact.created_at < filters.start:
-                return False
-            return not (filters.end and artifact.created_at > filters.end)
-
-        filtered = [artifact for artifact in artifacts if _matches(artifact)]
+        artifact_filter = ArtifactFilter(filters)
+        filtered = [a for a in artifacts if artifact_filter.matches(a)]
         filtered.sort(key=lambda a: (a.created_at, a.id))
 
+        # Apply pagination
         total = len(filtered)
         offset = max(offset, 0)
         if limit <= 0:
@@ -334,6 +276,7 @@ class InMemoryBlackboardStore(BlackboardStore):
         self,
         filters: FilterConfig | None = None,
     ) -> dict[str, Any]:
+        """Summarize artifacts using artifact aggregator."""
         filters = filters or FilterConfig()
         artifacts, total = await self.query_artifacts(
             filters=filters,
@@ -342,61 +285,21 @@ class InMemoryBlackboardStore(BlackboardStore):
             embed_meta=False,
         )
 
-        by_type: dict[str, int] = {}
-        by_producer: dict[str, int] = {}
-        by_visibility: dict[str, int] = {}
-        tag_counts: dict[str, int] = {}
-        earliest: datetime | None = None
-        latest: datetime | None = None
-
+        # Validate artifacts are correct type
         for artifact in artifacts:
             if not isinstance(artifact, Artifact):
                 raise TypeError("Expected Artifact instance")
-            by_type[artifact.type] = by_type.get(artifact.type, 0) + 1
-            by_producer[artifact.produced_by] = (
-                by_producer.get(artifact.produced_by, 0) + 1
-            )
-            kind = getattr(artifact.visibility, "kind", "Unknown")
-            by_visibility[kind] = by_visibility.get(kind, 0) + 1
-            for tag in artifact.tags:
-                tag_counts[tag] = tag_counts.get(tag, 0) + 1
-            if earliest is None or artifact.created_at < earliest:
-                earliest = artifact.created_at
-            if latest is None or artifact.created_at > latest:
-                latest = artifact.created_at
-
-        if earliest and latest:
-            span = latest - earliest
-            if span.days >= 2:
-                span_label = f"{span.days} days"
-            elif span.total_seconds() >= 3600:
-                hours = span.total_seconds() / 3600
-                span_label = f"{hours:.1f} hours"
-            elif span.total_seconds() > 0:
-                minutes = max(1, int(span.total_seconds() / 60))
-                span_label = f"{minutes} minutes"
-            else:
-                span_label = "moments"
-        else:
-            span_label = "empty"
 
-        return {
-            "total": total,
-            "by_type": by_type,
-            "by_producer": by_producer,
-            "by_visibility": by_visibility,
-            "tag_counts": tag_counts,
-            "earliest_created_at": earliest.isoformat() if earliest else None,
-            "latest_created_at": latest.isoformat() if latest else None,
-            "is_full_window": filters.start is None and filters.end is None,
-            "window_span_label": span_label,
-        }
+        # Delegate to aggregator for all aggregation logic
+        is_full_window = filters.start is None and filters.end is None
+        return self._aggregator.build_summary(artifacts, total, is_full_window)
 
     async def agent_history_summary(
         self,
         agent_id: str,
         filters: FilterConfig | None = None,
     ) -> dict[str, Any]:
+        """Summarize agent history using history aggregator."""
         filters = filters or FilterConfig()
         envelopes, _ = await self.query_artifacts(
             filters=filters,
@@ -405,27 +308,8 @@ class InMemoryBlackboardStore(BlackboardStore):
             embed_meta=True,
         )
 
-        produced_total = 0
-        produced_by_type: dict[str, int] = defaultdict(int)
-        consumed_total = 0
-        consumed_by_type: dict[str, int] = defaultdict(int)
-
-        for envelope in envelopes:
-            if not isinstance(envelope, ArtifactEnvelope):
-                raise TypeError("Expected ArtifactEnvelope instance")
-            artifact = envelope.artifact
-            if artifact.produced_by == agent_id:
-                produced_total += 1
-                produced_by_type[artifact.type] += 1
-            for consumption in envelope.consumptions:
-                if consumption.consumer == agent_id:
-                    consumed_total += 1
-                    consumed_by_type[artifact.type] += 1
-
-        return {
-            "produced": {"total": produced_total, "by_type": dict(produced_by_type)},
-            "consumed": {"total": consumed_total, "by_type": dict(consumed_by_type)},
-        }
+        # Delegate to history aggregator for aggregation logic
+        return self._history_aggregator.aggregate(envelopes, agent_id)
 
     async def upsert_agent_snapshot(self, snapshot: AgentSnapshotRecord) -> None:
         async with self._lock:
@@ -451,8 +335,6 @@ __all__ = [
 class SQLiteBlackboardStore(BlackboardStore):
     """SQLite-backed implementation of :class:`BlackboardStore`."""
 
-    SCHEMA_VERSION = 3
-
     def __init__(self, db_path: str, *, timeout: float = 5.0) -> None:
         self._db_path = Path(db_path)
         self._timeout = timeout
@@ -461,6 +343,21 @@ class SQLiteBlackboardStore(BlackboardStore):
         self._write_lock = asyncio.Lock()
         self._schema_ready = False
 
+        # Initialize helper subsystems
+        from flock.storage.sqlite.agent_history_queries import AgentHistoryQueries
+        from flock.storage.sqlite.consumption_loader import SQLiteConsumptionLoader
+        from flock.storage.sqlite.query_builder import SQLiteQueryBuilder
+        from flock.storage.sqlite.query_params_builder import QueryParamsBuilder
+        from flock.storage.sqlite.schema_manager import SQLiteSchemaManager
+        from flock.storage.sqlite.summary_queries import SQLiteSummaryQueries
+
+        self._schema_manager = SQLiteSchemaManager()
+        self._query_builder = SQLiteQueryBuilder()
+        self._consumption_loader = SQLiteConsumptionLoader()
+        self._summary_queries = SQLiteSummaryQueries()
+        self._query_params_builder = QueryParamsBuilder()
+        self._agent_history_queries = AgentHistoryQueries()
+
     async def publish(self, artifact: Artifact) -> None:  # type: ignore[override]
         with tracer.start_as_current_span("sqlite_store.publish"):
             conn = await self._get_connection()
@@ -470,10 +367,9 @@ class SQLiteBlackboardStore(BlackboardStore):
             tags_json = json.dumps(sorted(artifact.tags))
             created_at = artifact.created_at.isoformat()
 
-            try:
-                canonical_type = type_registry.resolve_name(artifact.type)
-            except Exception:
-                canonical_type = artifact.type
+            canonical_type = TypeResolutionHelper.safe_resolve(
+                type_registry, artifact.type
+            )
 
             record = {
                 "artifact_id": str(artifact.id),
@@ -693,16 +589,18 @@ class SQLiteBlackboardStore(BlackboardStore):
         offset: int = 0,
         embed_meta: bool = False,
     ) -> tuple[list[Artifact | ArtifactEnvelope], int]:
+        """Query artifacts using query params builder."""
         filters = filters or FilterConfig()
         conn = await self._get_connection()
 
         where_clause, params = self._build_filters(filters)
-        count_query = f"SELECT COUNT(*) AS total FROM artifacts{where_clause}"  # nosec B608 - where_clause contains only parameter placeholders from _build_filters
-        cursor = await conn.execute(count_query, tuple(params))  # nosec B608
+        count_query = f"SELECT COUNT(*) AS total FROM artifacts{where_clause}"  # nosec B608
+        cursor = await conn.execute(count_query, tuple(params))
         total_row = await cursor.fetchone()
         await cursor.close()
         total = total_row["total"] if total_row else 0
 
+        # Build base query
         query = f"""
             SELECT
                 artifact_id,
@@ -719,17 +617,13 @@ class SQLiteBlackboardStore(BlackboardStore):
             FROM artifacts
             {where_clause}
             ORDER BY created_at ASC, rowid ASC
-        """  # nosec B608 - where_clause contains only parameter placeholders from _build_filters
-        query_params: tuple[Any, ...]
-        if limit <= 0:
-            if offset > 0:
-                query += " LIMIT -1 OFFSET ?"
-                query_params = (*params, max(offset, 0))
-            else:
-                query_params = tuple(params)
-        else:
-            query += " LIMIT ? OFFSET ?"
-            query_params = (*params, limit, max(offset, 0))
+        """  # nosec B608
+
+        # Use query params builder for pagination
+        pagination_clause, query_params = (
+            self._query_params_builder.build_pagination_params(params, limit, offset)
+        )
+        query += pagination_clause
 
         cursor = await conn.execute(query, query_params)
         rows = await cursor.fetchall()
@@ -739,35 +633,11 @@ class SQLiteBlackboardStore(BlackboardStore):
         if not embed_meta or not artifacts:
             return artifacts, total
 
+        # Load consumptions using consumption loader
         artifact_ids = [str(artifact.id) for artifact in artifacts]
-        placeholders = ", ".join("?" for _ in artifact_ids)
-        consumption_query = f"""
-            SELECT
-                artifact_id,
-                consumer,
-                run_id,
-                correlation_id,
-                consumed_at
-            FROM artifact_consumptions
-            WHERE artifact_id IN ({placeholders})
-            ORDER BY consumed_at ASC
-        """  # nosec B608 - placeholders string contains only '?' characters
-        cursor = await conn.execute(consumption_query, artifact_ids)
-        consumption_rows = await cursor.fetchall()
-        await cursor.close()
-
-        consumptions_map: dict[UUID, list[ConsumptionRecord]] = defaultdict(list)
-        for row in consumption_rows:
-            artifact_uuid = UUID(row["artifact_id"])
-            consumptions_map[artifact_uuid].append(
-                ConsumptionRecord(
-                    artifact_id=artifact_uuid,
-                    consumer=row["consumer"],
-                    run_id=row["run_id"],
-                    correlation_id=row["correlation_id"],
-                    consumed_at=datetime.fromisoformat(row["consumed_at"]),
-                )
-            )
+        consumptions_map = await self._consumption_loader.load_for_artifacts(
+            conn, artifact_ids
+        )
 
         envelopes: list[ArtifactEnvelope] = [
             ArtifactEnvelope(
@@ -782,78 +652,32 @@ class SQLiteBlackboardStore(BlackboardStore):
         self,
         filters: FilterConfig | None = None,
     ) -> dict[str, Any]:
+        """Summarize artifacts using summary query builder."""
         filters = filters or FilterConfig()
         conn = await self._get_connection()
 
         where_clause, params = self._build_filters(filters)
         params_tuple = tuple(params)
 
-        count_query = f"SELECT COUNT(*) AS total FROM artifacts{where_clause}"  # nosec B608 - where_clause contains only parameter placeholders from _build_filters
-        cursor = await conn.execute(count_query, params_tuple)  # nosec B608
-        total_row = await cursor.fetchone()
-        await cursor.close()
-        total = total_row["total"] if total_row else 0
-
-        by_type_query = f"""
-            SELECT canonical_type, COUNT(*) AS count
-            FROM artifacts
-            {where_clause}
-            GROUP BY canonical_type
-        """  # nosec B608 - where_clause contains only parameter placeholders from _build_filters
-        cursor = await conn.execute(by_type_query, params_tuple)
-        by_type_rows = await cursor.fetchall()
-        await cursor.close()
-        by_type = {row["canonical_type"]: row["count"] for row in by_type_rows}
-
-        by_producer_query = f"""
-            SELECT produced_by, COUNT(*) AS count
-            FROM artifacts
-            {where_clause}
-            GROUP BY produced_by
-        """  # nosec B608 - where_clause contains only parameter placeholders from _build_filters
-        cursor = await conn.execute(by_producer_query, params_tuple)
-        by_producer_rows = await cursor.fetchall()
-        await cursor.close()
-        by_producer = {row["produced_by"]: row["count"] for row in by_producer_rows}
-
-        by_visibility_query = f"""
-            SELECT json_extract(visibility, '$.kind') AS visibility_kind, COUNT(*) AS count
-            FROM artifacts
-            {where_clause}
-            GROUP BY json_extract(visibility, '$.kind')
-        """  # nosec B608 - where_clause contains only parameter placeholders from _build_filters
-        cursor = await conn.execute(by_visibility_query, params_tuple)
-        by_visibility_rows = await cursor.fetchall()
-        await cursor.close()
-        by_visibility = {
-            (row["visibility_kind"] or "Unknown"): row["count"]
-            for row in by_visibility_rows
-        }
-
-        tag_query = f"""
-            SELECT json_each.value AS tag, COUNT(*) AS count
-            FROM artifacts
-            JOIN json_each(artifacts.tags)
-            {where_clause}
-            GROUP BY json_each.value
-        """  # nosec B608 - where_clause contains only parameter placeholders produced by _build_filters
-        cursor = await conn.execute(tag_query, params_tuple)
-        tag_rows = await cursor.fetchall()
-        await cursor.close()
-        tag_counts = {row["tag"]: row["count"] for row in tag_rows}
-
-        range_query = f"""
-            SELECT MIN(created_at) AS earliest, MAX(created_at) AS latest
-            FROM artifacts
-            {where_clause}
-        """  # nosec B608 - safe composition using parameterized where_clause
-        cursor = await conn.execute(range_query, params_tuple)
-        range_row = await cursor.fetchone()
-        await cursor.close()
-        earliest = (
-            range_row["earliest"] if range_row and range_row["earliest"] else None
+        # Execute all summary queries using summary query builder
+        total = await self._summary_queries.count_total(
+            conn, where_clause, params_tuple
+        )
+        by_type = await self._summary_queries.group_by_type(
+            conn, where_clause, params_tuple
+        )
+        by_producer = await self._summary_queries.group_by_producer(
+            conn, where_clause, params_tuple
+        )
+        by_visibility = await self._summary_queries.group_by_visibility(
+            conn, where_clause, params_tuple
+        )
+        tag_counts = await self._summary_queries.count_tags(
+            conn, where_clause, params_tuple
+        )
+        earliest, latest = await self._summary_queries.get_date_range(
+            conn, where_clause, params_tuple
         )
-        latest = range_row["latest"] if range_row and range_row["latest"] else None
 
         return {
             "total": total,
@@ -870,59 +694,27 @@ class SQLiteBlackboardStore(BlackboardStore):
         agent_id: str,
         filters: FilterConfig | None = None,
     ) -> dict[str, Any]:
+        """Summarize agent history using agent history queries."""
         filters = filters or FilterConfig()
         conn = await self._get_connection()
 
-        produced_total = 0
-        produced_by_type: dict[str, int] = {}
-
-        if filters.produced_by and agent_id not in filters.produced_by:
-            produced_total = 0
-        else:
-            produced_filter = FilterConfig(
-                type_names=set(filters.type_names) if filters.type_names else None,
-                produced_by={agent_id},
-                correlation_id=filters.correlation_id,
-                tags=set(filters.tags) if filters.tags else None,
-                visibility=set(filters.visibility) if filters.visibility else None,
-                start=filters.start,
-                end=filters.end,
-            )
-            where_clause, params = self._build_filters(produced_filter)
-            produced_query = f"""
-                SELECT canonical_type, COUNT(*) AS count
-                FROM artifacts
-                {where_clause}
-                GROUP BY canonical_type
-            """  # nosec B608 - produced_filter yields parameter placeholders only
-            cursor = await conn.execute(produced_query, tuple(params))
-            rows = await cursor.fetchall()
-            await cursor.close()
-            produced_by_type = {row["canonical_type"]: row["count"] for row in rows}
-            produced_total = sum(produced_by_type.values())
-
-        where_clause, params = self._build_filters(filters, table_alias="a")
-        params_with_consumer = (*params, agent_id)
-        consumption_query = f"""
-            SELECT a.canonical_type AS canonical_type, COUNT(*) AS count
-            FROM artifact_consumptions c
-            JOIN artifacts a ON a.artifact_id = c.artifact_id
-            {where_clause}
-            {"AND" if where_clause else "WHERE"} c.consumer = ?
-            GROUP BY a.canonical_type
-        """  # nosec B608 - where_clause joins parameter placeholders only
-        cursor = await conn.execute(consumption_query, params_with_consumer)
-        consumption_rows = await cursor.fetchall()
-        await cursor.close()
-
-        consumed_by_type = {
-            row["canonical_type"]: row["count"] for row in consumption_rows
-        }
-        consumed_total = sum(consumed_by_type.values())
+        # Use agent history queries helper for both produced and consumed
+        produced_by_type = await self._agent_history_queries.query_produced(
+            conn, agent_id, filters, self._build_filters
+        )
+        consumed_by_type = await self._agent_history_queries.query_consumed(
+            conn, agent_id, filters, self._build_filters
+        )
 
         return {
-            "produced": {"total": produced_total, "by_type": produced_by_type},
-            "consumed": {"total": consumed_total, "by_type": consumed_by_type},
+            "produced": {
+                "total": sum(produced_by_type.values()),
+                "by_type": produced_by_type,
+            },
+            "consumed": {
+                "total": sum(consumed_by_type.values()),
+                "by_type": consumed_by_type,
+            },
         }
 
     async def upsert_agent_snapshot(self, snapshot: AgentSnapshotRecord) -> None:
@@ -1051,113 +843,9 @@ class SQLiteBlackboardStore(BlackboardStore):
         return conn
 
     async def _apply_schema(self, conn: aiosqlite.Connection) -> None:
+        """Apply database schema using schema manager."""
         async with self._connection_lock:
-            await conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS schema_meta (
-                    id INTEGER PRIMARY KEY CHECK (id = 1),
-                    version INTEGER NOT NULL,
-                    applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
-                )
-                """
-            )
-            await conn.execute(
-                """
-                INSERT OR IGNORE INTO schema_meta (id, version)
-                VALUES (1, ?)
-                """,
-                (self.SCHEMA_VERSION,),
-            )
-            await conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS artifacts (
-                    artifact_id TEXT PRIMARY KEY,
-                    type TEXT NOT NULL,
-                    canonical_type TEXT NOT NULL,
-                    produced_by TEXT NOT NULL,
-                    payload TEXT NOT NULL,
-                    version INTEGER NOT NULL,
-                    visibility TEXT NOT NULL,
-                    tags TEXT NOT NULL,
-                    correlation_id TEXT,
-                    partition_key TEXT,
-                    created_at TEXT NOT NULL
-                )
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_artifacts_canonical_type_created
-                ON artifacts(canonical_type, created_at)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_artifacts_produced_by_created
-                ON artifacts(produced_by, created_at)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_artifacts_correlation
-                ON artifacts(correlation_id)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_artifacts_partition
-                ON artifacts(partition_key)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS artifact_consumptions (
-                    artifact_id TEXT NOT NULL,
-                    consumer TEXT NOT NULL,
-                    run_id TEXT,
-                    correlation_id TEXT,
-                    consumed_at TEXT NOT NULL,
-                    PRIMARY KEY (artifact_id, consumer, consumed_at)
-                )
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_consumptions_artifact
-                ON artifact_consumptions(artifact_id)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_consumptions_consumer
-                ON artifact_consumptions(consumer)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE INDEX IF NOT EXISTS idx_consumptions_correlation
-                ON artifact_consumptions(correlation_id)
-                """
-            )
-            await conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS agent_snapshots (
-                    agent_name TEXT PRIMARY KEY,
-                    description TEXT NOT NULL,
-                    subscriptions TEXT NOT NULL,
-                    output_types TEXT NOT NULL,
-                    labels TEXT NOT NULL,
-                    first_seen TEXT NOT NULL,
-                    last_seen TEXT NOT NULL,
-                    signature TEXT NOT NULL
-                )
-                """
-            )
-            await conn.execute(
-                "UPDATE schema_meta SET version=? WHERE id=1",
-                (self.SCHEMA_VERSION,),
-            )
-            await conn.commit()
+            await self._schema_manager.apply_schema(conn)
             self._schema_ready = True
 
     def _build_filters(
@@ -1166,54 +854,11 @@ class SQLiteBlackboardStore(BlackboardStore):
         *,
         table_alias: str | None = None,
     ) -> tuple[str, list[Any]]:
-        prefix = f"{table_alias}." if table_alias else ""
-        conditions: list[str] = []
-        params: list[Any] = []
-
-        if filters.type_names:
-            canonical = {
-                type_registry.resolve_name(name) for name in filters.type_names
-            }
-            placeholders = ", ".join("?" for _ in canonical)
-            conditions.append(f"{prefix}canonical_type IN ({placeholders})")
-            params.extend(sorted(canonical))
-
-        if filters.produced_by:
-            placeholders = ", ".join("?" for _ in filters.produced_by)
-            conditions.append(f"{prefix}produced_by IN ({placeholders})")
-            params.extend(sorted(filters.produced_by))
-
-        if filters.correlation_id:
-            conditions.append(f"{prefix}correlation_id = ?")
-            params.append(filters.correlation_id)
-
-        if filters.visibility:
-            placeholders = ", ".join("?" for _ in filters.visibility)
-            conditions.append(
-                f"json_extract({prefix}visibility, '$.kind') IN ({placeholders})"
-            )
-            params.extend(sorted(filters.visibility))
-
-        if filters.start is not None:
-            conditions.append(f"{prefix}created_at >= ?")
-            params.append(filters.start.isoformat())
-
-        if filters.end is not None:
-            conditions.append(f"{prefix}created_at <= ?")
-            params.append(filters.end.isoformat())
-
-        if filters.tags:
-            column = f"{prefix}tags" if table_alias else "artifacts.tags"
-            for tag in sorted(filters.tags):
-                conditions.append(
-                    f"EXISTS (SELECT 1 FROM json_each({column}) WHERE json_each.value = ?)"  # nosec B608 - column is internal constant
-                )
-                params.append(tag)
-
-        where_clause = f" WHERE {' AND '.join(conditions)}" if conditions else ""
-        return where_clause, params
+        """Build WHERE clause using query builder."""
+        return self._query_builder.build_filters(filters, table_alias=table_alias)
 
     def _row_to_artifact(self, row: Any) -> Artifact:
+        """Convert database row to Artifact using visibility utils."""
         payload = json.loads(row["payload"])
         visibility_data = json.loads(row["visibility"])
         tags = json.loads(row["tags"])
@@ -1224,7 +869,7 @@ class SQLiteBlackboardStore(BlackboardStore):
             type=row["type"],
             payload=payload,
             produced_by=row["produced_by"],
-            visibility=_deserialize_visibility(visibility_data),
+            visibility=deserialize_visibility(visibility_data),
             tags=set(tags),
             correlation_id=correlation,
             partition_key=row["partition_key"],