sqlbuild 0.45.0__tar.gz → 0.45.2__tar.gz

sqlbuild-0.45.2/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.45.2"
+}

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.45.2](https://github.com/chio-labs/sqlbuild/compare/v0.45.1...v0.45.2) (2026-06-28)
+
+
+### Bug Fixes
+
+* **dbt:** isolate defer clone prephase output ([9806c24](https://github.com/chio-labs/sqlbuild/commit/9806c24e4dfac3362b78e42dffc5af61248a8912))
+* **dbt:** isolate defer clone prephase output ([4a6e9ff](https://github.com/chio-labs/sqlbuild/commit/4a6e9ff60393de9904b62bef5c6fae3880216456))
+
+## [0.45.1](https://github.com/chio-labs/sqlbuild/compare/v0.45.0...v0.45.1) (2026-06-28)
+
+
+### Bug Fixes
+
+* **dbt:** defer clone pure dbt selections ([299fc98](https://github.com/chio-labs/sqlbuild/commit/299fc98c38782844ca4574068e87c3857717bfc6))
+* **dbt:** defer clone pure dbt selections ([978bbdd](https://github.com/chio-labs/sqlbuild/commit/978bbdd36dd8f91a2de8549fb7b8dbd0cb7929ed))
+
 ## [0.45.0](https://github.com/chio-labs/sqlbuild/compare/v0.44.4...v0.45.0) (2026-06-28)
 
 

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.45.0
+Version: 0.45.2
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sqlbuild"
-version = "0.45.0"
+version = "0.45.2"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/scripts/structure/structure_conventions/checker.py

@@ -45,6 +45,7 @@ from scripts.structure.structure_conventions.rules import (
     check_no_raw_runtime_diagnostics,
     check_no_relative_imports,
     check_no_sibling_package_imports,
+    check_no_singular_source_freshness_writer,
     check_no_standalone_comments,
     check_no_swallowed_exception_probes,
     check_private_definition_ordering,
@@ -104,6 +105,7 @@ def check_paths(paths: list[Path], repo_root: Path | None = None) -> list[Violat
         violations.extend(check_target_reuse_terminology(file_path))
         violations.extend(check_no_swallowed_exception_probes(file_path, module))
         violations.extend(check_no_metadata_calls_in_loops(file_path, module))
+        violations.extend(check_no_singular_source_freshness_writer(file_path, module))
         violations.extend(check_no_ad_hoc_dbt_ref_scans(file_path, module))
         violations.extend(check_no_ad_hoc_dbt_graph_projection(file_path, module))
         violations.extend(check_no_ad_hoc_selector_plus_parsing(file_path, module))

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/scripts/structure/structure_conventions/rules.py

@@ -105,6 +105,7 @@ _DOCSTRING_BEARING_NODE_TYPES: tuple[type[ast.AST], ...] = (
     ast.AsyncFunctionDef,
     ast.ClassDef,
 )
+_SOURCE_FRESHNESS_SINGULAR_WRITER_NAME: str = "write_source_freshness_record"
 
 
 def parse_python_module(file_path: Path) -> ast.Module:
@@ -216,6 +217,54 @@ def check_no_raw_color_helper_imports(file_path: Path, module: ast.Module) -> li
     return violations
 
 
+def check_no_singular_source_freshness_writer(
+    file_path: Path, module: ast.Module
+) -> list[Violation]:
+    """Reject per-record source freshness writer imports and calls."""
+
+    violations: list[Violation] = []
+    for node in ast.walk(module):
+        if isinstance(node, ast.ImportFrom):
+            alias: ast.alias
+            for alias in node.names:
+                if alias.name == _SOURCE_FRESHNESS_SINGULAR_WRITER_NAME:
+                    violations.append(
+                        Violation(
+                            code="SC057",
+                            path=file_path,
+                            line=node.lineno,
+                            message=(
+                                "source freshness state writes must use "
+                                "write_source_freshness_records() batch writes"
+                            ),
+                        )
+                    )
+        if (
+            isinstance(node, ast.Call)
+            and _call_name(node) == _SOURCE_FRESHNESS_SINGULAR_WRITER_NAME
+        ):
+            violations.append(
+                Violation(
+                    code="SC057",
+                    path=file_path,
+                    line=node.lineno,
+                    message=(
+                        "source freshness state writes must use "
+                        "write_source_freshness_records() batch writes"
+                    ),
+                )
+            )
+    return violations
+
+
+def _call_name(node: ast.Call) -> str | None:
+    if isinstance(node.func, ast.Name):
+        return node.func.id
+    if isinstance(node.func, ast.Attribute):
+        return node.func.attr
+    return None
+
+
 def check_no_internal_reexport_modules(
     repo_root: Path, file_path: Path, module: ast.Module
 ) -> list[Violation]:

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/src/sqlbuild/cli/commands/main/build.py

@@ -247,13 +247,15 @@ def run_build(
                 origin_target_name=effective_defer_clone_from,
                 destination_target_name=cloned_project.effective_target_name,
                 no_sql_validation=no_sql_validation,
-                select=boundary_selectors,
+                select=(*boundary_selectors, *view_chain_selectors),
+                caused_by_names=select,
                 cli_vars=cli_vars,
                 connection_config=connection_config,
                 project_dir=effective_project_dir,
                 on_progress=planning_progress.on_progress,
+                progress_stream=progress_stream,
+                use_color=use_color,
             )
-            select = (*select, *view_chain_selectors)
 
         progress_stream.write("\n")
         progress_stream.flush()

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/src/sqlbuild/cli/commands/main/helpers/build_defer_clone.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, TextIO
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.cli.commands.main.shared.exceptions import CliUserError
@@ -28,12 +28,14 @@ from sqlbuild.compiler.planner.main.scope import build_planner_scope
 from sqlbuild.compiler.planner.models import PlannerScope
 from sqlbuild.executor.clone.main.execute import execute_clone
 from sqlbuild.executor.clone.main.fingerprinting import copy_clone_fingerprints
-from sqlbuild.executor.clone.models import CloneExecutionResult
-from sqlbuild.executor.clone.types import CloneStatus
+from sqlbuild.executor.clone.models import CloneExecutionResult, CloneItemResult
+from sqlbuild.executor.clone.types import CloneAction, CloneStatus
 from sqlbuild.shared.helpers.graph_algorithms import (
     resolve_clone_boundary,
     resolve_skipped_view_chain,
 )
+from sqlbuild.shared.helpers.prephase_progress import write_prephase_header, write_prephase_rows
+from sqlbuild.shared.models import PrephaseProgressRow
 
 
 def build_defer_clone_boundary_selectors(
@@ -117,10 +119,13 @@ def run_defer_clone_prephase(
     destination_target_name: str | None,
     no_sql_validation: bool,
     select: tuple[str, ...],
+    caused_by_names: tuple[str, ...],
     cli_vars: dict[str, object] | None,
     connection_config: dict[str, object],
     project_dir: Path,
     on_progress: Any,
+    progress_stream: TextIO | None = None,
+    use_color: bool = False,
 ) -> None:
     """Clone selected boundary relations from origin before build planning."""
 
@@ -202,6 +207,47 @@ def run_defer_clone_prephase(
             on_progress(
                 f"Cloned deferred boundary relations. ({time.monotonic() - clone_start:.2f}s)"
             )
+        if progress_stream is not None:
+            write_prephase_header(stream=progress_stream, title="defer clone", use_color=use_color)
+            write_prephase_rows(
+                stream=progress_stream,
+                rows=_prephase_rows_from_clone_result(
+                    result=result,
+                    caused_by_names=caused_by_names,
+                ),
+                use_color=use_color,
+            )
     finally:
         adapter.close(origin_connection)
         adapter.close(destination_connection)
+
+
+def _prephase_rows_from_clone_result(
+    *, result: CloneExecutionResult, caused_by_names: tuple[str, ...]
+) -> tuple[PrephaseProgressRow, ...]:
+    return tuple(
+        PrephaseProgressRow(
+            label=_clone_item_label(item),
+            name=item.name,
+            status=_clone_item_status(item),
+            duration_seconds=item.duration_seconds,
+            caused_by_names=caused_by_names,
+        )
+        for item in result.item_results
+    )
+
+
+def _clone_item_label(item: CloneItemResult) -> str:
+    if item.action == CloneAction.RECREATED_VIEW:
+        return "view"
+    if item.action == CloneAction.COPIED:
+        return "copy"
+    return "clone"
+
+
+def _clone_item_status(item: CloneItemResult) -> str:
+    if item.status == CloneStatus.SUCCESS:
+        return "OK"
+    if item.status == CloneStatus.WARNING:
+        return "WARN"
+    return "FAIL"

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/src/sqlbuild/cli/commands/main/helpers/source_freshness.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from sqlbuild.adapter.base.base_adapter import BaseAdapter
 from sqlbuild.compiler.planner.models import ModelPlanEntry, PlanOutput
-from sqlbuild.compiler.source_freshness.main.write import write_source_freshness_record
+from sqlbuild.compiler.source_freshness.main.write import write_source_freshness_records
 from sqlbuild.compiler.source_freshness.models import (
     SourceFreshnessIdentity,
     SourceFreshnessRecord,
@@ -46,6 +46,7 @@ def append_eligible_standard_source_freshness_records(
 
     connection: Any = adapter.connect(connection_config)
     try:
+        records_by_location: dict[tuple[str | None, str], list[SourceFreshnessRecord]] = {}
         identity: SourceFreshnessIdentity
         affected_model_names: frozenset[str]
         for (
@@ -62,41 +63,57 @@ def append_eligible_standard_source_freshness_records(
             record: SourceFreshnessRecord | None = observed_records_by_identity.get(identity)
             if record is None:
                 continue
-            _append_record_to_affected_model_schemas(
-                adapter=adapter,
-                connection=connection,
+            _collect_record_for_affected_model_schemas(
+                records_by_location=records_by_location,
                 record=replace(record, run_id=run_id),
                 affected_model_names=affected_selected_model_names,
                 entries_by_name=entries_by_name,
             )
+        _append_records_by_location(
+            adapter=adapter,
+            connection=connection,
+            records_by_location=records_by_location,
+        )
     finally:
         adapter.close(connection)
 
 
-def _append_record_to_affected_model_schemas(
+def _collect_record_for_affected_model_schemas(
     *,
-    adapter: BaseAdapter,
-    connection: Any,
+    records_by_location: dict[tuple[str | None, str], list[SourceFreshnessRecord]],
     record: SourceFreshnessRecord,
     affected_model_names: frozenset[str],
     entries_by_name: dict[str, ModelPlanEntry],
 ) -> None:
-    written_locations: set[tuple[str | None, str]] = set()
+    recorded_locations: set[tuple[str | None, str]] = set()
     model_name: str
     for model_name in sorted(affected_model_names):
         entry: ModelPlanEntry | None = entries_by_name.get(model_name)
         if entry is None or entry.destination.schema is None:
             continue
         location: tuple[str | None, str] = (entry.destination.database, entry.destination.schema)
-        if location in written_locations:
+        if location in recorded_locations:
             continue
-        written_locations.add(location)
-        write_source_freshness_record(
+        recorded_locations.add(location)
+        records_by_location.setdefault(location, []).append(record)
+
+
+def _append_records_by_location(
+    *,
+    adapter: BaseAdapter,
+    connection: Any,
+    records_by_location: dict[tuple[str | None, str], list[SourceFreshnessRecord]],
+) -> None:
+    location: tuple[str | None, str]
+    records: list[SourceFreshnessRecord]
+    for location, records in records_by_location.items():
+        database, schema = location
+        write_source_freshness_records(
             connection=connection,
             execute=adapter.execute,
-            database=entry.destination.database,
-            schema=entry.destination.schema,
-            record=record,
+            database=database,
+            schema=schema,
+            records=tuple(records),
             render_qualified_name=adapter.render_qualified_name,
             render_framework_type=adapter.render_framework_type,
             render_create_index_sqls=adapter.render_create_source_freshness_index_sqls,

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/src/sqlbuild/compiler/source_freshness/main/write.py

@@ -13,21 +13,23 @@ from sqlbuild.compiler.source_freshness.main.shared.helpers.sql import (
 from sqlbuild.compiler.source_freshness.models import SourceFreshnessRecord
 
 
-def write_source_freshness_record(
+def write_source_freshness_records(
     *,
     connection: Any,
     execute: Any,
     database: str | None,
     schema: str,
-    record: SourceFreshnessRecord,
+    records: tuple[SourceFreshnessRecord, ...],
     render_qualified_name: Callable[..., str | None],
     render_framework_type: Callable[[FrameworkType], str],
     render_create_table_sql: Callable[..., str] | None = None,
     render_create_index_sqls: Callable[..., tuple[str, ...]] | None = None,
     transient: bool = False,
 ) -> None:
-    """Append one source freshness row, creating the table if needed."""
+    """Append source freshness rows, creating the table once if needed."""
 
+    if not records:
+        return
     create_sql: str = (
         render_create_table_sql(database=database, schema=schema)
         if render_create_table_sql is not None
@@ -44,19 +46,21 @@ def write_source_freshness_record(
         index_sql: str
         for index_sql in render_create_index_sqls(database=database, schema=schema):
             execute(connection, index_sql)
-    insert_sql: str = build_insert_sql(
-        database=database,
-        schema=schema,
-        source_name=record.source_name,
-        target_database=record.target_database,
-        target_schema=record.target_schema,
-        target_name=record.target_name,
-        run_id=record.run_id,
-        strategy=record.strategy,
-        value_kind=record.value_kind,
-        data_version=record.data_version,
-        data_version_hash=record.data_version_hash,
-        observed_at=record.observed_at.isoformat(),
-        render_qualified_name=render_qualified_name,
-    )
-    execute(connection, insert_sql)
+    record: SourceFreshnessRecord
+    for record in records:
+        insert_sql: str = build_insert_sql(
+            database=database,
+            schema=schema,
+            source_name=record.source_name,
+            target_database=record.target_database,
+            target_schema=record.target_schema,
+            target_name=record.target_name,
+            run_id=record.run_id,
+            strategy=record.strategy,
+            value_kind=record.value_kind,
+            data_version=record.data_version,
+            data_version_hash=record.data_version_hash,
+            observed_at=record.observed_at.isoformat(),
+            render_qualified_name=render_qualified_name,
+        )
+        execute(connection, insert_sql)

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/src/sqlbuild/integrations/dbt/helpers/runtime/event_stream.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import time
 from collections.abc import Callable
 from pathlib import Path
 from typing import TextIO, cast
@@ -64,6 +65,7 @@ def execute_dbt_json_event_stream(
     target_path: Path | None,
     display_total: int | None = None,
     on_node_result: Callable[[DbtNodeExecutionResult], None] | None = None,
+    detail_by_unique_id: dict[str, str] | None = None,
 ) -> tuple[int, tuple[DbtNodeExecutionResult, ...]]:
     """Run dbt and render SQLBuild-styled rows from JSON events."""
 
@@ -72,6 +74,7 @@ def execute_dbt_json_event_stream(
     results: list[DbtNodeExecutionResult] = []
     recorded_unique_ids: set[str] = set()
     started_indexes: dict[str, int] = {}
+    active_nodes: dict[str, tuple[str, float]] = {}
     display_index: int = 0
     status: TransientStatusReporter | None = _start_dbt_status(
         stream=stream,
@@ -127,6 +130,20 @@ def execute_dbt_json_event_stream(
                             result=start_result,
                             display_index=display_index,
                             display_total=display_total,
+                            detail=_node_detail(
+                                unique_id=start_result.unique_id,
+                                detail_by_unique_id=detail_by_unique_id,
+                            ),
+                        )
+                        active_nodes[start_result.unique_id] = (
+                            start_result.node_name,
+                            time.monotonic(),
+                        )
+                        status = _update_active_node_status(
+                            status=status,
+                            active_nodes=active_nodes,
+                            stream=stream,
+                            use_color=use_color,
                         )
                     continue
                 result: DbtNodeExecutionResult | None = parse_dbt_node_result(
@@ -141,6 +158,7 @@ def execute_dbt_json_event_stream(
                 if status is not None:
                     status.close()
                     status = None
+                active_nodes.pop(result.unique_id, None)
                 results.append(result)
                 if on_node_result is not None:
                     on_node_result(result)
@@ -154,6 +172,16 @@ def execute_dbt_json_event_stream(
                     result=result,
                     display_index=result_display_index,
                     display_total=display_total,
+                    detail=_node_detail(
+                        unique_id=result.unique_id,
+                        detail_by_unique_id=detail_by_unique_id,
+                    ),
+                )
+                status = _update_active_node_status(
+                    status=status,
+                    active_nodes=active_nodes,
+                    stream=stream,
+                    use_color=use_color,
                 )
 
     returncode: int = process.wait()
@@ -173,6 +201,38 @@ def _start_dbt_status(*, stream: TextIO, use_color: bool) -> TransientStatusRepo
     return status
 
 
+def _update_active_node_status(
+    *,
+    status: TransientStatusReporter | None,
+    active_nodes: dict[str, tuple[str, float]],
+    stream: TextIO,
+    use_color: bool,
+) -> TransientStatusReporter | None:
+    if not stream.isatty() or not active_nodes:
+        return None
+    message: str = _format_active_node_status(active_nodes=active_nodes)
+    if status is None:
+        status = TransientStatusReporter(stream=stream, use_color=use_color)
+        status.start(message)
+        return status
+    status.update(message)
+    return status
+
+
+def _format_active_node_status(*, active_nodes: dict[str, tuple[str, float]]) -> str:
+    now: float = time.monotonic()
+    ordered: tuple[tuple[str, float], ...] = tuple(
+        sorted(active_nodes.values(), key=lambda item: item[1])
+    )
+    displayed: tuple[str, ...] = tuple(
+        f"{name} {max(0, int(now - started_at))}s" for name, started_at in ordered[:3]
+    )
+    extra_count: int = len(ordered) - len(displayed)
+    suffix: str = f", +{extra_count} more" if extra_count > 0 else ""
+    node_label: str = "node" if len(active_nodes) == 1 else "nodes"
+    return f"running {len(active_nodes)} dbt {node_label}: {', '.join(displayed)}{suffix}"
+
+
 def parse_dbt_node_start_message(*, event: dict[str, object]) -> str | None:
     """Parse a dbt node-start event into a user-facing progress message."""
 
@@ -311,6 +371,7 @@ def render_dbt_node_result(
     result: DbtNodeExecutionResult,
     display_index: int | None = None,
     display_total: int | None = None,
+    detail: str = "",
 ) -> None:
     ctr: str = (
         f"{display_index}/{display_total}"
@@ -330,7 +391,7 @@ def render_dbt_node_result(
         + format_aligned_name_value(
             plain_name=name,
             styled_name=style.dbt_object_name(name),
-            value=f"{style.status(status)} {duration}".rstrip(),
+            value=f"{style.status(status)} {duration}{detail}".rstrip(),
             name_column_width=30,
             prefix=" ",
         )
@@ -342,6 +403,12 @@ def render_dbt_node_result(
     stream.flush()
 
 
+def _node_detail(*, unique_id: str, detail_by_unique_id: dict[str, str] | None) -> str:
+    if detail_by_unique_id is None:
+        return ""
+    return detail_by_unique_id.get(unique_id, "")
+
+
 def _display_status(status: str) -> str:
     normalized: str = status.lower()
     if normalized in {"ok", "success"}:

{sqlbuild-0.45.0 → sqlbuild-0.45.2}/src/sqlbuild/integrations/dbt/pipeline/helpers/defer_clone.py

@@ -20,6 +20,7 @@ from sqlbuild.integrations.dbt.helpers.graph.core import (
     build_dbt_combined_graph,
     combined_graph_node_is_clonable,
     combined_graph_node_is_view,
+    dbt_model_graph_key,
     sqlbuild_model_graph_key,
 )
 from sqlbuild.integrations.dbt.helpers.manifest.core import build_dbt_manifest_index
@@ -82,9 +83,10 @@ def run_dbt_defer_clone_prephase(
     current_manifest: DbtManifestIndex,
     unique_ids: tuple[str, ...],
     on_progress: Callable[[str], None] | None,
-) -> None:
+) -> CloneExecutionResult | None:
     if not unique_ids:
-        return
+        _report_progress(on_progress, "defer-clone enabled but no clonable dbt boundary resolved.")
+        return None
     production_ref: DbtProductionRefConfig = discovered_inputs.project_config.dbt.production_ref
     if production_ref.git_ref is None or production_ref.generate_schema_name_override is None:
         raise DbtInteropConfigError(
@@ -147,6 +149,7 @@ def run_dbt_defer_clone_prephase(
         on_progress,
         f"Cloned deferred dbt boundary relations. ({time.monotonic() - clone_start:.2f}s)",
     )
+    return result
 
 
 def resolve_defer_clone_unique_ids(
@@ -155,12 +158,14 @@ def resolve_defer_clone_unique_ids(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
     required_dbt_unique_ids: tuple[str, ...],
 ) -> frozenset[str]:
-    """Resolve the first non-view dbt ancestors to clone for SQLBuild-selected boundaries."""
+    """Resolve the first non-view dbt ancestors to clone for selected boundaries."""
 
-    selected: frozenset[DbtCombinedGraphKey] = frozenset(
-        sqlbuild_model_graph_key(model_name) for model_name in selected_sqlbuild_model_names
+    selected: frozenset[DbtCombinedGraphKey] = _defer_clone_seed_keys(
+        selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
 
     def is_clonable(key: DbtCombinedGraphKey) -> bool:
@@ -190,6 +195,7 @@ def resolve_defer_clone_view_chain_terms(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
 ) -> tuple[str, ...]:
     """Return dbt model selector terms for view ancestors that must rebuild over clones."""
 
@@ -198,6 +204,7 @@ def resolve_defer_clone_view_chain_terms(
         manifest=manifest,
         project=project,
         selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
     terms: set[str] = set()
     view_key: DbtCombinedGraphKey
@@ -216,6 +223,7 @@ def resolve_defer_clone_view_chain_unique_ids(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
 ) -> frozenset[str]:
     """Return dbt model unique IDs for view ancestors that must rebuild over clones."""
 
@@ -224,6 +232,7 @@ def resolve_defer_clone_view_chain_unique_ids(
         manifest=manifest,
         project=project,
         selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
     return frozenset(
         view_key.name for view_key in view_chain if view_key.owner == DbtCombinedGraphOwner.DBT
@@ -236,9 +245,11 @@ def _resolve_defer_clone_view_chain_keys(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
 ) -> frozenset[DbtCombinedGraphKey]:
-    selected: frozenset[DbtCombinedGraphKey] = frozenset(
-        sqlbuild_model_graph_key(model_name) for model_name in selected_sqlbuild_model_names
+    selected: frozenset[DbtCombinedGraphKey] = _defer_clone_seed_keys(
+        selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
 
     def is_clonable(key: DbtCombinedGraphKey) -> bool:
@@ -257,6 +268,19 @@ def _resolve_defer_clone_view_chain_keys(
     )
 
 
+def _defer_clone_seed_keys(
+    *,
+    selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
+) -> frozenset[DbtCombinedGraphKey]:
+    return frozenset(
+        (
+            *(sqlbuild_model_graph_key(model_name) for model_name in selected_sqlbuild_model_names),
+            *(dbt_model_graph_key(unique_id) for unique_id in selected_dbt_unique_ids),
+        )
+    )
+
+
 def _write_defer_clone_dbt_fingerprints(
     *,
     result: CloneExecutionResult,