sqlbuild 0.80.1__tar.gz → 0.80.2__tar.gz

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.80.1"
+version = "0.80.2"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.80.1
+Version: 0.80.2
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.80.1"
+version = "0.80.2"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/pyproject.toml

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

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/commands/_helpers/build_execution/outputs.py

@@ -17,6 +17,9 @@ from sqlbuild.cli.commands.models import (
     BuildRunOutcome,
 )
 from sqlbuild.cli.output.main._build_execution_json import format_build_execution_json
+from sqlbuild.cli.output.main._execution_json_degradation import (
+    degraded_execution_json,
+)
 from sqlbuild.cli.output.main._write_execution_json_output import write_execution_json_output
 from sqlbuild.cli.output.main.plan import format_plan
 from sqlbuild.cli.target_artifacts.main._write_python_check_runtime_target import (
@@ -24,11 +27,16 @@ from sqlbuild.cli.target_artifacts.main._write_python_check_runtime_target impor
 )
 from sqlbuild.cli.target_artifacts.main._write_runtime_target import write_runtime_target
 from sqlbuild.compiler.pipeline.models import CompilePipelineResult
+from sqlbuild.compiler.planner.models import PlanOutput
 from sqlbuild.cost.classes.run_cost_store import RunCostStore
 from sqlbuild.cost.models import CostRunRecord
 from sqlbuild.executor.build.models import BuildExecutionResult
 from sqlbuild.executor.build.types import BuildStatus
-from sqlbuild.executor.python_nodes.models import PythonCheckExecutionResult
+from sqlbuild.executor.python_nodes.models import (
+    PythonCheckExecutionResult,
+    PythonNodeExecutionResult,
+)
+from sqlbuild.runtime.observability.exceptions import ObservabilityValidationError
 
 
 def write_build_plan_text(
@@ -93,20 +101,58 @@ def write_build_completion_output(
     )
     invocation.progress_stream.write("\n" + footer + "\n")
     invocation.progress_stream.flush()
+    execution_succeeded: bool = (
+        resolve_build_exit_code(outcome=outcome, check_results=check_results) == 0
+    )
+    payload: str = execution_json_payload_with_degradation(
+        result=outcome.result,
+        plan=pipeline_result.plan_output,
+        python_node_results=outcome.python_results,
+        python_check_results=check_results,
+        command="build",
+        run_id=(None if cost_record is None else pipeline_result.project.run_id),
+        cost_record=cost_record,
+        execution_succeeded=execution_succeeded,
+    )
     write_execution_json_output(
-        payload=format_build_execution_json(
-            result=outcome.result,
-            plan=pipeline_result.plan_output,
-            python_node_results=outcome.python_results,
-            python_check_results=check_results,
-            run_id=(None if cost_record is None else pipeline_result.project.run_id),
-            cost=(None if cost_record is None else RunCostStore.output_payload(record=cost_record)),
-        ),
+        payload=payload,
         json_output=request.json_output,
         json_output_path=request.json_output_path,
     )
 
 
+def execution_json_payload_with_degradation(
+    *,
+    result: BuildExecutionResult,
+    plan: PlanOutput,
+    python_node_results: tuple[PythonNodeExecutionResult, ...],
+    python_check_results: tuple[PythonCheckExecutionResult, ...],
+    command: str,
+    run_id: str | None,
+    cost_record: CostRunRecord | None,
+    execution_succeeded: bool,
+) -> str:
+    """Render the execution JSON payload, degrading on projection failures."""
+
+    try:
+        return format_build_execution_json(
+            result=result,
+            plan=plan,
+            python_node_results=python_node_results,
+            python_check_results=python_check_results,
+            command=command,
+            run_id=run_id,
+            cost=(None if cost_record is None else RunCostStore.output_payload(record=cost_record)),
+        )
+    except (ObservabilityValidationError, TypeError, ValueError) as error:
+        return degraded_execution_json(
+            command=command,
+            status="success" if execution_succeeded else "failed",
+            error=error,
+            execution_succeeded=execution_succeeded,
+        )
+
+
 def write_no_work_build_json(
     *,
     request: BuildCommandRequest,

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/commands/main/execution/_virtual_build.py

@@ -9,6 +9,9 @@ from pathlib import Path
 from typing import TextIO
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
+from sqlbuild.cli.commands._helpers.build_execution.outputs import (
+    execution_json_payload_with_degradation,
+)
 from sqlbuild.cli.commands._helpers.build_execution.phase_timings import (
     record_and_write_virtual_build_phase_timings,
 )
@@ -33,7 +36,6 @@ from sqlbuild.cli.commands.models import (
     VirtualBuildCliRequest,
     VirtualBuildExecution,
 )
-from sqlbuild.cli.output.main._build_execution_json import format_build_execution_json
 from sqlbuild.cli.output.main._write_execution_json_output import write_execution_json_output
 from sqlbuild.cli.target_artifacts.main._write_python_check_runtime_target import (
     write_python_check_runtime_target,
@@ -44,7 +46,6 @@ from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
 from sqlbuild.compiler.pipeline.main.plan_work import plan_has_executable_work
 from sqlbuild.compiler.planner.models import PlanOutput
 from sqlbuild.cost.classes.cost_context import CostContext
-from sqlbuild.cost.classes.run_cost_store import RunCostStore
 from sqlbuild.cost.models import CostRunRecord
 from sqlbuild.cost.types import CostStatus
 from sqlbuild.diagnostics.classes.build_phase_timing_tracker import BuildPhaseTimingTracker
@@ -235,16 +236,18 @@ def _complete_virtual_build(
     cost_collection_seconds: float = time.monotonic() - cost_started_at
     stream.write("\n" + footer + "\n")
     stream.flush()
+    payload: str = execution_json_payload_with_degradation(
+        result=result.execution_result,
+        plan=plan_output,
+        python_node_results=result.python_node_results,
+        python_check_results=check_results,
+        command=request.execution_command,
+        run_id=None if cost_record is None else result.project.run_id,
+        cost_record=cost_record,
+        execution_succeeded=exit_code == 0,
+    )
     write_execution_json_output(
-        payload=format_build_execution_json(
-            result=result.execution_result,
-            plan=plan_output,
-            python_node_results=result.python_node_results,
-            python_check_results=check_results,
-            command=request.execution_command,
-            run_id=None if cost_record is None else result.project.run_id,
-            cost=(None if cost_record is None else RunCostStore.output_payload(record=cost_record)),
-        ),
+        payload=payload,
         json_output=request.json_output,
         json_output_path=request.json_output_path,
     )

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/output/_helpers/cursor_plan.py

@@ -37,15 +37,10 @@ def build_cursor_plan_details(*, entry: ModelPlanEntry) -> CursorPlanDetails | N
     runtime_owned: bool = any(
         relation.is_runtime_owned for relation in entry.cursor_input_relations
     ) and not (entry.start_cursor_override is not None and entry.end_cursor_override is not None)
-    causal_runtime: bool = any(
-        relation.producer_model_name is not None for relation in entry.cursor_input_relations
-    )
     resolved_bounds: CursorBounds | None = entry.microbatch_range or entry.cursor_bounds
-    effective_grain: str | None = None if causal_runtime else _effective_grain(entry=entry)
-    effective_batch_size: str | None = (
-        None
-        if causal_runtime
-        else _effective_batch_size(entry=entry, effective_grain=effective_grain)
+    effective_grain: str | None = _effective_grain(entry=entry)
+    effective_batch_size: str | None = _effective_batch_size(
+        entry=entry, effective_grain=effective_grain
     )
     planned_batch_count: int | None = None
     if (
@@ -59,9 +54,7 @@ def build_cursor_plan_details(*, entry: ModelPlanEntry) -> CursorPlanDetails | N
             batch_size=effective_batch_size,
             cursor_type=entry.cursor_type,
         )
-    if causal_runtime:
-        resolution_status: CursorResolutionStatus = CursorResolutionStatus.DEFERRED
-    elif resolved_bounds is not None:
+    if resolved_bounds is not None:
         resolution_status: CursorResolutionStatus = CursorResolutionStatus.RESOLVED
     elif runtime_owned:
         resolution_status = CursorResolutionStatus.DEFERRED
@@ -70,11 +63,7 @@ def build_cursor_plan_details(*, entry: ModelPlanEntry) -> CursorPlanDetails | N
     return CursorPlanDetails(
         requested_start=entry.start_cursor_override,
         requested_end=entry.end_cursor_override,
-        bounds_owner=(
-            CursorBoundsOwner.RUNTIME
-            if runtime_owned or causal_runtime
-            else CursorBoundsOwner.PLANNER
-        ),
+        bounds_owner=(CursorBoundsOwner.RUNTIME if runtime_owned else CursorBoundsOwner.PLANNER),
         resolution_status=resolution_status,
         resolved_bounds=resolved_bounds,
         declared_grain=entry.cursor_grain,
@@ -82,11 +71,6 @@ def build_cursor_plan_details(*, entry: ModelPlanEntry) -> CursorPlanDetails | N
         declared_batch_size=entry.batch_size,
         effective_batch_size=effective_batch_size,
         planned_batch_count=planned_batch_count,
-        causal_resolution=(
-            "runtime producer-event snapshot; unknown history uses conservative input grain"
-            if causal_runtime
-            else None
-        ),
     )
 
 
@@ -154,9 +138,7 @@ def append_microbatch_plan_detail(
 
     if details.declared_grain is not None:
         grain_text: str = details.declared_grain
-        resolved_grain: str = details.effective_grain or (
-            "runtime" if details.causal_resolution is not None else details.declared_grain
-        )
+        resolved_grain: str = details.effective_grain or details.declared_grain
         if resolved_grain != details.declared_grain:
             grain_text = f"{details.declared_grain} -> {resolved_grain} (effective)"
         lines.append(f"    grain: {grain_text}")
@@ -172,8 +154,6 @@ def append_microbatch_plan_detail(
         lines.append(f"    batch size: {batch_size_text}")
     if details.planned_batch_count is not None and details.effective_batch_size is not None:
         lines.append(f"    batches: {details.planned_batch_count} x {details.effective_batch_size}")
-    if details.causal_resolution is not None:
-        lines.append(f"    causal replay: {details.causal_resolution}")
     if details.resolution_status == CursorResolutionStatus.DEFERRED:
         lines.append("    batches: resolved at runtime after upstream models complete")
     lines.append(f"    batch concurrency: {entry.batch_concurrency}")

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/output/_helpers/execution_result_document.py

@@ -84,6 +84,38 @@ def write_execution_json_output(
         sys.stdout.flush()
 
 
+def format_degraded_execution_json(*, command: str, status: str) -> str:
+    """Format a minimal valid document when optional result projection fails."""
+
+    return (
+        json.dumps(
+            {
+                "version": _JSON_VERSION,
+                "command": command,
+                "status": status,
+                "summary": {},
+                "assets": [],
+                "checks": [],
+                "projection_degraded": True,
+            },
+            indent=2,
+        )
+        + "\n"
+    )
+
+
+def warn_execution_json_degraded(*, error: Exception, execution_succeeded: bool) -> None:
+    """Warn without allowing an optional post-execution projection to alter exit status."""
+
+    completion: str = (
+        "warehouse execution completed successfully"
+        if execution_succeeded
+        else "execution result remains authoritative"
+    )
+    sys.stderr.write(f"warning: integration output degraded: {error}; {completion}\n")
+    sys.stderr.flush()
+
+
 def format_build_execution_json(
     *,
     result: BuildExecutionResult,
@@ -671,22 +703,6 @@ def _format_microbatch_result(result: ModelExecutionResult) -> dict[str, object]
             for interval in result.microbatch_accounting_intervals
         ],
     }
-    if (
-        result.microbatch_causal_history_status is not None
-        or result.microbatch_producer_completion_event_ids
-        or result.microbatch_consumer_frontier_event_ids
-    ):
-        microbatch.update(
-            {
-                "causal_history_status": result.microbatch_causal_history_status,
-                "causal_replay_intervals": [
-                    {"start": start, "end": end}
-                    for start, end in result.microbatch_causal_replay_intervals
-                ],
-                "producer_completion_event_ids": result.microbatch_producer_completion_event_ids,
-                "consumer_frontier_event_ids": result.microbatch_consumer_frontier_event_ids,
-            }
-        )
     if result.microbatch_limit is not None:
         microbatch.update(
             {

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/output/_helpers/integration_result.py

@@ -142,6 +142,84 @@ def build_clone_integration_result(
     )
 
 
+def build_degraded_integration_result(
+    *,
+    result: object,
+    terminal: LifecycleEvent,
+    event_sequence: int,
+    command: str,
+) -> IntegrationResultEnvelope | None:
+    """Build a minimal result after optional integration enrichment fails."""
+
+    payload: Mapping[str, JSONValue] = terminal.payload
+    resource_kind: str = str(payload.get("resource_kind") or "")
+    resource_name: str = str(payload.get("resource_name") or "")
+    asset: IntegrationAssetResult | None = None
+    checks: tuple[IntegrationCheckResult, ...] = ()
+    if isinstance(
+        result,
+        (
+            ModelExecutionResult,
+            SeedExecutionResult,
+            FunctionExecutionResult,
+            LoadExecutionResult,
+            PythonNodeExecutionResult,
+            CloneItemResult,
+        ),
+    ):
+        asset = IntegrationAssetResult(
+            kind=resource_kind,
+            name=resource_name,
+            status=_terminal_status(terminal),
+        )
+    elif isinstance(
+        result,
+        (AuditExecutionResult, SqlTestExecutionResult, PythonCheckExecutionResult),
+    ):
+        checks = (
+            IntegrationCheckResult(
+                kind=resource_kind,
+                name=resource_name,
+                check_id=terminal.resource_id or "",
+                passed=terminal.event_type != INTEGRATION_RESOURCE_FAILED_EVENT,
+                status=(
+                    "error" if terminal.event_type == INTEGRATION_RESOURCE_FAILED_EVENT else "pass"
+                ),
+            ),
+        )
+    if asset is None and not checks:
+        return None
+    return IntegrationResultEnvelope(
+        schema_version=INTEGRATION_RESULT_SCHEMA_VERSION,
+        record_kind=INTEGRATION_RESULT_RECORD_KIND,
+        event_id=terminal.event_id,
+        event_sequence=event_sequence,
+        event_type=terminal.event_type,
+        occurred_at=terminal.occurred_at.isoformat(),
+        invocation_id=terminal.invocation_id,
+        run_id=terminal.run_id or "",
+        resource_id=terminal.resource_id or "",
+        resource_attempt_id=terminal.resource_attempt_id or "",
+        operation_id=terminal.operation_id,
+        statement_id=terminal.statement_id,
+        resource_kind=resource_kind,
+        resource_name=resource_name,
+        attempt_number=_attempt_number(payload.get("attempt_number")),
+        duration_ms=_number(payload.get("duration_ms")),
+        output_kind=(
+            IntegrationOutputKind.ASSET if asset is not None else IntegrationOutputKind.CHECK
+        ),
+        command=command,
+        error_code=_optional_text(payload.get("error_code")),
+        error_type=_optional_text(payload.get("error_type")),
+        skip_code=_optional_text(payload.get("skip_code")),
+        skip_mode=_optional_text(payload.get("skip_mode")),
+        projection_degraded=True,
+        asset=asset,
+        checks=checks,
+    )
+
+
 def result_resource_identity(*, result: object) -> tuple[str | None, str | None]:
     """Return the canonical resource name and identifier for an executor result."""
 
@@ -363,21 +441,6 @@ def _model_microbatch(result: ModelExecutionResult) -> Mapping[str, JSONValue]:
             else None
         ),
     }
-    if (
-        result.microbatch_causal_history_status is not None
-        or result.microbatch_producer_completion_event_ids
-        or result.microbatch_consumer_frontier_event_ids
-    ):
-        values.update(
-            {
-                "causal_history_status": result.microbatch_causal_history_status,
-                "causal_replay_interval_count": len(result.microbatch_causal_replay_intervals),
-                "producer_completion_event_count": len(
-                    result.microbatch_producer_completion_event_ids
-                ),
-                "consumer_frontier_event_count": len(result.microbatch_consumer_frontier_event_ids),
-            }
-        )
     return _bounded_metadata({key: value for key, value in values.items() if value is not None})
 
 
@@ -393,6 +456,14 @@ def _canonical_status(*, terminal: LifecycleEvent, fallback: str) -> str:
     return fallback
 
 
+def _terminal_status(terminal: LifecycleEvent) -> str:
+    if terminal.event_type == INTEGRATION_RESOURCE_FAILED_EVENT:
+        return "failed"
+    if terminal.event_type == RESOURCE_ATTEMPT_SKIPPED_EVENT:
+        return "skipped"
+    return "success"
+
+
 def _attempt_number(value: object) -> int:
     return value if isinstance(value, int) and not isinstance(value, bool) else 0
 

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/output/_helpers/plan_json.py

@@ -223,7 +223,6 @@ def _serialize_cursor_details(*, details: CursorPlanDetails) -> dict[str, object
         "declared_batch_size": details.declared_batch_size,
         "effective_batch_size": details.effective_batch_size,
         "planned_batch_count": details.planned_batch_count,
-        "causal_resolution": details.causal_resolution,
     }
 
 

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/output/classes/execution_event_writer.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import os
+import sys
 import threading
 from contextlib import AbstractContextManager, nullcontext
 from pathlib import Path
@@ -10,6 +11,7 @@ from typing import TextIO
 
 from sqlbuild.cli.output._helpers.integration_result import (
     build_clone_integration_result,
+    build_degraded_integration_result,
     build_integration_result,
     result_resource_identity,
 )
@@ -21,6 +23,7 @@ from sqlbuild.cli.output.constants import INTEGRATION_RESULT_PATH_ENV
 from sqlbuild.cli.output.models import IntegrationResultEnvelope, TerminalEventClaim
 from sqlbuild.compiler.planner.models import PlanOutput
 from sqlbuild.executor.clone.models import CloneItemResult
+from sqlbuild.runtime.observability.exceptions import ObservabilityValidationError
 
 
 class ExecutionEventWriter:
@@ -55,18 +58,33 @@ class ExecutionEventWriter:
                     if self._terminal_index is not None and resource_name is not None
                     else None
                 )
-                envelope: IntegrationResultEnvelope | None = (
-                    build_integration_result(
+                if claim is None:
+                    return
+                try:
+                    envelope: IntegrationResultEnvelope | None = build_integration_result(
                         result=result,
                         terminal=claim.terminal,
                         event_sequence=claim.event_sequence,
                         plan=plan,
                         command=command,
                     )
-                    if claim is not None
-                    else None
-                )
-                self._write_envelope(envelope)
+                    self._write_envelope(envelope)
+                except ObservabilityValidationError as error:
+                    self._warn_degraded_output(
+                        error=error,
+                        execution_succeeded=claim.terminal.event_type.endswith("completed"),
+                    )
+                    try:
+                        self._write_envelope(
+                            build_degraded_integration_result(
+                                result=result,
+                                terminal=claim.terminal,
+                                event_sequence=claim.event_sequence,
+                                command=command,
+                            )
+                        )
+                    except ObservabilityValidationError:
+                        return
 
     def write_clone_result(self, *, item: CloneItemResult, resource_type: str) -> None:
         """Write canonical terminal evidence plus typed clone-result enrichment."""
@@ -83,16 +101,32 @@ class ExecutionEventWriter:
                     if self._terminal_index is not None
                     else None
                 )
-                envelope: IntegrationResultEnvelope | None = (
-                    build_clone_integration_result(
-                        item=item,
-                        terminal=claim.terminal,
-                        event_sequence=claim.event_sequence,
+                if claim is None:
+                    return
+                try:
+                    self._write_envelope(
+                        build_clone_integration_result(
+                            item=item,
+                            terminal=claim.terminal,
+                            event_sequence=claim.event_sequence,
+                        )
                     )
-                    if claim is not None
-                    else None
-                )
-                self._write_envelope(envelope)
+                except ObservabilityValidationError as error:
+                    self._warn_degraded_output(
+                        error=error,
+                        execution_succeeded=claim.terminal.event_type.endswith("completed"),
+                    )
+                    try:
+                        self._write_envelope(
+                            build_degraded_integration_result(
+                                result=item,
+                                terminal=claim.terminal,
+                                event_sequence=claim.event_sequence,
+                                command="clone",
+                            )
+                        )
+                    except ObservabilityValidationError:
+                        return
 
     def _write_envelope(self, envelope: IntegrationResultEnvelope | None) -> None:
         if self._stream is None or envelope is None:
@@ -105,6 +139,18 @@ class ExecutionEventWriter:
             return nullcontext()
         return self._terminal_index.output_serialization_scope()
 
+    @staticmethod
+    def _warn_degraded_output(
+        *, error: ObservabilityValidationError, execution_succeeded: bool
+    ) -> None:
+        completion: str = (
+            "warehouse execution completed successfully"
+            if execution_succeeded
+            else "execution result remains authoritative"
+        )
+        sys.stderr.write(f"warning: integration output degraded: {error}; {completion}\n")
+        sys.stderr.flush()
+
     def close(self) -> None:
         """Close the event stream when configured."""
 

{sqlbuild-0.80.1 → sqlbuild-0.80.2}/src/sqlbuild/cli/output/constants.py

@@ -1,5 +1,8 @@
 """CLI execution output constants."""
 
+from sqlbuild.executor.clone.types import CloneAction
+from sqlbuild.spec.contracts.types import FutureCursorAction, MicrobatchLimitAction
+
 INTEGRATION_RESULT_PATH_ENV: str = "SQLBUILD_INTEGRATION_RESULT_PATH"
 INTEGRATION_RESULT_SCHEMA_VERSION: int = 1
 INTEGRATION_RESULT_RECORD_KIND: str = "integration_result"
@@ -55,17 +58,7 @@ INTEGRATION_CHECK_STATUSES: frozenset[str] = frozenset({"error", "fail", "pass",
 INTEGRATION_CHECK_SEVERITIES: frozenset[str] = frozenset({"error", "warn"})
 INTEGRATION_CHECK_ATTACHMENT_KINDS: frozenset[str] = frozenset({"end", "model", "source"})
 INTEGRATION_CHECK_RUN_SCOPE_PHASES: frozenset[str] = frozenset({"delta_and_final", "final"})
-INTEGRATION_CLONE_ACTIONS: frozenset[str] = frozenset(
-    {
-        "cloned",
-        "copied",
-        "failed",
-        "recreated_function",
-        "recreated_view",
-        "skipped_missing_dependency",
-        "warning_missing_source",
-    }
-)
+INTEGRATION_CLONE_ACTIONS: frozenset[str] = frozenset(action.value for action in CloneAction)
 INTEGRATION_SKIP_MODES: frozenset[str] = frozenset({"hard", "soft"})
 INTEGRATION_FUTURE_CURSOR_KEYS: frozenset[str] = frozenset(
     {
@@ -101,7 +94,9 @@ INTEGRATION_MAXIMUM_START_KEYS: frozenset[str] = frozenset(
         "relation",
     }
 )
-INTEGRATION_MAXIMUM_START_ACTIONS: frozenset[str] = frozenset({"cap", "error"})
+INTEGRATION_MAXIMUM_START_ACTIONS: frozenset[str] = frozenset(
+    action.value for action in FutureCursorAction
+)
 INTEGRATION_MAXIMUM_START_INPUT_KEYS: frozenset[str] = frozenset({"relation", "cursor_column"})
 INTEGRATION_MAXIMUM_START_REQUIRED_KEYS: frozenset[str] = frozenset(
     {
@@ -121,17 +116,13 @@ INTEGRATION_MICROBATCH_KEYS: frozenset[str] = frozenset(
         "batch_concurrency",
         "batch_count",
         "batch_size",
-        "causal_history_status",
-        "causal_replay_interval_count",
         "concurrent_enabled",
         "contiguous_frontier",
-        "consumer_frontier_event_count",
         "count",
         "global_concurrency",
         "known_gap_count",
         "limit",
         "physical_generation_id",
-        "producer_completion_event_count",
         "recovery_batch_count",
         "replay_requirement_id",
         "replay_requirement_state",
@@ -149,13 +140,10 @@ INTEGRATION_MICROBATCH_COUNT_KEYS: frozenset[str] = frozenset(
     {
         "batch_concurrency",
         "batch_count",
-        "causal_replay_interval_count",
         "count",
-        "consumer_frontier_event_count",
         "global_concurrency",
         "known_gap_count",
         "limit",
-        "producer_completion_event_count",
         "recovery_batch_count",
         "synthetic_completion_count",
         "unaccounted_interval_count",
@@ -165,7 +153,9 @@ INTEGRATION_MICROBATCH_COUNT_KEYS: frozenset[str] = frozenset(
 INTEGRATION_MICROBATCH_RUN_TYPES: frozenset[str] = frozenset(
     {"backfill", "normal", "replay_on_change"}
 )
-INTEGRATION_MICROBATCH_LIMIT_ACTIONS: frozenset[str] = frozenset({"error", "warn"})
+INTEGRATION_MICROBATCH_LIMIT_ACTIONS: frozenset[str] = frozenset(
+    action.value for action in MicrobatchLimitAction
+)
 INTEGRATION_MICROBATCH_PARTITION_POLICIES: frozenset[str] = frozenset(
     {"recover_all", "recover_empty", "synthesize"}
 )

sqlbuild-0.80.2/src/sqlbuild/cli/output/main/_execution_json_degradation.py

@@ -0,0 +1,19 @@
+"""Public post-execution JSON degradation helpers."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.output._helpers.execution_result_document import (
+    format_degraded_execution_json as _format_degraded_execution_json,
+)
+from sqlbuild.cli.output._helpers.execution_result_document import (
+    warn_execution_json_degraded as _warn_execution_json_degraded,
+)
+
+
+def degraded_execution_json(
+    *, command: str, status: str, error: Exception, execution_succeeded: bool
+) -> str:
+    """Warn and format a minimal valid document after projection failure."""
+
+    _ = _warn_execution_json_degraded(error=error, execution_succeeded=execution_succeeded)
+    return _format_degraded_execution_json(command=command, status=status)