sqlbuild 0.76.6__tar.gz → 0.76.8__tar.gz

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/Cargo.lock

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

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/PKG-INFO

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

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/crates/sqlbuild-kata-native/Cargo.toml

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

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/pyproject.toml

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

sqlbuild-0.76.8/src/sqlbuild/cli/commands/_helpers/audit/execution.py

@@ -0,0 +1,156 @@
+"""Audit command execution phases."""
+
+from __future__ import annotations
+
+from sqlbuild.cli.commands.models import (
+    AuditCommandRequest,
+    AuditExecutionPreparation,
+    AuditInvocation,
+)
+from sqlbuild.cli.output.classes.execution_event_writer import ExecutionEventWriter
+from sqlbuild.cli.progress.classes.audit_progress_reporter import AuditProgressReporter
+from sqlbuild.cli.progress.classes.connection_progress_reporter import (
+    ConnectionProgressReporter,
+)
+from sqlbuild.cli.progress.classes.native_progress_projector import (
+    NativeProgressProjector,
+    current_native_progress_projector,
+)
+from sqlbuild.compiler.pipeline.models import CompilePipelineResult
+from sqlbuild.compiler.planner.models import AuditPlanEntry
+from sqlbuild.cost.classes.cost_context import CostContext
+from sqlbuild.executor.auditing.models import AuditExecutionResult
+from sqlbuild.executor.pipeline.main.run import (
+    AuditPipelineCallbacks,
+    run_audit_pipeline_with_callbacks,
+)
+from sqlbuild.presentation.classes.cli_style import CliStyle
+
+
+def prepare_audit_execution(
+    *,
+    request: AuditCommandRequest,
+    invocation: AuditInvocation,
+    pipeline_result: CompilePipelineResult,
+) -> AuditExecutionPreparation:
+    """Prepare nested progress reporting and write the audit section header."""
+
+    audit_count: int = len(pipeline_result.plan_output.audit_entries)
+    effective_concurrency: int = (
+        request.concurrency
+        if request.concurrency is not None
+        else pipeline_result.project.settings.concurrency
+    )
+    worker_count: int = min(effective_concurrency, audit_count)
+    progress: AuditProgressReporter = AuditProgressReporter(
+        entries=pipeline_result.plan_output.audit_entries,
+        worker_limit=worker_count,
+        stream=invocation.progress_stream,
+        use_color=invocation.use_color,
+    )
+    projector: NativeProgressProjector | None = current_native_progress_projector()
+    if projector is not None:
+        for entry in pipeline_result.plan_output.audit_entries:
+            projector.expect_resource_enrichment(resource_name=entry.name)
+    execution_connection_progress: ConnectionProgressReporter = ConnectionProgressReporter(
+        adapter_name=invocation.adapter_name,
+        stream=invocation.progress_stream,
+        use_color=invocation.use_color,
+    )
+    return AuditExecutionPreparation(
+        progress=progress,
+        execution_connection_progress=execution_connection_progress,
+        effective_concurrency=effective_concurrency,
+        worker_count=worker_count,
+    )
+
+
+def write_audit_plan_header(
+    *, invocation: AuditInvocation, pipeline_result: CompilePipelineResult
+) -> None:
+    """Write the selected audit section after effective execution settings."""
+
+    entries: tuple[AuditPlanEntry, ...] = pipeline_result.plan_output.audit_entries
+    model_count: int = len(
+        {entry.attached_target_name for entry in entries if entry.attached_target_name}
+    )
+    header: str = f"Audit ({len(entries)} selected, {model_count} models)"
+    styled_header: str = CliStyle(use_color=invocation.use_color).success_strong(header)
+    invocation.progress_stream.write(f"\n{styled_header}\n\n")
+    invocation.progress_stream.flush()
+
+
+def execute_audit_plan(
+    *,
+    invocation: AuditInvocation,
+    pipeline_result: CompilePipelineResult,
+    preparation: AuditExecutionPreparation,
+) -> tuple[AuditExecutionResult, ...]:
+    """Execute the audit plan with nested progress reporting."""
+
+    event_writer: ExecutionEventWriter = ExecutionEventWriter()
+    preparation.progress.set_result_callback(
+        lambda result: event_writer.write_build_result(
+            result=result,
+            plan=pipeline_result.plan_output,
+            command="audit",
+        )
+    )
+    projector: NativeProgressProjector | None = current_native_progress_projector()
+    if projector is not None:
+        projector.configure_resources(
+            ordinals={
+                entry.name: index
+                for index, entry in enumerate(pipeline_result.plan_output.audit_entries, start=1)
+            },
+            total=len(pipeline_result.plan_output.audit_entries),
+        )
+    try:
+        with CostContext.scope(
+            run_id=pipeline_result.project.run_id,
+            resource_type="run",
+            resource_name="audit",
+            ledger_path=(
+                invocation.effective_project_dir
+                / "target"
+                / "executions"
+                / pipeline_result.project.run_id
+                / "statements.jsonl"
+            ),
+            phase="audit",
+        ):
+            return run_audit_pipeline_with_callbacks(
+                plan=pipeline_result.plan_output,
+                connection_config=invocation.connection_config,
+                adapter=invocation.adapter,
+                max_concurrency=preparation.effective_concurrency,
+                callbacks=AuditPipelineCallbacks(
+                    on_connection_start=(
+                        preparation.execution_connection_progress.on_connection_start
+                    ),
+                    on_connection_complete=(
+                        lambda connection_count, elapsed_seconds: (
+                            preparation.execution_connection_progress.on_connection_complete(
+                                connection_count=connection_count,
+                                elapsed_seconds=elapsed_seconds,
+                            )
+                        )
+                    ),
+                    on_connection_error=(
+                        lambda connection_count, elapsed_seconds: (
+                            preparation.execution_connection_progress.on_connection_error(
+                                connection_count=connection_count,
+                                elapsed_seconds=elapsed_seconds,
+                            )
+                        )
+                    ),
+                    on_audit_start=preparation.progress.on_item_start,
+                    on_audit_physical_complete=(preparation.progress.on_item_physical_complete),
+                    on_audit_complete=preparation.progress.on_item_complete,
+                    on_audit_error=preparation.progress.on_item_error,
+                ),
+                run_id=pipeline_result.project.run_id,
+            )
+    finally:
+        preparation.progress.close()
+        event_writer.close()

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/_helpers/audit/outputs.py

@@ -15,6 +15,8 @@ def write_audit_completion_output(
     request: AuditCommandRequest,
     invocation: AuditInvocation,
     results: tuple[AuditExecutionResult, ...],
+    configured_concurrency: int,
+    worker_count: int,
 ) -> None:
     """Write the audit summary footer and optional JSON output."""
 
@@ -36,7 +38,11 @@ def write_audit_completion_output(
     )
     invocation.progress_stream.flush()
     write_execution_json_output(
-        payload=format_audit_execution_json(results=results),
+        payload=format_audit_execution_json(
+            results=results,
+            configured_concurrency=configured_concurrency,
+            worker_count=worker_count,
+        ),
         json_output=request.json_output,
         json_output_path=request.json_output_path,
     )

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -248,6 +248,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 defer_to=args.defer_to,
                 no_color=args.no_color,
                 selected_target=args.target,
+                concurrency=args.concurrency,
                 select=select,
                 exclude=tuple(args.exclude),
                 cli_vars=args.vars,

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -244,6 +244,7 @@ def _add_quality_parsers(
     audit_parser.add_argument("--no-sql-validation", action="store_true", default=False)
     audit_parser.add_argument("--defer-to", default=None)
     audit_parser.add_argument("--target", default=None)
+    audit_parser.add_argument("--concurrency", type=int, default=None)
     audit_parser.add_argument("--json", action="store_true", default=False)
     _ = add_execution_json_output_arg(audit_parser)
     _ = add_select_args(audit_parser)

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/_helpers/entry/parsing.py

@@ -41,6 +41,8 @@ def resolve_env_default_concurrency(explicit_concurrency: int | None) -> int | N
     """Return CLI concurrency, falling back to SQLBUILD_CONCURRENCY when unset."""
 
     if explicit_concurrency is not None:
+        if explicit_concurrency < 1:
+            raise argparse.ArgumentTypeError("--concurrency must be >= 1")
         return explicit_concurrency
     raw_value: str | None = os.environ.get(SQLBUILD_CONCURRENCY_ENV_VAR)
     if raw_value is None or raw_value == EMPTY_ENV_VALUE:
@@ -118,7 +120,7 @@ def parse_cli_invocation(
             and not any(option in args.dbt_args for option in DBT_VERBOSE_OPTIONS)
         ):
             args.dbt_args.append("--verbose")
-        if args.command in {CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:
+        if args.command in {CliCommand.AUDIT, CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:
             try:
                 args.concurrency = resolve_env_default_concurrency(args.concurrency)
             except argparse.ArgumentTypeError as error:

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/_helpers/skills/update.py

@@ -221,17 +221,20 @@ def build_install_targets(
     home_dir: Path | None = None,
 ) -> tuple[SkillInstallTarget, ...]:
     home_path: Path = home_dir if home_dir is not None else Path.home()
+    local_install_root: Path = _find_git_root(project_dir=project_dir) or project_dir
     install_targets: list[SkillInstallTarget] = []
     for target_name in target_names:
         base_path: Path
         if target_name == opencode_skill_target:
             base_path = (
-                home_path / ".config/opencode" if global_install else project_dir / ".opencode"
+                home_path / ".config/opencode"
+                if global_install
+                else local_install_root / ".opencode"
             )
         elif target_name == claude_skill_target:
-            base_path = home_path / ".claude" if global_install else project_dir / ".claude"
+            base_path = home_path / ".claude" if global_install else local_install_root / ".claude"
         else:
-            base_path = home_path / ".agents" if global_install else project_dir / ".agents"
+            base_path = home_path / ".agents" if global_install else local_install_root / ".agents"
         install_targets.append(
             SkillInstallTarget(
                 name=target_name,
@@ -241,6 +244,14 @@ def build_install_targets(
     return tuple(install_targets)
 
 
+def _find_git_root(*, project_dir: Path) -> Path | None:
+    for candidate in (project_dir, *project_dir.parents):
+        marker: Path = candidate / ".git"
+        if marker.is_dir() or marker.is_file():
+            return candidate
+    return None
+
+
 def load_packaged_skill_content() -> str:
     skill_file: Traversable = files(skill_source_package).joinpath(*skill_source_path.split("/"))
     if not skill_file.is_file():

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/main/execution/_audit.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from sqlbuild.cli.commands._helpers.audit.execution import (
     execute_audit_plan,
     prepare_audit_execution,
+    write_audit_plan_header,
 )
 from sqlbuild.cli.commands._helpers.audit.invocation import resolve_audit_invocation
 from sqlbuild.cli.commands._helpers.audit.outputs import (
@@ -26,22 +27,24 @@ def run_audit(request: AuditCommandRequest) -> int:
     """Execute the audit command."""
 
     invocation: AuditInvocation = resolve_audit_invocation(request=request)
-    invocation.progress_stream.write("\n")
-    write_execution_header(
-        stream=invocation.progress_stream,
-        command="sqb audit",
-        target=None,
-        concurrency=1,
-        use_color=invocation.use_color,
-    )
     pipeline_result: CompilePipelineResult = compile_audit_plan(
         request=request,
         invocation=invocation,
     )
     preparation: AuditExecutionPreparation = prepare_audit_execution(
+        request=request,
         invocation=invocation,
         pipeline_result=pipeline_result,
     )
+    invocation.progress_stream.write("\n")
+    write_execution_header(
+        stream=invocation.progress_stream,
+        command="sqb audit",
+        target=None,
+        concurrency=preparation.effective_concurrency,
+        use_color=invocation.use_color,
+    )
+    write_audit_plan_header(invocation=invocation, pipeline_result=pipeline_result)
     results: tuple[AuditExecutionResult, ...] = execute_audit_plan(
         invocation=invocation,
         pipeline_result=pipeline_result,
@@ -51,5 +54,7 @@ def run_audit(request: AuditCommandRequest) -> int:
         request=request,
         invocation=invocation,
         results=results,
+        configured_concurrency=preparation.effective_concurrency,
+        worker_count=preparation.worker_count,
     )
     return resolve_audit_exit_code(results)

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/commands/models.py

@@ -121,6 +121,7 @@ class AuditCommandRequest:
     defer_to: str | None = None
     no_color: bool = False
     selected_target: str | None = None
+    concurrency: int | None = None
     select: tuple[str, ...] = ()
     exclude: tuple[str, ...] = ()
     cli_vars: dict[str, object] | None = None
@@ -147,8 +148,10 @@ class AuditInvocation:
 class AuditExecutionPreparation:
     """Prepared nested progress and execution reporters for audit runs."""
 
-    progress: NestedCommandProgressCallbacks
+    progress: AuditProgressReporter
     execution_connection_progress: ConnectionProgressReporter
+    effective_concurrency: int
+    worker_count: int
 
 
 @dataclass(frozen=True)
@@ -1418,3 +1421,6 @@ from sqlbuild.cli.commands.classes.build_progress_callbacks import (  # noqa: E4
     BuildProgressCallbacks,
 )
 from sqlbuild.cli.commands.classes.cli_namespace import CliNamespace  # noqa: E402,F401
+from sqlbuild.cli.progress.classes.audit_progress_reporter import (  # noqa: E402,F401
+    AuditProgressReporter,
+)

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/output/_helpers/execution_result_document.py

@@ -442,7 +442,12 @@ def format_test_execution_json(*, results: tuple[SqlTestExecutionResult, ...]) -
     )
 
 
-def format_audit_execution_json(*, results: tuple[AuditExecutionResult, ...]) -> str:
+def format_audit_execution_json(
+    *,
+    results: tuple[AuditExecutionResult, ...],
+    configured_concurrency: int = 1,
+    worker_count: int | None = None,
+) -> str:
     """Format audit command execution results as JSON."""
 
     results = _terminal_results(results=results)
@@ -458,6 +463,12 @@ def format_audit_execution_json(*, results: tuple[AuditExecutionResult, ...]) ->
             "fail_count": fail_count,
             "total_count": len(results),
         },
+        execution={
+            "configured_concurrency": configured_concurrency,
+            "worker_count": min(configured_concurrency, len(results))
+            if worker_count is None
+            else worker_count,
+        },
     )
 
 
@@ -520,6 +531,7 @@ def _format_execution_json(
     scenarios: tuple[dict[str, object], ...] = (),
     run_id: str | None = None,
     cost: dict[str, object] | None = None,
+    execution: dict[str, object] | None = None,
 ) -> str:
     projector: TerminalEventIndex | None = current_terminal_event_index()
     terminal: LifecycleEvent | None = None if projector is None else projector.lifecycle_terminal()
@@ -539,6 +551,8 @@ def _format_execution_json(
         payload["run_id"] = run_id
     if cost is not None:
         payload["cost"] = cost
+    if execution is not None:
+        payload["execution"] = execution
     return json.dumps(payload, indent=2) + "\n"
 
 

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cli/output/main/_audit_execution_json.py

@@ -8,7 +8,16 @@ from sqlbuild.cli.output._helpers.execution_result_document import (
 from sqlbuild.executor.auditing.models import AuditExecutionResult
 
 
-def format_audit_execution_json(*, results: tuple[AuditExecutionResult, ...]) -> str:
+def format_audit_execution_json(
+    *,
+    results: tuple[AuditExecutionResult, ...],
+    configured_concurrency: int = 1,
+    worker_count: int | None = None,
+) -> str:
     """Format audit command execution results as JSON."""
 
-    return _format_audit_execution_json(results=results)
+    return _format_audit_execution_json(
+        results=results,
+        configured_concurrency=configured_concurrency,
+        worker_count=worker_count,
+    )

sqlbuild-0.76.8/src/sqlbuild/cli/progress/classes/audit_progress_reporter.py

@@ -0,0 +1,177 @@
+"""Coordinator-safe progress reporting for standalone concurrent audits."""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+from typing import TextIO
+
+from sqlbuild.cli.progress.classes.native_progress_projector import (
+    NativeProgressProjector,
+    current_native_progress_projector,
+)
+from sqlbuild.compiler.auditing.types import AuditOutcome
+from sqlbuild.compiler.planner.models import AuditPlanEntry
+from sqlbuild.executor.auditing.main.resource_id import audit_resource_id
+from sqlbuild.executor.auditing.models import AuditExecutionResult
+from sqlbuild.presentation.classes.cli_style import CliStyle
+
+_LABEL_WIDTH: int = 10
+_NAME_WIDTH: int = 50
+
+
+class AuditProgressReporter:
+    """Render aggregate live state and flush completed audit rows in plan order."""
+
+    def __init__(
+        self,
+        *,
+        entries: tuple[AuditPlanEntry, ...],
+        worker_limit: int,
+        stream: TextIO,
+        use_color: bool,
+    ) -> None:
+        self._entries: tuple[AuditPlanEntry, ...] = entries
+        self._worker_limit: int = worker_limit
+        self._stream: TextIO = stream
+        self._style: CliStyle = CliStyle(use_color=use_color)
+        self._is_tty: bool = hasattr(stream, "isatty") and stream.isatty()
+        self._projector: NativeProgressProjector | None = current_native_progress_projector()
+        self._indexes: dict[str, int] = {
+            _entry_resource_id(entry): index for index, entry in enumerate(entries)
+        }
+        self._completed_by_index: dict[int, AuditExecutionResult | None] = {}
+        self._next_index: int = 0
+        self._running: int = 0
+        self._completed: int = 0
+        self._current_group: str | None = None
+        self._lock: threading.RLock = threading.RLock()
+        self._cursor_hidden: bool = False
+        self._on_result: Callable[[AuditExecutionResult], None] | None = None
+
+    def set_result_callback(self, callback: Callable[[AuditExecutionResult], None]) -> None:
+        """Install plan-ordered result enrichment before dispatch starts."""
+
+        self._on_result = callback
+
+    def on_item_start(self, entry: AuditPlanEntry) -> None:
+        """Record a worker start without mutating one-item spinner state."""
+
+        with self._lock:
+            self._running += 1
+            self._render_aggregate()
+
+    def on_item_complete(self, result: AuditExecutionResult) -> None:
+        """Flush every newly contiguous plan-order result row."""
+
+        with self._lock:
+            self._completed_by_index[self._indexes[_result_resource_id(result)]] = result
+            self._flush_ready()
+            self._render_aggregate()
+
+    def on_item_physical_complete(self, result: AuditExecutionResult) -> None:
+        """Update aggregate state immediately without projecting a result row."""
+
+        del result
+        with self._lock:
+            self._running = max(0, self._running - 1)
+            self._completed += 1
+            self._render_aggregate()
+
+    def on_item_error(self, entry: AuditPlanEntry) -> None:
+        """Advance aggregate and ordering state for a fatal audit exception."""
+
+        with self._lock:
+            self._running = max(0, self._running - 1)
+            self._completed += 1
+            self._completed_by_index[self._indexes[_entry_resource_id(entry)]] = None
+            self._flush_ready()
+            self._render_aggregate()
+
+    def close(self) -> None:
+        """Restore the terminal after the final aggregate update."""
+
+        with self._lock:
+            if self._is_tty:
+                self._clear_aggregate()
+                if self._cursor_hidden:
+                    self._stream.write("\033[?25h")
+                    self._cursor_hidden = False
+                self._stream.flush()
+
+    def _flush_ready(self) -> None:
+        while self._next_index in self._completed_by_index:
+            result: AuditExecutionResult | None = self._completed_by_index.pop(self._next_index)
+            self._next_index += 1
+            if result is not None:
+                self._write_result(result)
+
+    def _write_result(self, result: AuditExecutionResult) -> None:
+        if self._is_tty:
+            self._clear_aggregate()
+        group_name: str = result.attached_target_name or "(unattached)"
+        if group_name != self._current_group:
+            prefix: str = "\n" if self._current_group is not None else ""
+            self._stream.write(f"{prefix}{self._style.section(group_name)}\n")
+            self._current_group = group_name
+        status_text: str = {
+            AuditOutcome.PASS: "PASS",
+            AuditOutcome.WARN: "WARN",
+            AuditOutcome.ERROR: "FAIL",
+        }[result.outcome]
+        name: str = result.audit_name
+        if result.attached_column_name is not None:
+            name = f"{name} ({result.attached_column_name})"
+        detail: str = ""
+        if result.outcome != AuditOutcome.PASS and result.row_count > 0:
+            row_label: str = "row" if result.row_count == 1 else "rows"
+            detail = f"  {result.row_count} {row_label}"
+        if self._projector is not None:
+            duration_ms: float | None = self._projector.consume_resource_terminal(
+                resource_name=result.audit_name,
+                resource_id=_result_resource_id(result),
+            )
+            if duration_ms is not None:
+                detail = f"{detail}  {duration_ms / 1000.0:.2f}s"
+        status: str = self._style.status(status=status_text)
+        self._stream.write(f"    {'audit':<{_LABEL_WIDTH}}{name:<{_NAME_WIDTH}} {status}{detail}\n")
+        self._stream.flush()
+        if self._on_result is not None:
+            self._on_result(result)
+
+    def _render_aggregate(self) -> None:
+        if not self._is_tty:
+            return
+        if not self._cursor_hidden:
+            self._stream.write("\033[?25l")
+            self._cursor_hidden = True
+        self._clear_aggregate()
+        self._stream.write(
+            "\r\033[K    audit     "
+            f"running {self._running} | completed {self._completed}/{len(self._entries)} "
+            f"| workers {self._worker_limit}"
+        )
+        self._stream.flush()
+
+    def _clear_aggregate(self) -> None:
+        self._stream.write("\r\033[K")
+
+
+def _entry_resource_id(entry: AuditPlanEntry) -> str:
+    return audit_resource_id(
+        audit_name=entry.name,
+        attachment_kind=entry.attachment_kind,
+        attached_target_kind=entry.attached_target_kind,
+        attached_target_name=entry.attached_target_name,
+        attached_column_name=entry.attached_column_name,
+    )
+
+
+def _result_resource_id(result: AuditExecutionResult) -> str:
+    return audit_resource_id(
+        audit_name=result.audit_name,
+        attachment_kind=result.attachment_kind,
+        attached_target_kind=result.attached_target_kind,
+        attached_target_name=result.attached_target_name,
+        attached_column_name=result.attached_column_name,
+    )

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/compiler/discovery/_helpers/yml/project.py

@@ -440,6 +440,8 @@ def _load_settings(*, payload: object, file_path: Path) -> SettingsConfig:
         else CONFIG_CONCURRENCY_KEY
     )
     concurrency: int = _optional_int(mapping=mapping, key=concurrency_key, default=1)
+    if concurrency < 1:
+        raise ProjectConfigError("settings.concurrency must be >= 1")
     table_promotion_mode: str | None = _optional_str(payload=mapping, key="table_promotion_mode")
     default_audit_severity: str | None = _optional_str(
         payload=mapping, key="default_audit_severity"

{sqlbuild-0.76.6 → sqlbuild-0.76.8}/src/sqlbuild/cost/classes/cost_context.py

@@ -32,7 +32,11 @@ class CostContext:
             run_id=run_id,
             resource_type=resource_type,
             resource_name=resource_name,
-            ledger_path=ledger_path,
+            ledger_path=(
+                ledger_path
+                if ledger_path is not None
+                else (None if current is None else current.ledger_path)
+            ),
             phase=phase,
             attempt=attempt,
             on_statement_complete=(