From 869f2569b120bbbb8774fe4aff4bcb2c35bc6850 Mon Sep 17 00:00:00 2001
From: Kevin Longe <273747162+kvlonge@users.noreply.github.com>
Date: Thu, 8 Oct 2026 19:06:10 +0100
Subject: [PATCH 1/2] feat(native): report model config errors natively

---
 .../config_presence/main/first_macro_path.rs  |  51 +++
 .../src/config_presence/main/mod.rs           |   1 +
 .../src/config_presence/models.rs             |  10 +
 crates/sqlbuild-model-config/src/errors.rs    |  69 +++
 .../src/header_metadata/_helpers/audits.rs    | 118 +++--
 .../src/header_metadata/_helpers/columns.rs   | 118 +++--
 .../src/header_metadata/_helpers/identity.rs  |  84 ++++
 .../src/header_metadata/_helpers/mod.rs       |   1 +
 .../src/header_metadata/_helpers/text.rs      |  85 ++--
 .../src/header_metadata/constants.rs          |  10 +
 .../main/parse_header_metadata.rs             |  25 +-
 .../src/header_metadata/models.rs             |  18 +-
 .../src/header_metadata/tests/helpers.rs      |  35 +-
 .../tests/test_parse_header_metadata.rs       |  76 ++--
 .../src/header_metadata/tests/test_types.rs   |   5 +-
 crates/sqlbuild-model-config/src/lib.rs       |   1 +
 .../src/model_validation/_helpers/config.rs   | 140 ++++--
 .../_helpers/cursor_bounds.rs                 | 248 ++++++++--
 .../model_validation/_helpers/incremental.rs  | 428 ++++++++++++------
 .../_helpers/materialization.rs               | 256 +++++++----
 .../model_validation/_helpers/microbatch.rs   | 403 ++++++++++++-----
 .../model_validation/_helpers/references.rs   |  79 +++-
 .../src/model_validation/_helpers/snapshot.rs | 280 +++++++++---
 .../src/model_validation/_helpers/text.rs     |  10 +
 .../src/model_validation/constants.rs         |  18 +
 .../src/model_validation/main/mod.rs          |   2 +-
 .../main/retention_override.rs                |  26 +-
 .../main/table_type_override.rs               |  23 +-
 ...del_config.rs => validate_model_config.rs} |  22 +-
 .../src/model_validation/models.rs            |  21 +-
 .../src/model_validation/tests.rs             |   4 +-
 .../src/model_validation/tests/helpers.rs     |  51 ++-
 .../tests/test_storage_overrides.rs           |  20 +-
 .../src/model_validation/tests/test_types.rs  |  13 +-
 ...onfig.rs => test_validate_model_config.rs} | 146 +++---
 .../src/model_validation/types.rs             |   6 +-
 .../src/path_defaults/_helpers/matching.rs    |  30 +-
 .../src/path_defaults/constants.rs            |   3 +
 .../path_defaults/main/select_path_default.rs |  11 +-
 .../src/path_defaults/models.rs               |   6 +-
 .../tests/test_select_path_default.rs         |  12 +-
 .../src/templates/_helpers/evaluation.rs      |  33 +-
 .../src/templates/_helpers/expressions.rs     |  33 +-
 .../src/templates/_helpers/tokens.rs          |  65 ++-
 .../src/templates/errors.rs                   |  87 ++--
 .../src/templates/main/mod.rs                 |   1 +
 .../templates/main/template_error_message.rs  |  45 ++
 .../src/templates/models.rs                   |   2 +-
 .../tests/test_expand_template_string.rs      |  57 +--
 .../_helpers/model_config/config_errors.rs    |  40 ++
 .../_helpers/model_config/config_templates.rs |  45 +-
 .../bindings/_helpers/model_config/errors.rs  |  13 +
 .../_helpers/model_config/header_metadata.rs  |  86 ++--
 .../src/bindings/_helpers/model_config/mod.rs |   2 +
 .../model_config/model_config_builder.rs      | 187 +++++---
 .../_helpers/model_config/model_validator.rs  |  36 +-
 .../_helpers/model_config/registration.rs     |   4 +-
 .../_helpers/corpus/config_failure_cases.py   | 137 +++++-
 src/sqlbuild/_native.pyi                      |  29 +-
 .../compile/_helpers/attachment/functions.py  |   2 -
 .../_helpers/attachment/model_config.py       |  61 ++-
 .../compile/_helpers/attachment/sources.py    |   1 -
 .../_helpers/render/context_templates.py      |  28 +-
 .../compiler/model_config/constants.py        |   6 +-
 .../main/_expand_native_config_templates.py   |  25 +-
 .../model_config/main/_native_config_error.py |  35 ++
 .../main/_parse_native_header_metadata.py     |  46 +-
 src/sqlbuild/compiler/model_config/models.py  |   8 +-
 src/sqlbuild/compiler/model_config/types.py   |  11 +
 .../cli/commands/main/compile/_test_types.py  |  11 +
 .../cli/commands/main/compile/helpers.py      |  53 +++
 .../main/compile/test_native_config_errors.py | 180 ++++++++
 .../native_model_config/_test_types.py        |  10 +-
 .../compile/native_model_config/helpers.py    | 129 ++++--
 .../test_native_model_config_session.py       | 165 ++++---
 .../compiler/model_config/_test_types.py      |   9 -
 .../sqlbuild/compiler/model_config/helpers.py | 108 ++---
 .../model_config/test_native_model_config.py  |  34 --
 78 files changed, 3349 insertions(+), 1440 deletions(-)
 create mode 100644 crates/sqlbuild-model-config/src/config_presence/main/first_macro_path.rs
 create mode 100644 crates/sqlbuild-model-config/src/errors.rs
 create mode 100644 crates/sqlbuild-model-config/src/header_metadata/_helpers/identity.rs
 rename crates/sqlbuild-model-config/src/model_validation/main/{accept_model_config.rs => validate_model_config.rs} (57%)
 rename crates/sqlbuild-model-config/src/model_validation/tests/{test_accept_model_config.rs => test_validate_model_config.rs} (71%)
 create mode 100644 crates/sqlbuild-model-config/src/templates/main/template_error_message.rs
 create mode 100644 crates/sqlbuild-python/src/bindings/_helpers/model_config/config_errors.rs
 create mode 100644 crates/sqlbuild-python/src/bindings/_helpers/model_config/errors.rs
 create mode 100644 src/sqlbuild/compiler/model_config/main/_native_config_error.py
 create mode 100644 src/sqlbuild/compiler/model_config/types.py
 create mode 100644 tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py

diff --git a/crates/sqlbuild-model-config/src/config_presence/main/first_macro_path.rs b/crates/sqlbuild-model-config/src/config_presence/main/first_macro_path.rs
new file mode 100644
index 0000000000..2490eb32ae
--- /dev/null
+++ b/crates/sqlbuild-model-config/src/config_presence/main/first_macro_path.rs
@@ -0,0 +1,51 @@
+//! The first config field, in Python's walk order, whose string holds a macro call.
+
+use crate::config_presence::_helpers::macro_calls::macro_call;
+use crate::config_presence::models::{MacroPath, Presence};
+use crate::types::{AuthoredNode, NodeKind};
+
+/// Walk config values as `validate_no_macros_in_config_value` does, skipping the `skipped` keys.
+pub fn first_macro_path<N: AuthoredNode>(values: &N, skipped: &[&str]) -> MacroPath {
+    let mut entries = values.entries();
+    entries.retain(|(key, _)| !skipped.iter().any(|name| key.is_text(name)));
+    walk_entries(&entries, &[])
+}
+
+fn walk<N: AuthoredNode>(node: &N, path: &[String]) -> MacroPath {
+    match node.kind() {
+        NodeKind::Str => match node.with_text(macro_call) {
+            Some(Presence::Present) => MacroPath::Found(path.to_vec()),
+            Some(Presence::Absent) => MacroPath::Absent,
+            Some(Presence::Deferred) | None => MacroPath::Deferred,
+        },
+        NodeKind::Map => walk_entries(&node.entries(), path),
+        NodeKind::List | NodeKind::Tuple => {
+            for item in node.items() {
+                let found = walk(&item, path);
+                if found != MacroPath::Absent {
+                    return found;
+                }
+            }
+            MacroPath::Absent
+        }
+        _ => MacroPath::Absent,
+    }
+}
+
+fn walk_entries<N: AuthoredNode>(entries: &[(N, N)], path: &[String]) -> MacroPath {
+    for (key, value) in entries {
+        if key.kind() != NodeKind::Str {
+            continue;
+        }
+        let Some(name) = key.text() else {
+            return MacroPath::Deferred;
+        };
+        let mut child: Vec<String> = path.to_vec();
+        child.push(name);
+        let found = walk(value, &child);
+        if found != MacroPath::Absent {
+            return found;
+        }
+    }
+    MacroPath::Absent
+}
diff --git a/crates/sqlbuild-model-config/src/config_presence/main/mod.rs b/crates/sqlbuild-model-config/src/config_presence/main/mod.rs
index 36a864d560..03e068523b 100644
--- a/crates/sqlbuild-model-config/src/config_presence/main/mod.rs
+++ b/crates/sqlbuild-model-config/src/config_presence/main/mod.rs
@@ -1,2 +1,3 @@
 pub mod contains_macro_call;
 pub mod contains_template;
+pub mod first_macro_path;
diff --git a/crates/sqlbuild-model-config/src/config_presence/models.rs b/crates/sqlbuild-model-config/src/config_presence/models.rs
index cecf2b46d0..38b270b275 100644
--- a/crates/sqlbuild-model-config/src/config_presence/models.rs
+++ b/crates/sqlbuild-model-config/src/config_presence/models.rs
@@ -8,3 +8,13 @@ pub enum Presence {
     /// A string needs Python's Unicode `\s` class to decide.
     Deferred,
 }
+
+/// Where Python's config walk first finds a macro call.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum MacroPath {
+    /// The mapping keys leading to the first string holding a macro call.
+    Found(Vec<String>),
+    Absent,
+    /// A string before any match needs Python's Unicode rules to decide.
+    Deferred,
+}
diff --git a/crates/sqlbuild-model-config/src/errors.rs b/crates/sqlbuild-model-config/src/errors.rs
new file mode 100644
index 0000000000..ebd6e72e65
--- /dev/null
+++ b/crates/sqlbuild-model-config/src/errors.rs
@@ -0,0 +1,69 @@
+//! Errors the native config stages report exactly as the Python stages raise them.
+
+/// The Python exception class one error raises.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ErrorClass {
+    /// `CompileInputError`.
+    CompileInput,
+    /// `ConfigValueTypeError` for a config key that must hold a string.
+    ConfigValueType,
+    /// `ResourceIdentityError` for an identity that is not canonical snake_case.
+    ResourceIdentity,
+    /// `DiscoveryConflictError` for equally specific path-default keys.
+    DiscoveryConflict,
+}
+
+/// One error with the class, message, code and help the Python stage raises.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConfigError {
+    pub class: ErrorClass,
+    /// The message; empty for `ConfigValueTypeError`, which Python words from the value's type.
+    pub message: String,
+    /// The diagnostic code when it is not the class default.
+    pub code: Option<&'static str>,
+    pub help: Option<String>,
+    /// The config key a `ConfigValueTypeError` names.
+    pub key: Option<String>,
+}
+
+impl ConfigError {
+    /// A `CompileInputError` with this message.
+    pub fn compile(message: String) -> Self {
+        Self {
+            class: ErrorClass::CompileInput,
+            message,
+            code: None,
+            help: None,
+            key: None,
+        }
+    }
+
+    /// The `ConfigValueTypeError` `get_config_str` raises for a non-string `key`.
+    pub fn config_value_type(key: &str) -> Self {
+        Self {
+            class: ErrorClass::ConfigValueType,
+            message: String::new(),
+            code: None,
+            help: None,
+            key: Some(key.to_owned()),
+        }
+    }
+
+    /// This error of another class.
+    pub fn with_class(mut self, class: ErrorClass) -> Self {
+        self.class = class;
+        self
+    }
+
+    /// This error with help text.
+    pub fn with_help(mut self, help: impl Into<String>) -> Self {
+        self.help = Some(help.into());
+        self
+    }
+
+    /// This error with a diagnostic code.
+    pub fn with_code(mut self, code: &'static str) -> Self {
+        self.code = Some(code);
+        self
+    }
+}
diff --git a/crates/sqlbuild-model-config/src/header_metadata/_helpers/audits.rs b/crates/sqlbuild-model-config/src/header_metadata/_helpers/audits.rs
index 3431fa0d4f..5e7915de96 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/_helpers/audits.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/_helpers/audits.rs
@@ -1,68 +1,100 @@
 //! Audit lists and instances, as `parse_audit_instances` reads them with `null_as_empty`.
 
+use crate::header_metadata::_helpers::identity::check_identity;
 use crate::header_metadata::_helpers::text::{
-    entry, is_snake_case, non_blank_text, optional_bool, optional_count, optional_text,
+    Site, entry, non_blank_text, optional_bool, optional_count, optional_text,
 };
 use crate::header_metadata::constants::{AUDIT_OPTION_KEYS, AUDIT_SEVERITIES};
-use crate::header_metadata::models::{HeaderMetadataDeferral, ParsedAudit};
+use crate::header_metadata::models::{HeaderMetadataStop, ParsedAudit};
 use crate::types::{AuthoredNode, NodeKind};
 
 /// Parse an authored audit list; Python's `None` is an empty list.
 pub(crate) fn audit_list<N: AuthoredNode>(
     node: &N,
-) -> Result<Vec<ParsedAudit<N>>, HeaderMetadataDeferral> {
+    site: Site<'_>,
+) -> Result<Vec<ParsedAudit<N>>, HeaderMetadataStop> {
     match node.kind() {
         NodeKind::Null => Ok(Vec::new()),
-        NodeKind::List => node.items().iter().map(audit_instance).collect(),
-        _ => Err(HeaderMetadataDeferral::Invalid),
+        NodeKind::List => node
+            .items()
+            .iter()
+            .map(|item| audit_instance(item, site))
+            .collect(),
+        _ => Err(site.error("audits must be a list")),
     }
 }
 
-fn audit_instance<N: AuthoredNode>(node: &N) -> Result<ParsedAudit<N>, HeaderMetadataDeferral> {
-    match node.kind() {
-        NodeKind::Str => {
-            identity(node)?;
-            Ok(bare_audit(node.clone()))
-        }
-        NodeKind::Map => {
-            let entries = node.entries();
-            let [(definition_name, arguments)] = entries.as_slice() else {
-                return Err(HeaderMetadataDeferral::Invalid);
-            };
-            identity(definition_name)?;
-            match arguments.kind() {
-                NodeKind::Null => Ok(bare_audit(definition_name.clone())),
-                NodeKind::Map => configured_audit(definition_name, &arguments.entries()),
-                _ => Err(HeaderMetadataDeferral::Invalid),
-            }
-        }
-        _ => Err(HeaderMetadataDeferral::Invalid),
+fn audit_instance<N: AuthoredNode>(
+    node: &N,
+    site: Site<'_>,
+) -> Result<ParsedAudit<N>, HeaderMetadataStop> {
+    let definition_kind = format!("{} audit definition", site.label);
+    if node.kind() == NodeKind::Str {
+        let Some(text) = non_blank_text(node)? else {
+            return Err(site.error("audits must not contain empty names"));
+        };
+        check_identity(&text, &definition_kind, site.path)?;
+        return Ok(bare_audit(node.clone()));
+    }
+    let entries = node.entries();
+    let [(definition_name, arguments)] = entries.as_slice() else {
+        return Err(site.error("audits must be strings or single-key mappings"));
+    };
+    if node.kind() != NodeKind::Map {
+        return Err(site.error("audits must be strings or single-key mappings"));
+    }
+    let Some(definition) = non_blank_text(definition_name)? else {
+        return Err(site.error("audit names must be non-empty strings"));
+    };
+    check_identity(&definition, &definition_kind, site.path)?;
+    match arguments.kind() {
+        NodeKind::Null => Ok(bare_audit(definition_name.clone())),
+        NodeKind::Map => configured_audit(definition_name, &definition, &arguments.entries(), site),
+        _ => Err(site.error(&format!("audit '{definition}' arguments must be a mapping"))),
     }
 }
 
 fn configured_audit<N: AuthoredNode>(
     definition_name: &N,
+    definition: &str,
     options: &[(N, N)],
-) -> Result<ParsedAudit<N>, HeaderMetadataDeferral> {
-    let name = optional_text(entry(options, "name"))?;
+    site: Site<'_>,
+) -> Result<ParsedAudit<N>, HeaderMetadataStop> {
+    let option_label = format!("{} audit '{definition}'", site.label);
+    let option_site = Site {
+        path: site.path,
+        label: &option_label,
+    };
+    let name = optional_text(entry(options, "name"), option_site, "name")?;
     if let Some(name) = &name {
-        identity(name)?;
+        let text = name.text().ok_or(HeaderMetadataStop::Unsupported)?;
+        check_identity(&text, &format!("{} audit instance", site.label), site.path)?;
     }
-    let description = optional_text(entry(options, "description"))?;
-    let severity = optional_text(entry(options, "severity"))?;
-    if let Some(severity) = &severity {
-        let text = severity.text().ok_or(HeaderMetadataDeferral::Unsupported)?;
-        if !AUDIT_SEVERITIES.contains(&text.as_str()) {
-            return Err(HeaderMetadataDeferral::Invalid);
-        }
+    let description = optional_text(entry(options, "description"), option_site, "description")?;
+    let severity = optional_text(entry(options, "severity"), option_site, "severity")?;
+    if let Some(severity) = &severity
+        && !AUDIT_SEVERITIES.iter().any(|value| severity.is_text(value))
+    {
+        return Err(option_site.error(&format!(
+            "'severity' must be one of: {}",
+            AUDIT_SEVERITIES.join(", ")
+        )));
     }
-    let run_scope = optional_text(entry(options, "run_scope"))?;
-    let always_run = optional_bool(entry(options, "always_run"))?;
+    let run_scope = optional_text(entry(options, "run_scope"), option_site, "run_scope")?;
+    let always_run = optional_bool(entry(options, "always_run"), option_site, "always_run")?;
     if entry(options, "thresholds").is_some_and(|value| value.kind() != NodeKind::Null) {
-        return Err(HeaderMetadataDeferral::Unsupported);
+        return Err(HeaderMetadataStop::Unsupported);
     }
-    let minimum_samples = optional_count(entry(options, "minimum_samples"))?;
-    let evidence_limit = optional_count(entry(options, "evidence_limit"))?;
+    let minimum_samples = optional_count(
+        entry(options, "minimum_samples"),
+        option_site,
+        "minimum_samples",
+    )?;
+    let evidence_limit = optional_count(
+        entry(options, "evidence_limit"),
+        option_site,
+        "evidence_limit",
+    )?;
     let arguments: Vec<(N, N)> = options
         .iter()
         .filter(|(key, _)| !is_option_key(key))
@@ -95,14 +127,6 @@ fn bare_audit<N: AuthoredNode>(definition_name: N) -> ParsedAudit<N> {
     }
 }
 
-fn identity<N: AuthoredNode>(node: &N) -> Result<(), HeaderMetadataDeferral> {
-    if is_snake_case(&non_blank_text(node)?) {
-        Ok(())
-    } else {
-        Err(HeaderMetadataDeferral::Invalid)
-    }
-}
-
 fn is_option_key<N: AuthoredNode>(key: &N) -> bool {
     AUDIT_OPTION_KEYS.iter().any(|name| key.is_text(name))
 }
diff --git a/crates/sqlbuild-model-config/src/header_metadata/_helpers/columns.rs b/crates/sqlbuild-model-config/src/header_metadata/_helpers/columns.rs
index 82f8fae2ab..df77dcdcb0 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/_helpers/columns.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/_helpers/columns.rs
@@ -2,63 +2,75 @@
 
 use std::collections::HashSet;
 
+use crate::errors::ConfigError;
 use crate::header_metadata::_helpers::audits::audit_list;
-use crate::header_metadata::_helpers::text::{entry, non_blank_text, optional_bool, optional_text};
-use crate::header_metadata::constants::{MODEL_COLUMN_KEYS, NOT_NULL_AUDIT_NAME};
-use crate::header_metadata::models::{HeaderMetadataDeferral, ParsedColumn};
+use crate::header_metadata::_helpers::text::{
+    Site, entry, non_blank_text, optional_bool, optional_text,
+};
+use crate::header_metadata::constants::{
+    MODEL_COLUMN_KEYS, MODEL_LABEL, NOT_NULL_AUDIT_NAME, NULLABLE_NOT_NULL_CODE,
+};
+use crate::header_metadata::models::{HeaderMetadataStop, ParsedColumn};
 use crate::types::{AuthoredNode, NodeKind};
 
 /// Parse an authored columns mapping; Python's `None` declares no columns.
 pub(crate) fn column_mapping<N: AuthoredNode>(
     node: &N,
-) -> Result<Vec<ParsedColumn<N>>, HeaderMetadataDeferral> {
+    path: &str,
+) -> Result<Vec<ParsedColumn<N>>, HeaderMetadataStop> {
+    let site = Site {
+        path,
+        label: MODEL_LABEL,
+    };
     match node.kind() {
-        NodeKind::Null => Ok(Vec::new()),
-        NodeKind::Map => {
-            let columns: Vec<ParsedColumn<N>> = node
-                .entries()
-                .iter()
-                .map(|(name, metadata)| column(name, metadata))
-                .collect::<Result<_, _>>()?;
-            if has_duplicate_names(&columns) {
-                Err(HeaderMetadataDeferral::Invalid)
-            } else {
-                Ok(columns)
-            }
-        }
-        _ => Err(HeaderMetadataDeferral::Invalid),
+        NodeKind::Null => return Ok(Vec::new()),
+        NodeKind::Map => {}
+        _ => return Err(site.error("'columns' must be a mapping")),
     }
-}
-
-/// Return whether two ASCII column names are equal under Python's `str.lower()`.
-fn has_duplicate_names<N: AuthoredNode>(columns: &[ParsedColumn<N>]) -> bool {
     let mut seen: HashSet<String> = HashSet::new();
-    !columns.iter().all(|column| {
-        column
-            .name
-            .text()
-            .is_some_and(|name| seen.insert(name.to_ascii_lowercase()))
-    })
+    let mut columns: Vec<ParsedColumn<N>> = Vec::new();
+    for (name, metadata) in node.entries() {
+        let Some(text) = non_blank_text(&name)? else {
+            return Err(site.error("column names must be non-empty strings"));
+        };
+        if !text.is_ascii() {
+            return Err(HeaderMetadataStop::Unsupported);
+        }
+        if !seen.insert(text.to_ascii_lowercase()) {
+            return Err(site.error(&format!(
+                "has duplicate column '{text}' (column names are case-insensitive)"
+            )));
+        }
+        columns.push(column(&name, &text, &metadata, path)?);
+    }
+    Ok(columns)
 }
 
 fn column<N: AuthoredNode>(
     name: &N,
+    text: &str,
     metadata: &N,
-) -> Result<ParsedColumn<N>, HeaderMetadataDeferral> {
-    let text = non_blank_text(name)?;
-    if !text.is_ascii() {
-        return Err(HeaderMetadataDeferral::Unsupported);
-    }
+    path: &str,
+) -> Result<ParsedColumn<N>, HeaderMetadataStop> {
+    let label = format!("{MODEL_LABEL} column '{text}'");
+    let site = Site {
+        path,
+        label: &label,
+    };
     if metadata.kind() != NodeKind::Map {
-        return Err(HeaderMetadataDeferral::Invalid);
+        return Err(site.error("metadata must be a mapping"));
     }
     let entries = metadata.entries();
-    if !entries.iter().all(|(key, _)| is_column_key(key)) {
-        return Err(HeaderMetadataDeferral::Invalid);
+    let unknown = unknown_keys(&entries)?;
+    if !unknown.is_empty() {
+        return Err(site.error(&format!(
+            "has unknown metadata keys: {}",
+            unknown.join(", ")
+        )));
     }
-    let nullable = optional_bool(entry(&entries, "nullable"))?;
+    let nullable = optional_bool(entry(&entries, "nullable"), site, "nullable")?;
     let audits = match entry(&entries, "audits") {
-        Some(value) => audit_list(value)?,
+        Some(value) => audit_list(value, site)?,
         None => Vec::new(),
     };
     let declares_nullable = nullable
@@ -69,18 +81,36 @@ fn column<N: AuthoredNode>(
             .iter()
             .any(|audit| audit.definition_name.is_text(NOT_NULL_AUDIT_NAME))
     {
-        return Err(HeaderMetadataDeferral::Invalid);
+        return Err(HeaderMetadataStop::Error(
+            ConfigError::compile(format!(
+                "{path} column '{text}' cannot set nullable = true and audit not_null"
+            ))
+            .with_code(NULLABLE_NOT_NULL_CODE)
+            .with_help("remove the not_null audit or set nullable = false"),
+        ));
     }
     Ok(ParsedColumn {
         name: name.clone(),
-        column_type: optional_text(entry(&entries, "type"))?,
+        column_type: optional_text(entry(&entries, "type"), site, "type")?,
         nullable,
-        description: optional_text(entry(&entries, "description"))?,
+        description: optional_text(entry(&entries, "description"), site, "description")?,
         audits,
-        migrate_from: optional_text(entry(&entries, "migrate_from"))?,
+        migrate_from: optional_text(entry(&entries, "migrate_from"), site, "migrate_from")?,
     })
 }
 
-fn is_column_key<N: AuthoredNode>(key: &N) -> bool {
-    MODEL_COLUMN_KEYS.iter().any(|name| key.is_text(name))
+/// Return the sorted metadata keys outside `MODEL_COLUMN_KEYS`, deferring keys Python cannot sort.
+fn unknown_keys<N: AuthoredNode>(entries: &[(N, N)]) -> Result<Vec<String>, HeaderMetadataStop> {
+    let mut unknown: Vec<String> = Vec::new();
+    for (key, _) in entries {
+        if MODEL_COLUMN_KEYS.iter().any(|name| key.is_text(name)) {
+            continue;
+        }
+        if key.kind() != NodeKind::Str {
+            return Err(HeaderMetadataStop::Unsupported);
+        }
+        unknown.push(key.text().ok_or(HeaderMetadataStop::Unsupported)?);
+    }
+    unknown.sort_unstable();
+    Ok(unknown)
 }
diff --git a/crates/sqlbuild-model-config/src/header_metadata/_helpers/identity.rs b/crates/sqlbuild-model-config/src/header_metadata/_helpers/identity.rs
new file mode 100644
index 0000000000..c046a733ab
--- /dev/null
+++ b/crates/sqlbuild-model-config/src/header_metadata/_helpers/identity.rs
@@ -0,0 +1,84 @@
+//! `validate_resource_identity` for ASCII names, with its suggested snake_case spelling.
+
+use crate::errors::{ConfigError, ErrorClass};
+use crate::header_metadata::_helpers::text::ascii_strip;
+use crate::header_metadata::constants::{FALLBACK_IDENTITY, IDENTITY_HELP};
+use crate::header_metadata::models::HeaderMetadataStop;
+
+/// Raise `ResourceIdentityError` unless `name` is canonical snake_case; defer non-ASCII names.
+pub(crate) fn check_identity(name: &str, kind: &str, path: &str) -> Result<(), HeaderMetadataStop> {
+    if is_snake_case(name) {
+        return Ok(());
+    }
+    if !name.is_ascii() {
+        return Err(HeaderMetadataStop::Unsupported);
+    }
+    let suggestion = suggested_identity(name);
+    Err(HeaderMetadataStop::Error(
+        ConfigError::compile(format!(
+            "Invalid {kind} identity '{name}' in {path}; use snake_case '{suggestion}'"
+        ))
+        .with_class(ErrorClass::ResourceIdentity)
+        .with_help(IDENTITY_HELP),
+    ))
+}
+
+/// Return whether `name` fully matches `^[a-z](?:[a-z0-9_]*[a-z0-9])?$`.
+fn is_snake_case(name: &str) -> bool {
+    let bytes = name.as_bytes();
+    match (bytes.first(), bytes.last()) {
+        (Some(first), Some(last)) => {
+            first.is_ascii_lowercase()
+                && (last.is_ascii_lowercase() || last.is_ascii_digit())
+                && bytes
+                    .iter()
+                    .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || *byte == b'_')
+        }
+        _ => false,
+    }
+}
+
+/// Return `suggest_resource_identity` for an ASCII public identity.
+fn suggested_identity(name: &str) -> String {
+    let characters: Vec<char> = ascii_strip(name).chars().collect();
+    let acronyms = split_where(&characters, |index| {
+        characters[index - 1].is_ascii_uppercase()
+            && characters[index].is_ascii_uppercase()
+            && characters
+                .get(index + 1)
+                .is_some_and(char::is_ascii_lowercase)
+    });
+    let words = split_where(&acronyms, |index| {
+        (acronyms[index - 1].is_ascii_lowercase() || acronyms[index - 1].is_ascii_digit())
+            && acronyms[index].is_ascii_uppercase()
+    });
+    let mut replaced = String::with_capacity(words.len());
+    let mut in_invalid_run = false;
+    for character in words {
+        if character.is_ascii_alphanumeric() || character == '_' {
+            replaced.push(character.to_ascii_lowercase());
+            in_invalid_run = false;
+        } else if !in_invalid_run {
+            replaced.push('_');
+            in_invalid_run = true;
+        }
+    }
+    let corrected = replaced.trim_matches('_');
+    if corrected.is_empty() {
+        FALLBACK_IDENTITY.to_owned()
+    } else {
+        corrected.to_owned()
+    }
+}
+
+/// Insert `_` before every index after the first where `boundary` holds.
+fn split_where(characters: &[char], boundary: impl Fn(usize) -> bool) -> Vec<char> {
+    let mut result: Vec<char> = Vec::with_capacity(characters.len() * 2);
+    for (index, character) in characters.iter().enumerate() {
+        if index > 0 && boundary(index) {
+            result.push('_');
+        }
+        result.push(*character);
+    }
+    result
+}
diff --git a/crates/sqlbuild-model-config/src/header_metadata/_helpers/mod.rs b/crates/sqlbuild-model-config/src/header_metadata/_helpers/mod.rs
index 6e200497a7..3e2c0f3b41 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/_helpers/mod.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/_helpers/mod.rs
@@ -1,3 +1,4 @@
 pub(crate) mod audits;
 pub(crate) mod columns;
+pub(crate) mod identity;
 pub(crate) mod text;
diff --git a/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs b/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs
index b1829e6728..14989b1747 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs
@@ -1,71 +1,85 @@
-//! Text checks that agree with Python's `str` methods or defer.
+//! Text checks that agree with Python's `str` methods or defer, and the errors they raise.
 
-use crate::header_metadata::models::HeaderMetadataDeferral;
+use crate::errors::ConfigError;
+use crate::header_metadata::models::HeaderMetadataStop;
 use crate::types::{AuthoredNode, NodeKind};
 
-/// Return the text of a string whose `strip()` Python finds non-empty.
-pub(crate) fn non_blank_text<N: AuthoredNode>(node: &N) -> Result<String, HeaderMetadataDeferral> {
+/// Where one parse reports its errors: the file path and the label the messages name.
+#[derive(Clone, Copy)]
+pub(crate) struct Site<'a> {
+    pub(crate) path: &'a str,
+    pub(crate) label: &'a str,
+}
+
+impl Site<'_> {
+    /// The `CompileInputError` `<path> <label> <text>`.
+    pub(crate) fn error(&self, text: &str) -> HeaderMetadataStop {
+        HeaderMetadataStop::Error(ConfigError::compile(format!(
+            "{} {} {text}",
+            self.path, self.label
+        )))
+    }
+}
+
+/// Return the text of a string whose `strip()` Python finds non-empty, `None` otherwise.
+pub(crate) fn non_blank_text<N: AuthoredNode>(
+    node: &N,
+) -> Result<Option<String>, HeaderMetadataStop> {
     if node.kind() != NodeKind::Str {
-        return Err(HeaderMetadataDeferral::Invalid);
+        return Ok(None);
     }
-    let text = node.text().ok_or(HeaderMetadataDeferral::Unsupported)?;
+    let text = node.text().ok_or(HeaderMetadataStop::Unsupported)?;
     if text
         .bytes()
         .any(|byte| byte.is_ascii() && !is_python_space(byte))
     {
-        Ok(text)
+        Ok(Some(text))
     } else if text.is_ascii() {
-        Err(HeaderMetadataDeferral::Invalid)
+        Ok(None)
     } else {
-        Err(HeaderMetadataDeferral::Unsupported)
+        Err(HeaderMetadataStop::Unsupported)
     }
 }
 
-/// Return `None` for Python's `None`, or the node of a string `strip()` finds non-empty.
+/// Read `optional_named_string`: `None`, or a string `strip()` finds non-empty.
 pub(crate) fn optional_text<N: AuthoredNode>(
     node: Option<&N>,
-) -> Result<Option<N>, HeaderMetadataDeferral> {
+    site: Site<'_>,
+    key: &str,
+) -> Result<Option<N>, HeaderMetadataStop> {
     match node {
         None => Ok(None),
         Some(value) if value.kind() == NodeKind::Null => Ok(None),
-        Some(value) => non_blank_text(value).map(|_| Some(value.clone())),
+        Some(value) => match non_blank_text(value)? {
+            Some(_) => Ok(Some(value.clone())),
+            None => Err(site.error(&format!("'{key}' must be a non-empty string"))),
+        },
     }
 }
 
-/// Return `None` for Python's `None`, or the node of a boolean.
+/// Read `optional_named_bool`: `None`, or a boolean.
 pub(crate) fn optional_bool<N: AuthoredNode>(
     node: Option<&N>,
-) -> Result<Option<N>, HeaderMetadataDeferral> {
+    site: Site<'_>,
+    key: &str,
+) -> Result<Option<N>, HeaderMetadataStop> {
     match node.map(AuthoredNode::kind) {
         None | Some(NodeKind::Null) => Ok(None),
         Some(NodeKind::Bool(_)) => Ok(node.cloned()),
-        Some(_) => Err(HeaderMetadataDeferral::Invalid),
+        Some(_) => Err(site.error(&format!("'{key}' must be a boolean"))),
     }
 }
 
-/// Return `None` for Python's `None`, or the node of a non-negative non-boolean integer.
+/// Read a non-negative non-boolean integer option, or `None`.
 pub(crate) fn optional_count<N: AuthoredNode>(
     node: Option<&N>,
-) -> Result<Option<N>, HeaderMetadataDeferral> {
+    site: Site<'_>,
+    key: &str,
+) -> Result<Option<N>, HeaderMetadataStop> {
     match node.map(AuthoredNode::kind) {
         None | Some(NodeKind::Null) => Ok(None),
         Some(NodeKind::Int { negative: false }) => Ok(node.cloned()),
-        Some(_) => Err(HeaderMetadataDeferral::Invalid),
-    }
-}
-
-/// Return whether `name` fully matches Python's `^[a-z](?:[a-z0-9_]*[a-z0-9])?$` identity pattern.
-pub(crate) fn is_snake_case(name: &str) -> bool {
-    let bytes = name.as_bytes();
-    match (bytes.first(), bytes.last()) {
-        (Some(first), Some(last)) => {
-            first.is_ascii_lowercase()
-                && (last.is_ascii_lowercase() || last.is_ascii_digit())
-                && bytes
-                    .iter()
-                    .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || *byte == b'_')
-        }
-        _ => false,
+        Some(_) => Err(site.error(&format!("'{key}' must be a non-negative integer"))),
     }
 }
 
@@ -80,6 +94,11 @@ pub(crate) fn entry<'entries, N: AuthoredNode>(
         .map(|(_, value)| value)
 }
 
+/// Return Python's `text.strip()` for ASCII text.
+pub(crate) fn ascii_strip(text: &str) -> &str {
+    text.trim_matches(|character: char| character.is_ascii() && is_python_space(character as u8))
+}
+
 /// ASCII characters Python's `str.isspace` accepts, including the information separators.
 fn is_python_space(byte: u8) -> bool {
     matches!(byte, b'\t'..=b'\r' | 0x1c..=0x1f | b' ')
diff --git a/crates/sqlbuild-model-config/src/header_metadata/constants.rs b/crates/sqlbuild-model-config/src/header_metadata/constants.rs
index 75cc6cc2cb..74bb090ec3 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/constants.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/constants.rs
@@ -18,3 +18,13 @@ pub const AUDIT_OPTION_KEYS: [&str; 8] = [
 pub const AUDIT_SEVERITIES: [&str; 2] = ["warn", "error"];
 /// The audit that contradicts `nullable = true`.
 pub const NOT_NULL_AUDIT_NAME: &str = "not_null";
+/// The help every `ResourceIdentityError` shows.
+pub const IDENTITY_HELP: &str = "Rename the authored identity and update its references, selectors, \
+and integration keys. SQLBuild does not silently normalize resource identities. Double \
+underscores remain valid.";
+/// The identity suggested when nothing of the authored name remains.
+pub const FALLBACK_IDENTITY: &str = "resource_name";
+/// The label MODEL header messages name.
+pub const MODEL_LABEL: &str = "model";
+/// The code of the nullable column that also declares `not_null`.
+pub const NULLABLE_NOT_NULL_CODE: &str = "P002";
diff --git a/crates/sqlbuild-model-config/src/header_metadata/main/parse_header_metadata.rs b/crates/sqlbuild-model-config/src/header_metadata/main/parse_header_metadata.rs
index 5ef7637674..2e83b20d2b 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/main/parse_header_metadata.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/main/parse_header_metadata.rs
@@ -1,17 +1,26 @@
-//! Parse one MODEL header's columns and audits, or defer to Python.
+//! Parse one MODEL header's columns and audits, with the errors Python raises.
 
 use crate::header_metadata::_helpers::audits::audit_list;
 use crate::header_metadata::_helpers::columns::column_mapping;
-use crate::header_metadata::models::{HeaderMetadata, HeaderMetadataDeferral};
+use crate::header_metadata::_helpers::text::Site;
+use crate::header_metadata::constants::MODEL_LABEL;
+use crate::header_metadata::models::HeaderMetadata;
 use crate::types::AuthoredNode;
 
-/// Parse the authored `columns` and `audits` values exactly as the Python compiler would.
+/// Parse the authored `columns` and `audits` of the model file at `path` as Python would.
 pub fn parse_header_metadata<N: AuthoredNode>(
     columns: &N,
     audits: &N,
-) -> Result<HeaderMetadata<N>, HeaderMetadataDeferral> {
-    Ok(HeaderMetadata {
-        columns: column_mapping(columns)?,
-        audits: audit_list(audits)?,
-    })
+    path: &str,
+) -> HeaderMetadata<N> {
+    HeaderMetadata {
+        columns: column_mapping(columns, path),
+        audits: audit_list(
+            audits,
+            Site {
+                path,
+                label: MODEL_LABEL,
+            },
+        ),
+    }
 }
diff --git a/crates/sqlbuild-model-config/src/header_metadata/models.rs b/crates/sqlbuild-model-config/src/header_metadata/models.rs
index a0e5d6602d..ddda2827de 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/models.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/models.rs
@@ -1,5 +1,7 @@
 //! Parsed MODEL header metadata whose leaves are the caller's own authored values.
 
+use crate::errors::ConfigError;
+
 /// One audit instance; every field holds the authored value Python would store.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ParsedAudit<N> {
@@ -27,18 +29,18 @@ pub struct ParsedColumn<N> {
     pub migrate_from: Option<N>,
 }
 
-/// The MODEL header's columns and model-level audits.
+/// The MODEL header's columns and model-level audits, each parsed or stopped on its own.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct HeaderMetadata<N> {
-    pub columns: Vec<ParsedColumn<N>>,
-    pub audits: Vec<ParsedAudit<N>>,
+    pub columns: Result<Vec<ParsedColumn<N>>, HeaderMetadataStop>,
+    pub audits: Result<Vec<ParsedAudit<N>>, HeaderMetadataStop>,
 }
 
-/// Why Python must parse a header's metadata instead.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum HeaderMetadataDeferral {
-    /// Python's parse raises; it runs to raise its exact error.
-    Invalid,
+/// Why a header's columns or audits did not parse natively.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum HeaderMetadataStop {
+    /// The first error Python's parse raises.
+    Error(ConfigError),
     /// Python parses it with rules the native parser does not reproduce.
     Unsupported,
 }
diff --git a/crates/sqlbuild-model-config/src/header_metadata/tests/helpers.rs b/crates/sqlbuild-model-config/src/header_metadata/tests/helpers.rs
index 47c50e95a8..a4c91f0881 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/tests/helpers.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/tests/helpers.rs
@@ -1,7 +1,5 @@
 use crate::header_metadata::main::parse_header_metadata::parse_header_metadata;
-use crate::header_metadata::models::{
-    HeaderMetadata, HeaderMetadataDeferral, ParsedAudit, ParsedColumn,
-};
+use crate::header_metadata::models::{HeaderMetadataStop, ParsedAudit, ParsedColumn};
 use crate::tests::test_types::Value;
 use crate::types::AuthoredNode;
 
@@ -15,21 +13,30 @@ pub(super) fn map(entries: &[(&'static str, Value)]) -> Value {
     )
 }
 
-/// The parse as one line per column and model audit, or why Python must parse it.
-pub(super) fn summary(
-    columns: &Value,
-    audits: &Value,
-) -> Result<Vec<String>, HeaderMetadataDeferral> {
-    parse_header_metadata(columns, audits).map(|metadata| metadata_summary(&metadata))
-}
+/// The model file path the parse errors name.
+pub(super) const MODEL_PATH: &str = "/project/models/orders.sql";
 
-fn metadata_summary(metadata: &HeaderMetadata<Value>) -> Vec<String> {
-    metadata
+/// The parse as one line per column and model audit, or the first error or `unsupported`.
+pub(super) fn summary(columns: &Value, audits: &Value) -> Result<Vec<String>, String> {
+    let metadata = parse_header_metadata(columns, audits, MODEL_PATH);
+    let columns: Vec<String> = metadata
         .columns
+        .map_err(stop_summary)?
         .iter()
         .map(column_summary)
-        .chain(metadata.audits.iter().map(audit_summary))
-        .collect()
+        .collect();
+    let audits = metadata.audits.map_err(stop_summary)?;
+    Ok(columns
+        .into_iter()
+        .chain(audits.iter().map(audit_summary))
+        .collect())
+}
+
+fn stop_summary(stop: HeaderMetadataStop) -> String {
+    let HeaderMetadataStop::Error(error) = stop else {
+        return "unsupported".to_owned();
+    };
+    error.message
 }
 
 fn column_summary(column: &ParsedColumn<Value>) -> String {
diff --git a/crates/sqlbuild-model-config/src/header_metadata/tests/test_parse_header_metadata.rs b/crates/sqlbuild-model-config/src/header_metadata/tests/test_parse_header_metadata.rs
index 9475ab725c..4910eacee2 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/tests/test_parse_header_metadata.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/tests/test_parse_header_metadata.rs
@@ -1,10 +1,9 @@
-use crate::header_metadata::models::HeaderMetadataDeferral;
 use crate::header_metadata::tests::helpers::{map, summary};
 use crate::header_metadata::tests::test_types::HeaderMetadataTestCase;
 use crate::tests::test_types::Value;
 
 #[test]
-fn given_header_metadata_when_parsing_then_happy_paths_parse_and_python_errors_defer() {
+fn given_header_metadata_when_parsing_then_python_parses_and_errors_result() {
     let column = |metadata: &[(&'static str, Value)]| map(&[("order_id", map(metadata))]);
     let test_cases = [
         HeaderMetadataTestCase {
@@ -56,58 +55,70 @@ fn given_header_metadata_when_parsing_then_happy_paths_parse_and_python_errors_d
             expected_summary: Ok(&[]),
         },
         HeaderMetadataTestCase {
-            description: "case-insensitive duplicate columns defer",
+            description: "case-insensitive duplicate columns fail",
             columns: map(&[("id", map(&[])), ("ID", map(&[]))]),
             audits: Value::Null,
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model has duplicate column 'ID' (column names are case-insensitive)",
+            ),
         },
         HeaderMetadataTestCase {
-            description: "unknown column keys defer",
+            description: "unknown column keys fail",
             columns: column(&[("format", Value::Str("x"))]),
             audits: Value::Null,
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model column 'order_id' has unknown metadata keys: format",
+            ),
         },
         HeaderMetadataTestCase {
-            description: "nullable true with not_null defers",
+            description: "nullable true with not_null fails",
             columns: column(&[
                 ("nullable", Value::Bool(true)),
                 ("audits", Value::List(vec![Value::Str("not_null")])),
             ]),
             audits: Value::Null,
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql column 'order_id' cannot set nullable = true and audit not_null",
+            ),
         },
         HeaderMetadataTestCase {
-            description: "blank or non-string text defers",
+            description: "blank or non-string text fails",
             columns: column(&[("type", Value::Str("  "))]),
             audits: Value::Null,
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model column 'order_id' 'type' must be a non-empty string",
+            ),
         },
         HeaderMetadataTestCase {
             description: "non-ASCII column names defer to Python's lower()",
             columns: map(&[("caf\u{e9}", map(&[]))]),
             audits: Value::Null,
-            expected_summary: Err(HeaderMetadataDeferral::Unsupported),
+            expected_summary: Err("unsupported"),
         },
         HeaderMetadataTestCase {
-            description: "an audit name that is not snake_case defers",
+            description: "an audit name that is not snake_case fails",
             columns: Value::Null,
             audits: Value::List(vec![Value::Str("NotNull")]),
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "Invalid model audit definition identity 'NotNull' in /project/models/orders.sql; use snake_case 'not_null'",
+            ),
         },
         HeaderMetadataTestCase {
-            description: "unknown severities, thresholds and negative counts defer",
+            description: "unknown severities, thresholds and negative counts fail",
             columns: Value::Null,
             audits: Value::List(vec![
                 map(&[("a", map(&[("severity", Value::Str("fatal"))]))]),
                 map(&[("b", map(&[("thresholds", map(&[]))]))]),
             ]),
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model audit 'a' 'severity' must be one of: warn, error",
+            ),
         },
         HeaderMetadataTestCase {
             description: "thresholds are left to Python's parser",
             columns: Value::Null,
             audits: Value::List(vec![map(&[("b", map(&[("thresholds", map(&[]))]))])]),
-            expected_summary: Err(HeaderMetadataDeferral::Unsupported),
+            expected_summary: Err("unsupported"),
         },
         HeaderMetadataTestCase {
             description: "ASCII control characters are text to Python's strip",
@@ -116,44 +127,53 @@ fn given_header_metadata_when_parsing_then_happy_paths_parse_and_python_errors_d
             expected_summary: Ok(&["order_id - - "]),
         },
         HeaderMetadataTestCase {
-            description: "a negative evidence limit defers",
+            description: "a negative evidence limit fails",
             columns: Value::Null,
             audits: Value::List(vec![map(&[(
                 "a",
                 map(&[("evidence_limit", Value::Int(-1))]),
             )])]),
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model audit 'a' 'evidence_limit' must be a non-negative integer",
+            ),
         },
         HeaderMetadataTestCase {
-            description: "a boolean count defers",
+            description: "a boolean count fails",
             columns: Value::Null,
             audits: Value::List(vec![map(&[(
                 "a",
                 map(&[("minimum_samples", Value::Bool(true))]),
             )])]),
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model audit 'a' 'minimum_samples' must be a non-negative integer",
+            ),
         },
         HeaderMetadataTestCase {
-            description: "an audit list that is not a list defers",
+            description: "an audit list that is not a list fails",
             columns: Value::Null,
             audits: Value::Float,
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err("/project/models/orders.sql model audits must be a list"),
         },
         HeaderMetadataTestCase {
-            description: "a multi-key audit mapping defers",
+            description: "a multi-key audit mapping fails",
             columns: Value::Null,
             audits: Value::List(vec![map(&[("a", Value::Null), ("b", Value::Null)])]),
-            expected_summary: Err(HeaderMetadataDeferral::Invalid),
+            expected_summary: Err(
+                "/project/models/orders.sql model audits must be strings or single-key mappings",
+            ),
         },
     ];
 
     for test_case in test_cases {
         assert_eq!(
             summary(&test_case.columns, &test_case.audits),
-            test_case.expected_summary.map(|lines| lines
-                .iter()
-                .map(|line| (*line).to_owned())
-                .collect::<Vec<_>>()),
+            test_case
+                .expected_summary
+                .map(|lines| lines
+                    .iter()
+                    .map(|line| (*line).to_owned())
+                    .collect::<Vec<_>>())
+                .map_err(str::to_owned),
             "{}",
             test_case.description
         );
diff --git a/crates/sqlbuild-model-config/src/header_metadata/tests/test_types.rs b/crates/sqlbuild-model-config/src/header_metadata/tests/test_types.rs
index 55a9ffa600..8e0f831b52 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/tests/test_types.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/tests/test_types.rs
@@ -1,4 +1,3 @@
-use crate::header_metadata::models::HeaderMetadataDeferral;
 use crate::tests::test_types::Value;
 
 /// One header's `columns` and `audits` values and the parse the native parser must produce.
@@ -6,6 +5,6 @@ pub(super) struct HeaderMetadataTestCase {
     pub(super) description: &'static str,
     pub(super) columns: Value,
     pub(super) audits: Value,
-    /// `name type nullable audit,audit` per column, then `audit:argument,...` per model audit.
-    pub(super) expected_summary: Result<&'static [&'static str], HeaderMetadataDeferral>,
+    /// Lines per column then model audit, or the first error message, or `unsupported`.
+    pub(super) expected_summary: Result<&'static [&'static str], &'static str>,
 }
diff --git a/crates/sqlbuild-model-config/src/lib.rs b/crates/sqlbuild-model-config/src/lib.rs
index 414cb0b950..5e8b132f8e 100644
--- a/crates/sqlbuild-model-config/src/lib.rs
+++ b/crates/sqlbuild-model-config/src/lib.rs
@@ -3,6 +3,7 @@
 #![forbid(unsafe_code)]
 
 pub mod config_presence;
+pub mod errors;
 pub mod header_metadata;
 pub mod model_validation;
 pub mod path_defaults;
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/config.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/config.rs
index e1d386cb32..5c69012b41 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/config.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/config.rs
@@ -1,31 +1,35 @@
 //! Effective config values read the way the Python validators read the dict.
 
 use std::collections::HashMap;
+use std::fmt::Display;
 
+use crate::errors::ConfigError;
 use crate::model_validation::_helpers::text::{python_lower, python_strip};
-use crate::model_validation::models::Rejected;
+use crate::model_validation::models::{Rejected, ValidationStop};
 use crate::types::{AuthoredNode, NodeKind};
 
 /// Config values by string key; Python's `dict.get` never matches other keys.
-pub(crate) struct ConfigView<N> {
+pub(crate) struct ConfigView<'a, N> {
     values: HashMap<String, N>,
+    /// The model name every validator message starts with.
+    pub(crate) model_name: &'a str,
 }
 
-impl<N: AuthoredNode> ConfigView<N> {
-    /// View the entries of one config mapping.
-    pub(crate) fn new(entries: Vec<(N, N)>) -> Self {
+impl<'a, N: AuthoredNode> ConfigView<'a, N> {
+    /// View the entries of one config mapping for the model `model_name`.
+    pub(crate) fn new(entries: Vec<(N, N)>, model_name: &'a str) -> Self {
         let mut values: HashMap<String, N> = HashMap::with_capacity(entries.len());
         for (key, value) in entries {
             if let Some(text) = key.text() {
                 values.insert(text, value);
             }
         }
-        Self { values }
+        Self { values, model_name }
     }
 
-    /// Return whether `key in values`, even when its value is `None`.
-    pub(crate) fn contains_key(&self, key: &str) -> bool {
-        self.values.contains_key(key)
+    /// Return `values[key]` when the key is present, even when its value is `None`.
+    pub(crate) fn raw(&self, key: &str) -> Option<&N> {
+        self.values.get(key)
     }
 
     /// Return `values.get(key)` unless it is absent or `None`.
@@ -40,20 +44,34 @@ impl<N: AuthoredNode> ConfigView<N> {
         self.get(key).is_some()
     }
 
-    /// Return whether any of `keys` is set.
-    pub(crate) fn any_present(&self, keys: &[&str]) -> bool {
-        keys.iter().any(|key| self.present(key))
+    /// Return the first of `keys` that is set, in order.
+    pub(crate) fn first_present<'k>(&self, keys: &[&'k str]) -> Option<&'k str> {
+        keys.iter().copied().find(|key| self.present(key))
     }
 
-    /// Read `get_config_str`: a string, `None`, or a rejection for any other type.
-    pub(crate) fn string(&self, key: &str) -> Result<Option<String>, Rejected> {
-        self.get(key).map(string_value).transpose()
+    /// Read `get_config_str`: a string, `None`, or the type error it raises for other values.
+    pub(crate) fn string(&self, key: &str) -> Result<Option<String>, ValidationStop> {
+        match self.get(key) {
+            None => Ok(None),
+            Some(value) if value.kind() == NodeKind::Str => Ok(Some(value.text().ok_or(Rejected)?)),
+            Some(_) => Err(ValidationStop::Error(ConfigError::config_value_type(key))),
+        }
     }
 
     /// Return whether the value equals `text`, as Python's `==` against a string.
     pub(crate) fn equals(&self, key: &str, text: &str) -> bool {
         self.get(key).is_some_and(|value| value.is_text(text))
     }
+
+    /// The validator error `model '<name>': <text>`.
+    pub(crate) fn error(&self, text: impl Display) -> ValidationStop {
+        ValidationStop::Error(self.config_error(text))
+    }
+
+    /// The `CompileInputError` `model '<name>': <text>`.
+    pub(crate) fn config_error(&self, text: impl Display) -> ConfigError {
+        ConfigError::compile(format!("model '{}': {text}", self.model_name))
+    }
 }
 
 /// Return the text of a string value, or reject any other type.
@@ -65,24 +83,70 @@ pub(crate) fn string_value<N: AuthoredNode>(value: &N) -> Result<String, Rejecte
     }
 }
 
-/// Return `None` for an absent or `None` value, the text of a string, or reject other types.
-pub(crate) fn optional_text<N: AuthoredNode>(
-    value: Option<&N>,
-) -> Result<Option<String>, Rejected> {
-    match value {
-        Some(node) if node.kind() != NodeKind::Null => string_value(node).map(Some),
-        _ => Ok(None),
+/// Return the text of a string value, `None` for another type, or reject unreadable text.
+pub(crate) fn text_if_string<N: AuthoredNode>(value: &N) -> Result<Option<String>, Rejected> {
+    if value.kind() == NodeKind::Str {
+        value.text().map(Some).ok_or(Rejected)
+    } else {
+        Ok(None)
+    }
+}
+
+/// Return Python's `str(value)` for strings, integers, booleans and `None`, or reject.
+pub(crate) fn python_str<N: AuthoredNode>(value: &N) -> Result<String, Rejected> {
+    match value.kind() {
+        NodeKind::Str => value.text().ok_or(Rejected),
+        NodeKind::Int { .. } => value
+            .integer()
+            .map(|number| number.to_string())
+            .ok_or(Rejected),
+        NodeKind::Bool(flag) => Ok(if flag { "True" } else { "False" }.to_owned()),
+        NodeKind::Null => Ok("None".to_owned()),
+        _ => Err(Rejected),
     }
 }
 
+/// Return Python's `repr(value)` for printable ASCII strings and scalars, or reject.
+pub(crate) fn python_repr<N: AuthoredNode>(value: &N) -> Result<String, Rejected> {
+    if value.kind() != NodeKind::Str {
+        return python_str(value);
+    }
+    let text = value.text().ok_or(Rejected)?;
+    python_text_repr(&text)
+}
+
+/// Return Python's `repr(text)` for printable ASCII text, or reject.
+pub(crate) fn python_text_repr(text: &str) -> Result<String, Rejected> {
+    if !text.bytes().all(|byte| (b' '..=b'~').contains(&byte)) {
+        return Err(Rejected);
+    }
+    let quote = if text.contains('\'') && !text.contains('"') {
+        '"'
+    } else {
+        '\''
+    };
+    let mut repr = String::with_capacity(text.len() + 2);
+    repr.push(quote);
+    for character in text.chars() {
+        if character == '\\' || character == quote {
+            repr.push('\\');
+        }
+        repr.push(character);
+    }
+    repr.push(quote);
+    Ok(repr)
+}
+
 /// Return whether `text in vocabulary`.
 pub(crate) fn one_of(text: &str, vocabulary: &[&str]) -> bool {
     vocabulary.contains(&text)
 }
 
-/// Return whether an optional string is in `vocabulary`; `None` is not.
-pub(crate) fn optional_one_of(text: Option<&str>, vocabulary: &[&str]) -> bool {
-    text.is_some_and(|value| one_of(value, vocabulary))
+/// Return the vocabulary sorted and joined with `, `, as the Python messages list it.
+pub(crate) fn sorted_values(vocabulary: &[&str]) -> String {
+    let mut values: Vec<&str> = vocabulary.to_vec();
+    values.sort_unstable();
+    values.join(", ")
 }
 
 /// Read `_string_sequence`: a string, or the strings of a list or tuple; reject unreadable text.
@@ -106,25 +170,15 @@ pub(crate) fn has_config_value<N: AuthoredNode>(value: Option<&N>) -> bool {
     })
 }
 
-/// Return the text of a string whose Python `strip()` is non-empty, or reject.
-pub(crate) fn non_blank_string<N: AuthoredNode>(value: &N) -> Result<String, Rejected> {
-    let text = string_value(value)?;
-    if python_strip(&text)?.is_empty() {
-        Err(Rejected)
-    } else {
-        Ok(text)
+/// Check that a value is a string whose Python `strip()` is non-empty, or reject.
+pub(crate) fn non_blank_string_check<N: AuthoredNode>(value: &N) -> Result<bool, Rejected> {
+    match text_if_string(value)? {
+        Some(text) => Ok(!python_strip(&text)?.is_empty()),
+        None => Ok(false),
     }
 }
 
-/// Reject duplicate names under Python's `str.lower()`.
-pub(crate) fn reject_case_insensitive_duplicates(names: &[String]) -> Result<(), Rejected> {
-    let mut seen = Vec::with_capacity(names.len());
-    for name in names {
-        let lowered = python_lower(name)?;
-        if seen.contains(&lowered) {
-            return Err(Rejected);
-        }
-        seen.push(lowered);
-    }
-    Ok(())
+/// Return whether two names are equal under Python's `str.lower()`, or reject.
+pub(crate) fn same_lowered(left: &str, right: &str) -> Result<bool, Rejected> {
+    Ok(python_lower(left)? == python_lower(right)?)
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/cursor_bounds.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/cursor_bounds.rs
index 3c10d64100..53f83a1324 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/cursor_bounds.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/cursor_bounds.rs
@@ -1,57 +1,211 @@
-//! `cursor_start` and `cursor_end` values Python certainly accepts, with their ordering keys.
+//! `cursor_start` and `cursor_end` checks with the errors Python raises, and their ordering keys.
 
+use crate::model_validation::_helpers::config::{ConfigView, python_text_repr, text_if_string};
+use crate::model_validation::_helpers::text::python_strip;
 use crate::model_validation::constants::{
-    CLOCK_FIELD_LENGTH, CLOCK_PART_COUNTS, CLOCK_PARTS_WITH_SECONDS, INTEGER_CURSOR,
-    ISO_DATE_LENGTH, ISO_DATE_SEPARATOR_OFFSETS, LAST_SHIFTED_MONTH, MAX_HOUR, MAX_MINUTE,
-    MAX_YEAR, MIN_YEAR, TIMESTAMP_CURSOR, UTC_OFFSET_LENGTH,
+    CLOCK_FIELD_LENGTH, CLOCK_PART_COUNTS, CLOCK_PARTS_WITH_SECONDS, DECIMAL_SPECIAL_PREFIXES,
+    INTEGER_CURSOR, ISO_DATE_LENGTH, ISO_DATE_SEPARATOR_OFFSETS, LAST_SHIFTED_MONTH, MAX_HOUR,
+    MAX_MINUTE, MAX_YEAR, MIN_YEAR, TIMESTAMP_CURSOR, UTC_OFFSET_LENGTH,
 };
-use crate::model_validation::models::Rejected;
-use crate::types::AuthoredNode;
+use crate::model_validation::models::{Rejected, ValidationStop};
+use crate::model_validation::types::Check;
+use crate::types::{AuthoredNode, NodeKind};
 
 const MICROS_PER_SECOND: i128 = 1_000_000;
 const SECONDS_PER_DAY: i128 = 86_400;
 const SECONDS_PER_HOUR: i128 = 3_600;
 const SECONDS_PER_MINUTE: i128 = 60;
 const CIVIL_EPOCH_OFFSET_DAYS: i128 = 719_468;
+const DAYS_PER_ERA: i128 = 146_097;
 const FRACTION_DIGITS: [usize; 2] = [3, 6];
+const MICROSECOND_DIGITS: u32 = 6;
+/// January's month index when months count from March.
+const MARCH_BASED_JANUARY: i128 = 10;
+const DECIMAL_SYNTAX: &str = "0123456789+-.eE";
 
-/// Return the `_cursor_contract_key` order key: UTC microseconds, or the integer itself.
-pub(crate) fn cursor_bound_key<N: AuthoredNode>(
+/// A bound's `_cursor_contract_key`, or the overflow Python reports while shifting it to UTC.
+pub(crate) enum BoundKey {
+    /// UTC microseconds, or the integer itself.
+    Key(i128),
+    /// The UTC shift leaves years 1-9999; the text is the value's ISO form at UTC.
+    Overflow(String),
+}
+
+/// A parsed ISO timestamp.
+struct Timestamp {
+    days: i128,
+    clock_micros: i128,
+    /// The UTC offset in seconds, or `None` for a naive value.
+    offset_seconds: Option<i128>,
+}
+
+/// Check one bound as `_validate_timestamp_cursor_start` or `_validate_integer_cursor_start` does.
+pub(crate) fn check_bound<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    bound: &N,
+    cursor_type: Option<&str>,
+) -> Check {
+    match cursor_type {
+        Some(TIMESTAMP_CURSOR) => check_timestamp_bound(config, bound),
+        Some(INTEGER_CURSOR) => check_integer_bound(config, bound),
+        _ => Ok(()),
+    }
+}
+
+fn check_timestamp_bound<N: AuthoredNode>(config: &ConfigView<'_, N>, bound: &N) -> Check {
+    match bound.kind() {
+        NodeKind::Str => {
+            let text = bound.text().ok_or(Rejected)?;
+            parse_timestamp(&text)
+                .map(|_| ())
+                .or_else(|Rejected| invalid_timestamp(config, &text))
+        }
+        NodeKind::Other => Err(ValidationStop::Defer),
+        _ => Err(config
+            .error("cursor_start for cursor_type=timestamp must be a string or date-like value")),
+    }
+}
+
+/// Raise Python's error for an ASCII string without digits, which no ISO form parses; else defer.
+fn invalid_timestamp<N: AuthoredNode>(config: &ConfigView<'_, N>, text: &str) -> Check {
+    if !text.is_ascii() || text.bytes().any(|byte| byte.is_ascii_digit()) {
+        return Err(ValidationStop::Defer);
+    }
+    let repr = python_text_repr(text)?;
+    Err(config.error(format!(
+        "cursor_start value '{text}' is not a valid ISO timestamp: Invalid isoformat string: \
+         {repr}"
+    )))
+}
+
+fn check_integer_bound<N: AuthoredNode>(config: &ConfigView<'_, N>, bound: &N) -> Check {
+    match bound.kind() {
+        NodeKind::Bool(_) => {
+            Err(config.error("cursor_start for cursor_type=integer must be an integer"))
+        }
+        NodeKind::Int { .. } => Ok(()),
+        NodeKind::Str => {
+            let text = bound.text().ok_or(Rejected)?;
+            match plain_decimal(&text) {
+                Some((_, fraction)) if fraction.bytes().all(|byte| byte == b'0') => Ok(()),
+                Some(_) => {
+                    Err(config.error(format!("cursor_start value '{text}' is not a whole number")))
+                }
+                None if certainly_not_decimal(&text)? => Err(config.error(format!(
+                    "cursor_start value '{text}' is not a valid integer"
+                ))),
+                None => Err(ValidationStop::Defer),
+            }
+        }
+        _ => Err(config.error("cursor_start for cursor_type=integer must be a string or integer")),
+    }
+}
+
+/// Split `[+-]digits[.digits]` into its signed whole part and fraction digits.
+fn plain_decimal(text: &str) -> Option<(&str, &str)> {
+    let unsigned = text.strip_prefix(['+', '-']).unwrap_or(text);
+    let (whole, fraction) = unsigned.split_once('.').unwrap_or((unsigned, ""));
+    let digits = |part: &str| part.bytes().all(|byte| byte.is_ascii_digit());
+    let has_fraction = unsigned.contains('.');
+    if whole.is_empty()
+        || !digits(whole)
+        || !digits(fraction)
+        || (has_fraction && fraction.is_empty())
+    {
+        return None;
+    }
+    Some((&text[..text.len() - unsigned.len() + whole.len()], fraction))
+}
+
+/// Return whether `Decimal(text)` certainly raises `InvalidOperation`, or reject non-ASCII text.
+fn certainly_not_decimal(text: &str) -> Result<bool, Rejected> {
+    let stripped: String = python_strip(text)?.replace('_', "");
+    if stripped.is_empty() {
+        return Ok(true);
+    }
+    let special = stripped.trim_start_matches(['+', '-']).to_ascii_lowercase();
+    Ok(stripped
+        .chars()
+        .any(|character| !DECIMAL_SYNTAX.contains(character))
+        && !DECIMAL_SPECIAL_PREFIXES
+            .iter()
+            .any(|prefix| special.starts_with(prefix)))
+}
+
+/// Return the `_cursor_contract_key` of a bound that passed its checks, or reject.
+pub(crate) fn bound_key<N: AuthoredNode>(
     value: &N,
     cursor_type: &str,
-) -> Result<i128, Rejected> {
+) -> Result<BoundKey, Rejected> {
     if let Some(number) = value.integer().filter(|_| cursor_type == INTEGER_CURSOR) {
-        return Ok(i128::from(number));
+        return Ok(BoundKey::Key(i128::from(number)));
     }
-    let text = value.text().ok_or(Rejected)?;
+    let text = text_if_string(value)?.ok_or(Rejected)?;
     match cursor_type {
-        INTEGER_CURSOR => integer_key(&text),
+        INTEGER_CURSOR => integer_key(&text).map(BoundKey::Key),
         TIMESTAMP_CURSOR => timestamp_key(&text),
         _ => Err(Rejected),
     }
 }
 
-/// Return whether two timestamp keys keep their order through Python's float timestamps.
-pub(crate) fn keys_ordered(start: i128, end: i128, cursor_type: &str) -> bool {
-    if cursor_type == TIMESTAMP_CURSOR {
-        end - start >= MICROS_PER_SECOND
+/// Return whether `start < end` as Python compares the keys, or reject when floats may tie.
+pub(crate) fn keys_ordered(start: i128, end: i128, cursor_type: &str) -> Result<bool, Rejected> {
+    if cursor_type != TIMESTAMP_CURSOR || start >= end {
+        return Ok(start < end);
+    }
+    if end - start >= MICROS_PER_SECOND {
+        Ok(true)
     } else {
-        start < end
+        Err(Rejected)
     }
 }
 
 fn integer_key(text: &str) -> Result<i128, Rejected> {
-    let digits = text.strip_prefix(['+', '-']).unwrap_or(text);
-    if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
+    let (whole, fraction) = plain_decimal(text).ok_or(Rejected)?;
+    if !fraction.bytes().all(|byte| byte == b'0') {
         return Err(Rejected);
     }
-    text.strip_prefix('+')
-        .unwrap_or(text)
+    whole
+        .strip_prefix('+')
+        .unwrap_or(whole)
         .parse()
         .map_err(|_| Rejected)
 }
 
-fn timestamp_key(text: &str) -> Result<i128, Rejected> {
+fn timestamp_key(text: &str) -> Result<BoundKey, Rejected> {
+    let timestamp = parse_timestamp(text)?;
+    let local_micros =
+        timestamp.days * SECONDS_PER_DAY * MICROS_PER_SECOND + timestamp.clock_micros;
+    let utc_micros = local_micros - timestamp.offset_seconds.unwrap_or(0) * MICROS_PER_SECOND;
+    let day_micros = SECONDS_PER_DAY * MICROS_PER_SECOND;
+    let first_micros = days_from_civil(MIN_YEAR, 1, 1) * day_micros;
+    let end_micros = days_from_civil(MAX_YEAR + 1, 1, 1) * day_micros;
+    if utc_micros < first_micros || utc_micros >= end_micros {
+        return Ok(BoundKey::Overflow(utc_isoformat(&timestamp)));
+    }
+    Ok(BoundKey::Key(utc_micros))
+}
+
+/// Return `parsed.replace(tzinfo=UTC).isoformat()`.
+fn utc_isoformat(timestamp: &Timestamp) -> String {
+    let (year, month, day) = civil_from_days(timestamp.days);
+    let seconds = timestamp.clock_micros / MICROS_PER_SECOND;
+    let micros = timestamp.clock_micros % MICROS_PER_SECOND;
+    let clock = format!(
+        "{:02}:{:02}:{:02}",
+        seconds / SECONDS_PER_HOUR,
+        seconds % SECONDS_PER_HOUR / SECONDS_PER_MINUTE,
+        seconds % SECONDS_PER_MINUTE
+    );
+    let fraction = if micros == 0 {
+        String::new()
+    } else {
+        format!(".{micros:06}")
+    };
+    format!("{year:04}-{month:02}-{day:02}T{clock}{fraction}+00:00")
+}
+
+fn parse_timestamp(text: &str) -> Result<Timestamp, Rejected> {
     if !text.is_ascii() {
         return Err(Rejected);
     }
@@ -66,18 +220,15 @@ fn timestamp_key(text: &str) -> Result<i128, Rejected> {
         _ => return Err(Rejected),
     };
     let days = date_days(date)?;
-    let (micros, offset_seconds) = match time {
-        None => (0, 0),
+    let (clock_micros, offset_seconds) = match time {
+        None => (0, None),
         Some(clock) => clock_micros(clock)?,
     };
-    let utc_micros = (days * SECONDS_PER_DAY - offset_seconds) * MICROS_PER_SECOND + micros;
-    let day_micros = SECONDS_PER_DAY * MICROS_PER_SECOND;
-    let first_micros = days_from_civil(MIN_YEAR, 1, 1) * day_micros;
-    let end_micros = days_from_civil(MAX_YEAR + 1, 1, 1) * day_micros;
-    if utc_micros < first_micros || utc_micros >= end_micros {
-        return Err(Rejected);
-    }
-    Ok(utc_micros)
+    Ok(Timestamp {
+        days,
+        clock_micros,
+        offset_seconds,
+    })
 }
 
 fn date_days(date: &str) -> Result<i128, Rejected> {
@@ -95,7 +246,7 @@ fn date_days(date: &str) -> Result<i128, Rejected> {
     Ok(days_from_civil(year, month, day))
 }
 
-fn clock_micros(clock: &str) -> Result<(i128, i128), Rejected> {
+fn clock_micros(clock: &str) -> Result<(i128, Option<i128>), Rejected> {
     let (clock, offset_seconds) = split_offset(clock)?;
     let (hms, fraction) = clock
         .split_once('.')
@@ -116,7 +267,8 @@ fn clock_micros(clock: &str) -> Result<(i128, i128), Rejected> {
     let fraction_micros = match fraction {
         None => 0,
         Some(digits) if FRACTION_DIGITS.contains(&digits.len()) => {
-            number(digits)? * 10_i128.pow(6 - u32::try_from(digits.len()).map_err(|_| Rejected)?)
+            let scale = MICROSECOND_DIGITS - u32::try_from(digits.len()).map_err(|_| Rejected)?;
+            number(digits)? * 10_i128.pow(scale)
         }
         Some(_) => return Err(Rejected),
     };
@@ -127,12 +279,12 @@ fn clock_micros(clock: &str) -> Result<(i128, i128), Rejected> {
     ))
 }
 
-fn split_offset(clock: &str) -> Result<(&str, i128), Rejected> {
+fn split_offset(clock: &str) -> Result<(&str, Option<i128>), Rejected> {
     if let Some(clock) = clock.strip_suffix('Z') {
-        return Ok((clock, 0));
+        return Ok((clock, Some(0)));
     }
     let Some(sign_index) = clock.rfind(['+', '-']) else {
-        return Ok((clock, 0));
+        return Ok((clock, None));
     };
     let offset = &clock[sign_index + 1..];
     let bytes = offset.as_bytes();
@@ -150,7 +302,7 @@ fn split_offset(clock: &str) -> Result<(&str, i128), Rejected> {
     } else {
         1
     };
-    Ok((&clock[..sign_index], sign * magnitude))
+    Ok((&clock[..sign_index], Some(sign * magnitude)))
 }
 
 fn number(digits: &str) -> Result<i128, Rejected> {
@@ -180,5 +332,23 @@ fn days_from_civil(year: i128, month: i128, day: i128) -> i128 {
     let shifted_month = (month + 9) % 12;
     let day_of_year = (153 * shifted_month + 2) / 5 + day - 1;
     let day_of_era = year_of_era * 365 + year_of_era / 4 - year_of_era / 100 + day_of_year;
-    era * 146_097 + day_of_era - CIVIL_EPOCH_OFFSET_DAYS
+    era * DAYS_PER_ERA + day_of_era - CIVIL_EPOCH_OFFSET_DAYS
+}
+
+fn civil_from_days(days: i128) -> (i128, i128, i128) {
+    let shifted = days + CIVIL_EPOCH_OFFSET_DAYS;
+    let era = shifted.div_euclid(DAYS_PER_ERA);
+    let day_of_era = shifted - era * DAYS_PER_ERA;
+    let year_of_era =
+        (day_of_era - day_of_era / 1_460 + day_of_era / 36_524 - day_of_era / 146_096) / 365;
+    let day_of_year = day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
+    let shifted_month = (5 * day_of_year + 2) / 153;
+    let day = day_of_year - (153 * shifted_month + 2) / 5 + 1;
+    let month = if shifted_month < MARCH_BASED_JANUARY {
+        shifted_month + 3
+    } else {
+        shifted_month - 9
+    };
+    let year = year_of_era + era * 400 + i128::from(month <= LAST_SHIFTED_MONTH);
+    (year, month, day)
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/incremental.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/incremental.rs
index d1e8731d21..482751c1b6 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/incremental.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/incremental.rs
@@ -1,37 +1,45 @@
-//! `validate_incremental_config` for configs Python certainly accepts.
+//! `validate_incremental_config`, raising the first error the Python validator raises.
 
 use std::collections::HashSet;
 
 use crate::model_validation::_helpers::config::{
-    ConfigView, has_config_value, one_of, optional_one_of, reject_case_insensitive_duplicates,
-    string_sequence, string_value,
+    ConfigView, has_config_value, one_of, sorted_values, string_sequence,
+};
+use crate::model_validation::_helpers::cursor_bounds::{
+    BoundKey, bound_key, check_bound, keys_ordered,
 };
-use crate::model_validation::_helpers::cursor_bounds::{cursor_bound_key, keys_ordered};
 use crate::model_validation::_helpers::durations::parse_duration;
 use crate::model_validation::_helpers::microbatch::check_incremental_batching;
-use crate::model_validation::_helpers::text::{python_lower, python_strip};
+use crate::model_validation::_helpers::text::{model_header_help, python_lower, python_strip};
 use crate::model_validation::constants::{
     APPEND_STRATEGY, BOUNDED_REPLAY_PREFIX, CURSOR_GRAIN_BATCH_SIZES, CURSOR_INPUT_KEYS,
     CURSOR_POLICY_DISABLED, CURSOR_TYPES, DELETE_INSERT_STRATEGY, EFFECTIVE_BATCH_SIZE,
     ENFORCED_CONTRACT, FUTURE_CURSOR_ACTIONS, INCREMENTAL_MATERIALIZATION, INCREMENTAL_STRATEGIES,
-    MERGE_STRATEGY, ON_SCHEMA_CHANGE_POLICIES, REPLAY_ON_CHANGE_ACTIONS, TABLE_MATERIALIZATION,
+    MERGE_STRATEGY, ON_SCHEMA_CHANGE_EXAMPLE, ON_SCHEMA_CHANGE_POLICIES, REPLAY_ON_CHANGE_ACTIONS,
+    REPLAY_ON_CHANGE_EXAMPLE, REPLAY_ON_CHANGE_VALID_VALUES, TABLE_MATERIALIZATION,
     TIMESTAMP_CURSOR, VIEW_MATERIALIZATION, ZERO_DAY_DURATION,
 };
-use crate::model_validation::models::{ModelValidationFacts, Rejected};
+use crate::model_validation::models::{ModelValidationFacts, Rejected, ValidationStop};
 use crate::model_validation::types::Check;
 use crate::types::{AuthoredNode, NodeKind};
 
-/// The incremental config values `_resolve_incremental_config_values` reads.
+const ON_SCHEMA_CHANGE_KEY: &str = "on_schema_change";
+const REPLAY_ON_CHANGE_KEY: &str = "replay_on_change";
+const CURSOR_SAFETY_DURATION_KEYS: [&str; 2] =
+    ["cursor_start_max_ahead", "cursor_future_max_distance"];
+const CURSOR_SAFETY_ACTION_KEYS: [&str; 2] = ["cursor_start_max_action", "cursor_future_action"];
+
+/// The incremental config values `_resolve_incremental_config_values` reads, in its order.
 pub(crate) struct IncrementalValues<N> {
     pub(crate) strategy: Option<String>,
     pub(crate) cursor: Option<String>,
     pub(crate) cursor_type: Option<String>,
-    pub(crate) cursor_grain: Option<String>,
     pub(crate) lookback: Option<String>,
     pub(crate) incremental_mode: Option<String>,
     pub(crate) batch_size: Option<String>,
     pub(crate) microbatch_strategy: Option<String>,
     pub(crate) cursor_watermark_mode: Option<String>,
+    pub(crate) cursor_grain: Option<String>,
     pub(crate) cursor_start: Option<N>,
     pub(crate) cursor_end: Option<N>,
     pub(crate) unique_key: Option<N>,
@@ -42,18 +50,27 @@ pub(crate) struct IncrementalValues<N> {
 }
 
 impl<N: AuthoredNode> IncrementalValues<N> {
-    fn read(config: &ConfigView<N>) -> Result<Self, Rejected> {
+    fn read(config: &ConfigView<'_, N>) -> Result<Self, ValidationStop> {
         let node = |key: &str| config.get(key).cloned();
+        let strategy = config.string("incremental_strategy")?;
+        let cursor = config.string("cursor")?;
+        let cursor_type = config.string("cursor_type")?;
+        let lookback = config.string("lookback")?;
+        let incremental_mode = config.string("incremental_mode")?;
+        let batch_size = config.string("batch_size")?;
+        let microbatch_strategy = config.string("microbatch_strategy")?;
+        let cursor_watermark_mode = config.string("cursor_watermark_mode")?;
+        let cursor_grain = config.string("cursor_grain")?;
         Ok(Self {
-            strategy: config.string("incremental_strategy")?,
-            cursor: config.string("cursor")?,
-            cursor_type: config.string("cursor_type")?,
-            cursor_grain: config.string("cursor_grain")?,
-            lookback: config.string("lookback")?,
-            incremental_mode: config.string("incremental_mode")?,
-            batch_size: config.string("batch_size")?,
-            microbatch_strategy: config.string("microbatch_strategy")?,
-            cursor_watermark_mode: config.string("cursor_watermark_mode")?,
+            strategy,
+            cursor,
+            cursor_type,
+            lookback,
+            incremental_mode,
+            batch_size,
+            microbatch_strategy,
+            cursor_watermark_mode,
+            cursor_grain,
             cursor_start: node("cursor_start"),
             cursor_end: node("cursor_end"),
             unique_key: node("unique_key"),
@@ -80,9 +97,9 @@ impl<N: AuthoredNode> IncrementalValues<N> {
     }
 }
 
-/// Accept the incremental rules for one model's layered config.
+/// Check the incremental rules for one model's layered config.
 pub(crate) fn check_incremental<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
     let materialized = config.string("materialized")?;
@@ -90,212 +107,338 @@ pub(crate) fn check_incremental<N: AuthoredNode>(
     if matches!(
         materialized,
         Some(TABLE_MATERIALIZATION | VIEW_MATERIALIZATION)
-    ) && config.any_present(&CURSOR_INPUT_KEYS)
+    ) && let Some(key) = config.first_present(&CURSOR_INPUT_KEYS)
     {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "{key} requires cursor-based incremental materialization"
+        )));
     }
     if materialized != Some(INCREMENTAL_MATERIALIZATION) {
         return Ok(());
     }
     let values = IncrementalValues::read(config)?;
     check_core(config, &values)?;
-    check_incremental_batching(&values, config, facts)?;
+    check_incremental_batching(config, &values, facts)?;
     check_write_strategy(config, &values)?;
     check_contract_columns(config, &values, facts)?;
     if values.lookback.is_some() && values.cursor.is_none() {
-        return Err(Rejected);
+        return Err(config.error("lookback is only valid with cursor-based incremental"));
     }
     Ok(())
 }
 
-fn check_core<N: AuthoredNode>(config: &ConfigView<N>, values: &IncrementalValues<N>) -> Check {
-    if let Some(value) = config.get("on_schema_change") {
-        accept_text(value, |text| Ok(one_of(text, &ON_SCHEMA_CHANGE_POLICIES)))?;
-    }
-    if let Some(value) = config.get("replay_on_change") {
-        accept_text(value, valid_replay_on_change)?;
+fn check_core<N: AuthoredNode>(config: &ConfigView<'_, N>, values: &IncrementalValues<N>) -> Check {
+    for (key, example) in [
+        (ON_SCHEMA_CHANGE_KEY, ON_SCHEMA_CHANGE_EXAMPLE),
+        (REPLAY_ON_CHANGE_KEY, REPLAY_ON_CHANGE_EXAMPLE),
+    ] {
+        if let Some(value) = config.get(key)
+            && let Some(problem) = change_policy_problem(key, value)?
+        {
+            let help =
+                model_header_help(&format!("use a valid {key}"), &format!("{key} {example}"));
+            return Err(ValidationStop::Error(
+                config.config_error(problem).with_help(help),
+            ));
+        }
     }
-    if !optional_one_of(values.strategy.as_deref(), &INCREMENTAL_STRATEGIES) {
-        return Err(Rejected);
+    let Some(strategy) = values.strategy.as_deref() else {
+        return Err(config.error("incremental materialization requires incremental_strategy"));
+    };
+    if !one_of(strategy, &INCREMENTAL_STRATEGIES) {
+        return Err(config.error(format!(
+            "unknown incremental_strategy '{strategy}'; valid values: {}",
+            sorted_values(&INCREMENTAL_STRATEGIES)
+        )));
     }
     check_cursor_rules(config, values)?;
     check_cursor_safety(config, values)
 }
 
-fn accept_text<N: AuthoredNode>(
+/// Return `change_policy_problem`: why a change-policy value is invalid, or `None`.
+fn change_policy_problem<N: AuthoredNode>(
+    key: &str,
     value: &N,
-    valid: impl FnOnce(&str) -> Result<bool, Rejected>,
-) -> Check {
-    if valid(&string_value(value)?)? {
-        Ok(())
+) -> Result<Option<String>, Rejected> {
+    let valid = if key == ON_SCHEMA_CHANGE_KEY {
+        sorted_values(&ON_SCHEMA_CHANGE_POLICIES)
     } else {
-        Err(Rejected)
+        REPLAY_ON_CHANGE_VALID_VALUES.join(", ")
+    };
+    if value.kind() != NodeKind::Str {
+        return Ok(Some(format!(
+            "{key} must be a string; valid values: {valid}"
+        )));
     }
-}
-
-fn valid_replay_on_change(text: &str) -> Result<bool, Rejected> {
-    if one_of(text, &REPLAY_ON_CHANGE_ACTIONS) {
-        return Ok(true);
+    let text = value.text().ok_or(Rejected)?;
+    if key == ON_SCHEMA_CHANGE_KEY && one_of(&text, &ON_SCHEMA_CHANGE_POLICIES) {
+        return Ok(None);
     }
-    match text.strip_prefix(BOUNDED_REPLAY_PREFIX) {
-        Some(duration) => Ok(parse_duration(python_strip(duration)?)?.is_some()),
-        None => Ok(false),
+    if key == REPLAY_ON_CHANGE_KEY {
+        if one_of(&text, &REPLAY_ON_CHANGE_ACTIONS) {
+            return Ok(None);
+        }
+        if let Some(rest) = text.strip_prefix(BOUNDED_REPLAY_PREFIX) {
+            let duration = python_strip(rest)?;
+            if parse_duration(duration)?.is_some() {
+                return Ok(None);
+            }
+            return Ok(Some(format!(
+                "{key} '{text}' has an invalid duration '{duration}'; use a positive duration \
+                 such as 14d, 12h or 1mo"
+            )));
+        }
     }
+    Ok(Some(format!(
+        "unknown {key} '{text}'; valid values: {valid}"
+    )))
 }
 
 fn check_cursor_rules<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
 ) -> Check {
     let cursor = values.cursor.as_deref();
     let cursor_type = values.cursor_type.as_deref();
     let grain = values.cursor_grain.as_deref();
+    let grains: Vec<&str> = CURSOR_GRAIN_BATCH_SIZES
+        .iter()
+        .map(|(name, _)| *name)
+        .collect();
     if cursor.is_some() && cursor_type.is_none() {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "cursor requires cursor_type (valid values: {})",
+            sorted_values(&CURSOR_TYPES)
+        )));
     }
-    if cursor_type.is_some_and(|value| !one_of(value, &CURSOR_TYPES)) {
-        return Err(Rejected);
+    if let Some(cursor_type) = cursor_type
+        && !one_of(cursor_type, &CURSOR_TYPES)
+    {
+        return Err(config.error(format!(
+            "unknown cursor_type '{cursor_type}'; valid values: {}",
+            sorted_values(&CURSOR_TYPES)
+        )));
     }
-    if grain.is_some()
-        && (cursor_type != Some(TIMESTAMP_CURSOR)
-            || !CURSOR_GRAIN_BATCH_SIZES
-                .iter()
-                .any(|(name, _)| Some(*name) == grain))
+    if grain.is_some() && cursor_type != Some(TIMESTAMP_CURSOR) {
+        return Err(config.error("cursor_grain is only valid with cursor_type=timestamp"));
+    }
+    if let Some(grain) = grain
+        && !one_of(grain, &grains)
     {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "unknown cursor_grain '{grain}'; valid values: {}",
+            sorted_values(&grains)
+        )));
     }
     if cursor.is_some() && cursor_type == Some(TIMESTAMP_CURSOR) && grain.is_none() {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "cursor_type=timestamp requires cursor_grain (valid values: {})",
+            sorted_values(&grains)
+        )));
     }
-    let bounds = [values.cursor_start.as_ref(), values.cursor_end.as_ref()];
-    if bounds.iter().any(Option::is_some) && (cursor.is_none() || cursor_type.is_none()) {
-        return Err(Rejected);
+    if let Some(start) = &values.cursor_start {
+        if cursor.is_none() {
+            return Err(config.error("cursor_start requires cursor"));
+        }
+        if cursor_type.is_none() {
+            return Err(config.error("cursor_start requires cursor_type"));
+        }
+        check_bound(config, start, cursor_type)?;
     }
-    if let Some(cursor_type) = cursor_type {
-        let keys = bounds
-            .iter()
-            .flatten()
-            .map(|bound| cursor_bound_key(*bound, cursor_type))
-            .collect::<Result<Vec<_>, _>>()?;
-        if let [start, end] = keys[..]
-            && !keys_ordered(start, end, cursor_type)
-        {
-            return Err(Rejected);
+    if let Some(end) = &values.cursor_end {
+        if cursor.is_none() {
+            return Err(config.error("cursor_end requires cursor"));
         }
+        check_bound(config, end, cursor_type)?;
     }
-    match config
-        .get("append_cursor_inclusive")
-        .map(AuthoredNode::kind)
+    if let (Some(start), Some(end), Some(cursor_type)) =
+        (&values.cursor_start, &values.cursor_end, cursor_type)
     {
-        None => Ok(()),
-        Some(NodeKind::Bool(_))
-            if values.strategy.as_deref() == Some(APPEND_STRATEGY) && cursor.is_some() =>
-        {
-            Ok(())
+        let start_key = ordering_key(config, start, cursor_type, "cursor_start")?;
+        let end_key = ordering_key(config, end, cursor_type, "cursor_end")?;
+        if !keys_ordered(start_key, end_key, cursor_type)? {
+            return Err(config.error("cursor_start must be before exclusive cursor_end"));
         }
-        Some(_) => Err(Rejected),
     }
+    check_append_cursor_inclusive(config, values)
+}
+
+fn ordering_key<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    bound: &N,
+    cursor_type: &str,
+    key: &str,
+) -> Result<i128, ValidationStop> {
+    match bound_key(bound, cursor_type)? {
+        BoundKey::Key(value) => Ok(value),
+        BoundKey::Overflow(utc_value) => {
+            let text = bound.text().ok_or(Rejected)?;
+            let help = model_header_help(
+                &format!("keep {key} within years 1-9999 in UTC"),
+                &format!("{key} '{utc_value}'"),
+            );
+            Err(ValidationStop::Error(
+                config
+                    .config_error(format!(
+                        "{key} value '{text}' falls outside years 1-9999 once converted to UTC"
+                    ))
+                    .with_help(help),
+            ))
+        }
+    }
+}
+
+fn check_append_cursor_inclusive<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    values: &IncrementalValues<N>,
+) -> Check {
+    let Some(inclusive) = config.get("append_cursor_inclusive") else {
+        return Ok(());
+    };
+    if !matches!(inclusive.kind(), NodeKind::Bool(_)) {
+        return Err(config.error("append_cursor_inclusive must be a boolean"));
+    }
+    if values.strategy.as_deref() != Some(APPEND_STRATEGY) {
+        return Err(config.error("append_cursor_inclusive is only valid with append strategy"));
+    }
+    if values.cursor.is_none() {
+        return Err(config.error("append_cursor_inclusive requires cursor"));
+    }
+    Ok(())
 }
 
 fn check_cursor_safety<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
 ) -> Check {
-    let durations = ["cursor_start_max_ahead", "cursor_future_max_distance"];
-    let actions = ["cursor_start_max_action", "cursor_future_action"];
-    if values.cursor.is_none() && (config.any_present(&durations) || config.any_present(&actions)) {
-        return Err(Rejected);
-    }
-    for key in durations {
-        if let Some(value) = config.get(key) {
-            accept_text(value, |text| {
-                Ok(text == CURSOR_POLICY_DISABLED
-                    || text == ZERO_DAY_DURATION
-                    || parse_duration(text)?.is_some())
-            })?;
+    if values.cursor.is_none()
+        && (config.first_present(&CURSOR_SAFETY_DURATION_KEYS).is_some()
+            || config.first_present(&CURSOR_SAFETY_ACTION_KEYS).is_some())
+    {
+        return Err(config.error("cursor safety overrides require cursor"));
+    }
+    for key in CURSOR_SAFETY_DURATION_KEYS {
+        if let Some(value) = config.get(key)
+            && !safety_duration_check(value)?
+        {
+            return Err(config.error(format!("{key} must be a duration or 'disabled'")));
         }
     }
-    for key in actions {
-        if let Some(value) = config.get(key) {
-            accept_text(value, |text| Ok(one_of(text, &FUTURE_CURSOR_ACTIONS)))?;
+    for key in CURSOR_SAFETY_ACTION_KEYS {
+        let Some(value) = config.get(key) else {
+            continue;
+        };
+        let valid = match value.kind() {
+            NodeKind::Str => FUTURE_CURSOR_ACTIONS
+                .iter()
+                .any(|action| value.is_text(action)),
+            NodeKind::Int { .. } | NodeKind::Bool(_) => false,
+            _ => return Err(ValidationStop::Defer),
+        };
+        if !valid {
+            return Err(config.error(format!("{key} must be one of: cap, error")));
         }
     }
     Ok(())
 }
 
+fn safety_duration_check<N: AuthoredNode>(value: &N) -> Result<bool, Rejected> {
+    if value.kind() != NodeKind::Str {
+        return Ok(false);
+    }
+    let text = value.text().ok_or(Rejected)?;
+    Ok(text == CURSOR_POLICY_DISABLED
+        || text == ZERO_DAY_DURATION
+        || parse_duration(&text)?.is_some())
+}
+
 fn check_write_strategy<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
 ) -> Check {
     let strategy = values.strategy.as_deref();
     let has_unique_key = has_config_value(values.unique_key.as_ref());
     if strategy == Some(DELETE_INSERT_STRATEGY) && values.cursor.is_none() && !has_unique_key {
-        return Err(Rejected);
+        return Err(config.error("delete_insert without cursor requires unique_key"));
     }
     if strategy == Some(MERGE_STRATEGY) && !has_unique_key {
-        return Err(Rejected);
+        return Err(config.error("merge strategy requires unique_key"));
     }
     if let Some(excluded) = &values.merge_exclude_columns {
-        let excluded = non_empty_strings(excluded)?;
+        if !is_non_empty_string_list(excluded) {
+            return Err(config.error("merge_exclude_columns must be a list of non-empty strings"));
+        }
+        let excluded = string_sequence(Some(excluded))?;
         if strategy != Some(MERGE_STRATEGY) {
-            return Err(Rejected);
+            return Err(config.error("merge_exclude_columns requires incremental_strategy=merge"));
+        }
+        let lowered = excluded
+            .iter()
+            .map(|column| python_lower(column))
+            .collect::<Result<Vec<String>, Rejected>>()?;
+        let distinct: HashSet<&String> = lowered.iter().collect();
+        if distinct.len() != lowered.len() {
+            return Err(config.error("merge_exclude_columns contains duplicate columns"));
         }
-        reject_case_insensitive_duplicates(&excluded)?;
         let unique_columns = string_sequence(values.unique_key.as_ref())?
             .iter()
             .map(|column| python_lower(column))
-            .collect::<Result<HashSet<_>, _>>()?;
-        for column in &excluded {
-            if unique_columns.contains(&python_lower(column)?) {
-                return Err(Rejected);
-            }
+            .collect::<Result<HashSet<String>, Rejected>>()?;
+        let overlap: Vec<&str> = excluded
+            .iter()
+            .zip(&lowered)
+            .filter(|(_, lower)| unique_columns.contains(*lower))
+            .map(|(column, _)| column.as_str())
+            .collect();
+        if !overlap.is_empty() {
+            return Err(config.error(format!(
+                "merge_exclude_columns cannot include unique_key column(s): {}",
+                overlap.join(", ")
+            )));
         }
     }
     match config.get("full_refresh").map(AuthoredNode::kind) {
         None | Some(NodeKind::Bool(_)) => Ok(()),
-        Some(_) => Err(Rejected),
+        Some(_) => Err(config.error("full_refresh must be a boolean")),
     }
 }
 
-fn non_empty_strings<N: AuthoredNode>(value: &N) -> Result<Vec<String>, Rejected> {
-    if !matches!(value.kind(), NodeKind::List | NodeKind::Tuple) {
-        return Err(Rejected);
-    }
-    value
-        .items()
-        .iter()
-        .map(|item| string_value(item).and_then(non_empty))
-        .collect()
-}
-
-fn non_empty(text: String) -> Result<String, Rejected> {
-    if text.is_empty() {
-        Err(Rejected)
-    } else {
-        Ok(text)
-    }
+/// Return whether a value is a list or tuple of non-empty strings, as `_validated_string_sequence`.
+fn is_non_empty_string_list<N: AuthoredNode>(value: &N) -> bool {
+    matches!(value.kind(), NodeKind::List | NodeKind::Tuple)
+        && value.items().iter().all(|item| {
+            item.kind() == NodeKind::Str && !item.with_text(str::is_empty).unwrap_or(false)
+        })
 }
 
 fn check_contract_columns<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
     let Some(declared) = contract_declared_columns(config, facts) else {
         return Ok(());
     };
-    let named = values
-        .cursor
-        .iter()
-        .cloned()
-        .chain(string_sequence(values.unique_key.as_ref())?)
-        .chain(string_sequence(values.merge_exclude_columns.as_ref())?);
-    require_declared(named, &declared)
+    if let Some(cursor) = &values.cursor {
+        require_declared(config, "cursor", std::slice::from_ref(cursor), &declared)?;
+    }
+    require_declared(
+        config,
+        "unique_key",
+        &string_sequence(values.unique_key.as_ref())?,
+        &declared,
+    )?;
+    require_declared(
+        config,
+        "merge_exclude_columns",
+        &string_sequence(values.merge_exclude_columns.as_ref())?,
+        &declared,
+    )
 }
 
 /// Return `_contract_declared_column_names` when the contract is enforced.
 pub(crate) fn contract_declared_columns<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Option<HashSet<String>> {
     if !config.equals("contract", ENFORCED_CONTRACT) {
@@ -322,14 +465,17 @@ pub(crate) fn contract_declared_columns<N: AuthoredNode>(
     Some(names)
 }
 
-/// Reject any column name the enforced contract does not declare.
-pub(crate) fn require_declared(
-    mut names: impl Iterator<Item = String>,
+/// Raise for the first of `names` the enforced contract does not declare.
+pub(crate) fn require_declared<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    key: &str,
+    names: &[String],
     declared: &HashSet<String>,
 ) -> Check {
-    if names.all(|name| declared.contains(&name)) {
-        Ok(())
-    } else {
-        Err(Rejected)
+    match names.iter().find(|name| !declared.contains(*name)) {
+        Some(name) => Err(config.error(format!(
+            "{key} references column '{name}' not declared in enforced contract"
+        ))),
+        None => Ok(()),
     }
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/materialization.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/materialization.rs
index 1af4ad3848..e76ea01eae 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/materialization.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/materialization.rs
@@ -1,59 +1,88 @@
-//! Contract, materialization, storage, migration and placeholder rules Python certainly accepts.
+//! Contract, materialization, storage, migration and placeholder rules with Python's errors.
 
 use std::collections::BTreeSet;
 
-use crate::model_validation::_helpers::config::{ConfigView, one_of, string_value};
+use crate::model_validation::_helpers::config::{
+    ConfigView, one_of, python_repr, python_str, sorted_values, text_if_string,
+};
 use crate::model_validation::_helpers::durations::parse_duration;
 use crate::model_validation::_helpers::text::{python_lower, python_strip};
 use crate::model_validation::constants::{
     BUILTIN_MATERIALIZATIONS, CONTRACT_POLICIES, CUSTOM_MATERIALIZATION_DISALLOWED_KEYS,
     HISTORY_MATERIALIZATIONS, INCREMENTAL_MATERIALIZATION, INCREMENTAL_ONLY_KEYS,
-    OLD_NAME_VIEW_KEY, PLACEHOLDER_SIGIL, TABLE_BACKED_MATERIALIZATIONS, VIEW_MATERIALIZATION,
+    MICROBATCH_CONCURRENCY_HELP, MICROBATCH_CONCURRENCY_NOTE, OLD_NAME_VIEW_KEY, PLACEHOLDER_SIGIL,
+    TABLE_BACKED_MATERIALIZATIONS, VIEW_MATERIALIZATION,
+};
+use crate::model_validation::models::{
+    ModelValidationFacts, ProjectValidationFacts, Rejected, ValidationStop,
 };
-use crate::model_validation::models::{ModelValidationFacts, ProjectValidationFacts, Rejected};
 use crate::model_validation::types::Check;
 use crate::types::{AuthoredNode, NodeKind};
 
 const MIGRATE_FROM_KEY: &str = "migrate_from";
 const MIGRATE_FORCE_KEY: &str = "migrate_force";
 
-/// Accept `validate_microbatch_project_capability`.
+/// Check `validate_microbatch_project_capability`.
 pub(crate) fn check_project_capability<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     project: &ProjectValidationFacts,
 ) -> Check {
     let Some(concurrency) = config.get("batch_concurrency") else {
         return Ok(());
     };
-    match (concurrency.kind(), concurrency.integer()) {
-        (NodeKind::Int { .. }, Some(value)) if value > 1 && !project.microbatch_concurrency => {
-            Err(Rejected)
-        }
-        (NodeKind::Int { .. }, None) => Err(Rejected),
-        _ => Ok(()),
+    let concurrent = match (concurrency.kind(), concurrency.integer()) {
+        (NodeKind::Int { negative: false }, Some(value)) => value > 1,
+        (NodeKind::Int { negative: false }, None) => true,
+        _ => false,
+    };
+    if concurrent && !project.microbatch_concurrency {
+        return Err(ValidationStop::Error(
+            config
+                .config_error(format!(
+                    "batch_concurrency > 1 requires concurrent microbatches; \
+                     {MICROBATCH_CONCURRENCY_NOTE}"
+                ))
+                .with_help(MICROBATCH_CONCURRENCY_HELP),
+        ));
     }
+    Ok(())
 }
 
-/// Accept `validate_contract_config` and `validate_non_incremental_config`.
-pub(crate) fn check_contract_and_incremental_keys<N: AuthoredNode>(
-    config: &ConfigView<N>,
-) -> Check {
-    if let Some(contract) = config.get("contract")
-        && !one_of(&string_value(contract)?, &CONTRACT_POLICIES)
-    {
-        return Err(Rejected);
+/// Check `validate_contract_config`.
+pub(crate) fn check_contract<N: AuthoredNode>(config: &ConfigView<'_, N>) -> Check {
+    let Some(contract) = config.get("contract") else {
+        return Ok(());
+    };
+    if contract.kind() != NodeKind::Str {
+        return Err(config.error("contract must be a string"));
     }
-    if config.string("materialized")?.as_deref() != Some(INCREMENTAL_MATERIALIZATION)
-        && config.any_present(&INCREMENTAL_ONLY_KEYS)
+    if CONTRACT_POLICIES
+        .iter()
+        .any(|policy| contract.is_text(policy))
     {
-        return Err(Rejected);
+        return Ok(());
+    }
+    let contract = contract.text().ok_or(Rejected)?;
+    Err(config.error(format!(
+        "unknown contract '{contract}'; valid values: {}",
+        sorted_values(&CONTRACT_POLICIES)
+    )))
+}
+
+/// Check `validate_non_incremental_config`.
+pub(crate) fn check_non_incremental<N: AuthoredNode>(config: &ConfigView<'_, N>) -> Check {
+    if config.string("materialized")?.as_deref() == Some(INCREMENTAL_MATERIALIZATION) {
+        return Ok(());
+    }
+    match config.first_present(&INCREMENTAL_ONLY_KEYS) {
+        Some(key) => Err(config.error(format!("{key} is only valid for incremental models"))),
+        None => Ok(()),
     }
-    Ok(())
 }
 
-/// Accept `validate_custom_materialization_config`.
+/// Check `validate_custom_materialization_config`.
 pub(crate) fn check_custom_materialization<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     project: &ProjectValidationFacts,
 ) -> Check {
     let Some(materialized) = config.string("materialized")? else {
@@ -62,72 +91,129 @@ pub(crate) fn check_custom_materialization<N: AuthoredNode>(
     if one_of(&materialized, &BUILTIN_MATERIALIZATIONS) {
         return Ok(());
     }
-    if !project.custom_materializations.contains(&materialized)
-        || config.any_present(&CUSTOM_MATERIALIZATION_DISALLOWED_KEYS)
-    {
-        return Err(Rejected);
+    if !project.custom_materializations.contains(&materialized) {
+        return Err(config.error(format!(
+            "unknown materialization '{materialized}'; not a built-in type and no custom \
+             materialization with that name was discovered"
+        )));
+    }
+    match config.first_present(&CUSTOM_MATERIALIZATION_DISALLOWED_KEYS) {
+        Some(key) => Err(config.error(format!("{key} is not allowed on custom materializations"))),
+        None => Ok(()),
     }
-    Ok(())
 }
 
-/// Accept `validate_storage_policies`.
+/// Check `validate_storage_policies`.
 pub(crate) fn check_storage_policies<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
-    if facts.retention_unmanaged && !facts.table_type_declared {
-        return Ok(());
-    }
     let materialized = config.string("materialized")?;
-    match materialized.as_deref() {
-        Some(VIEW_MATERIALIZATION) | None => Err(Rejected),
-        Some(value) if one_of(value, &TABLE_BACKED_MATERIALIZATIONS) => Ok(()),
-        Some(_) => Err(Rejected),
+    let materialized = materialized.as_deref();
+    let shown = materialized.unwrap_or("None");
+    let table_backed =
+        materialized.is_some_and(|value| one_of(value, &TABLE_BACKED_MATERIALIZATIONS));
+    if !facts.retention_unmanaged {
+        if materialized == Some(VIEW_MATERIALIZATION) {
+            return Err(config.error(
+                "managed time_travel_retention is not valid for views; set \
+                 time_travel_retention disabled",
+            ));
+        }
+        if !table_backed {
+            return Err(config.error(format!(
+                "managed time_travel_retention is not supported for materialization '{shown}'"
+            )));
+        }
+    }
+    if facts.table_type_declared {
+        if materialized == Some(VIEW_MATERIALIZATION) {
+            return Err(config.error("table_type is not valid for views"));
+        }
+        if !table_backed {
+            return Err(config.error(format!(
+                "table_type is not supported for materialization '{shown}'"
+            )));
+        }
     }
+    Ok(())
 }
 
-/// Accept `validate_model_migration_config`.
+/// Check `validate_model_migration_config`.
 pub(crate) fn check_migration<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
-    if config.contains_key(OLD_NAME_VIEW_KEY) {
-        let value = config.get(OLD_NAME_VIEW_KEY).ok_or(Rejected)?;
-        if value.kind() != NodeKind::Bool(false) {
-            let text = string_value(value)?;
-            if parse_duration(python_strip(&text)?)?.is_none() {
-                return Err(Rejected);
-            }
-        }
-    }
+    check_old_name_view(config)?;
     let migrate_from = config.get(MIGRATE_FROM_KEY);
     let migrate_force = config.get(MIGRATE_FORCE_KEY);
     if migrate_from.is_none() && migrate_force.is_none() {
         return Ok(());
     }
-    let materialized = config.string("materialized")?.ok_or(Rejected)?;
-    if !one_of(&materialized, &TABLE_BACKED_MATERIALIZATIONS)
-        && materialized != VIEW_MATERIALIZATION
-    {
-        return Err(Rejected);
+    let materialized = config.string("materialized")?;
+    let migratable = materialized.as_deref().is_some_and(|value| {
+        value == VIEW_MATERIALIZATION || one_of(value, &TABLE_BACKED_MATERIALIZATIONS)
+    });
+    if !migratable {
+        return Err(config
+            .error("migrate_from is only valid for table, view, incremental and snapshot models"));
     }
+    let materialized = materialized.unwrap_or_default();
     if migrate_force.is_some() && !one_of(&materialized, &HISTORY_MATERIALIZATIONS) {
-        return Err(Rejected);
+        return Err(ValidationStop::Error(
+            config
+                .config_error(format!(
+                    "migrate_force is only valid for incremental and snapshot models; nothing is \
+                     replaced when a '{materialized}' model migrates, because tables and views \
+                     are rebuilt under their new name"
+                ))
+                .with_help("remove migrate_force from the model header"),
+        ));
+    }
+    let Some(migrate_from) = migrate_from else {
+        return Err(config.error("migrate_force requires migrate_from"));
+    };
+    let origin = match text_if_string(migrate_from)? {
+        Some(text) => python_strip(&text)?.to_owned(),
+        None => String::new(),
+    };
+    if origin.is_empty() {
+        return Err(config.error("migrate_from must be a model name or a qualified relation"));
     }
-    let origin = string_value(migrate_from.ok_or(Rejected)?)?;
-    let origin = python_strip(&origin)?;
-    if origin.is_empty() || python_lower(origin)? == python_lower(facts.model_name)? {
-        return Err(Rejected);
+    if python_lower(&origin)? == python_lower(facts.model_name)? {
+        return Err(config.error("migrate_from cannot name the model itself"));
     }
     match migrate_force.map(AuthoredNode::kind) {
         None | Some(NodeKind::Bool(_)) => Ok(()),
-        Some(_) => Err(Rejected),
+        Some(_) => Err(config.error("migrate_force must be true or false")),
+    }
+}
+
+fn check_old_name_view<N: AuthoredNode>(config: &ConfigView<'_, N>) -> Check {
+    let Some(value) = config.raw(OLD_NAME_VIEW_KEY) else {
+        return Ok(());
+    };
+    if value.kind() == NodeKind::Bool(false) {
+        return Ok(());
+    }
+    if let Some(text) = text_if_string(value)?
+        && parse_duration(python_strip(&text)?)?.is_some()
+    {
+        return Ok(());
     }
+    let shown = python_repr(value)?;
+    Err(ValidationStop::Error(
+        config
+            .config_error(format!(
+                "old_name_view must be a positive duration such as 7d, or false; got {shown}"
+            ))
+            .with_help("write for example old_name_view 7d, or old_name_view false"),
+    ))
 }
 
-/// Accept `validate_placeholder_config`.
+/// Check `validate_placeholder_config`.
 pub(crate) fn check_placeholders<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     project: &ProjectValidationFacts,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
@@ -137,26 +223,44 @@ pub(crate) fn check_placeholders<N: AuthoredNode>(
         .is_some_and(|value| project.custom_materializations.contains(value));
     let used = placeholder_names(facts.query_sql)?;
     let declared = config.get("placeholders");
-    if !custom {
-        return if used.is_empty() && declared.is_none() {
-            Ok(())
-        } else {
-            Err(Rejected)
-        };
+    if !custom && !used.is_empty() {
+        return Err(config.error("@@@placeholders are only allowed on custom materializations"));
+    }
+    if !custom && declared.is_some() {
+        return Err(config.error("placeholders config is only allowed on custom materializations"));
+    }
+    if !custom || (used.is_empty() && declared.is_none()) {
+        return Ok(());
     }
     let declared_names = match declared {
         Some(value) if value.kind() == NodeKind::Map => value
             .entries()
             .iter()
-            .map(|(key, _)| string_value(key))
-            .collect::<Result<BTreeSet<_>, _>>()?,
+            .map(|(key, _)| python_str(key))
+            .collect::<Result<BTreeSet<String>, Rejected>>()?,
         _ => BTreeSet::new(),
     };
-    if declared_names == used {
-        Ok(())
-    } else {
-        Err(Rejected)
+    let missing: Vec<&str> = used
+        .difference(&declared_names)
+        .map(String::as_str)
+        .collect();
+    if !missing.is_empty() {
+        return Err(config.error(format!(
+            "@@@placeholders without default values in placeholders config: {}",
+            missing.join(", ")
+        )));
+    }
+    let unused: Vec<&str> = declared_names
+        .difference(&used)
+        .map(String::as_str)
+        .collect();
+    if !unused.is_empty() {
+        return Err(config.error(format!(
+            "placeholders config entries not used in SQL: {}",
+            unused.join(", ")
+        )));
     }
+    Ok(())
 }
 
 /// Return the names `re.findall(r"@@@(\w+)", sql)` finds, rejecting non-ASCII word candidates.
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/microbatch.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/microbatch.rs
index 5606179318..9537395733 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/microbatch.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/microbatch.rs
@@ -1,9 +1,9 @@
-//! `_validate_incremental_batching` for configs Python certainly accepts.
+//! `_validate_incremental_batching`, raising the first error the Python validator raises.
 
 use std::collections::HashSet;
 
 use crate::model_validation::_helpers::config::{
-    ConfigView, non_blank_string, one_of, optional_one_of, string_value,
+    ConfigView, non_blank_string_check, one_of, python_str, sorted_values,
 };
 use crate::model_validation::_helpers::durations::parse_duration;
 use crate::model_validation::_helpers::incremental::IncrementalValues;
@@ -14,92 +14,134 @@ use crate::model_validation::constants::{
     ROLLING_WINDOW_STRATEGY, TIMESTAMP_CURSOR, UNACCOUNTED_PARTITION_POLICIES,
     WATERMARK_BLOCK_KEYS, WATERMARK_MODES, WATERMARK_ROLE, WATERMARK_STRATEGY,
 };
-use crate::model_validation::models::{ModelValidationFacts, Rejected};
+use crate::model_validation::models::{ModelValidationFacts, Rejected, ValidationStop};
 use crate::model_validation::types::Check;
 use crate::types::{AuthoredNode, NodeKind};
 
-/// Accept the batching, microbatch and cursor input rules.
+const COLUMN_KEY: &str = "column";
+const ROLES_KEY: &str = "roles";
+
+/// Check the batching, microbatch and cursor input rules.
 pub(crate) fn check_incremental_batching<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
-    config: &ConfigView<N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
     let mode = values.incremental_mode.as_deref();
-    if mode.is_some_and(|value| !one_of(value, &INCREMENTAL_MODES)) {
-        return Err(Rejected);
+    if let Some(mode) = mode
+        && !one_of(mode, &INCREMENTAL_MODES)
+    {
+        return Err(config.error(format!(
+            "unknown incremental_mode '{mode}'; valid values: {}",
+            sorted_values(&INCREMENTAL_MODES)
+        )));
     }
     let microbatch = mode == Some(MICROBATCH_MODE);
     if let Some(batch_size) = values.batch_size.as_deref() {
         if !microbatch {
-            return Err(Rejected);
+            return Err(config.error("batch_size is only valid with incremental_mode=microbatch"));
         }
         if batch_size == EFFECTIVE_BATCH_SIZE
             && (values.cursor.is_none()
                 || values.cursor_type.as_deref() != Some(TIMESTAMP_CURSOR)
                 || values.cursor_grain.is_none())
         {
-            return Err(Rejected);
+            return Err(
+                config.error("batch_size=effective requires a timestamp cursor with cursor_grain")
+            );
         }
     }
-    check_state_config(values, config, microbatch)?;
-    if config.any_present(&REMOVED_CURSOR_INPUT_KEYS) {
-        return Err(Rejected);
-    }
-    check_cursor_inputs(values, facts)?;
-    if let Some(limit) = microbatch_limit(values)? {
-        check_static_watermark_limit(values, limit)?;
+    check_state_config(config, values, microbatch)?;
+    check_cursor_inputs(config, values, facts)?;
+    if let Some(limit) = microbatch_limit(config, values)? {
+        check_static_watermark_limit(config, values, &limit)?;
     }
     Ok(())
 }
 
 fn check_state_config<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
-    config: &ConfigView<N>,
     microbatch: bool,
 ) -> Check {
     if let Some(concurrency) = config.get("batch_concurrency") {
-        let concurrency = concurrency.integer().ok_or(Rejected)?;
-        if concurrency <= 0
-            || (concurrency > 1
-                && (!microbatch || values.strategy.as_deref() != Some(DELETE_INSERT_STRATEGY)))
-        {
-            return Err(Rejected);
+        let concurrent = match (concurrency.kind(), concurrency.integer()) {
+            (NodeKind::Int { negative: false }, Some(value)) if value > 0 => value > 1,
+            (NodeKind::Int { negative: false }, None) => true,
+            _ => return Err(config.error("batch_concurrency must be a positive integer")),
+        };
+        if concurrent && !microbatch {
+            return Err(config.error("batch_concurrency > 1 requires incremental_mode=microbatch"));
+        }
+        if concurrent && values.strategy.as_deref() != Some(DELETE_INSERT_STRATEGY) {
+            return Err(
+                config.error("batch_concurrency > 1 requires incremental_strategy=delete_insert")
+            );
         }
     }
-    if let Some(policy) = config.get("unaccounted_partition_policy")
-        && (!one_of(&string_value(policy)?, &UNACCOUNTED_PARTITION_POLICIES) || !microbatch)
-    {
-        return Err(Rejected);
+    if let Some(policy) = config.get("unaccounted_partition_policy") {
+        if !UNACCOUNTED_PARTITION_POLICIES
+            .iter()
+            .any(|valid| policy.is_text(valid))
+        {
+            return Err(config.error(format!(
+                "unaccounted_partition_policy must be one of: {}",
+                sorted_values(&UNACCOUNTED_PARTITION_POLICIES)
+            )));
+        }
+        if !microbatch {
+            return Err(
+                config.error("unaccounted_partition_policy requires incremental_mode=microbatch")
+            );
+        }
     }
     Ok(())
 }
 
 fn check_cursor_inputs<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
+    if let Some(key) = config.first_present(&REMOVED_CURSOR_INPUT_KEYS) {
+        return Err(config.error(format!(
+            "{key} has been removed; declare microbatch_strategy and use strategy-specific \
+             cursor_inputs"
+        )));
+    }
     let microbatch = values.incremental_mode.as_deref() == Some(MICROBATCH_MODE);
     let strategy = values.microbatch_strategy.as_deref();
     let reference_count = facts.references.len();
-    if strategy.is_some() != microbatch
-        || strategy.is_some_and(|value| !one_of(value, &MICROBATCH_STRATEGIES))
-    {
-        return Err(Rejected);
+    if strategy.is_some() && !microbatch {
+        return Err(
+            config.error("microbatch_strategy is only valid with incremental_mode=microbatch")
+        );
     }
-    if strategy == Some(ROLLING_WINDOW_STRATEGY)
-        && values.cursor_type.as_deref() != Some(TIMESTAMP_CURSOR)
+    if microbatch && strategy.is_none() {
+        return Err(config.error(
+            "incremental_mode=microbatch requires explicit microbatch_strategy \
+             (rolling_window or watermark)",
+        ));
+    }
+    if let Some(strategy) = strategy
+        && !one_of(strategy, &MICROBATCH_STRATEGIES)
     {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "unknown microbatch_strategy '{strategy}'; valid values: {}",
+            sorted_values(&MICROBATCH_STRATEGIES)
+        )));
+    }
+    let watermark = strategy == Some(WATERMARK_STRATEGY);
+    let rolling_window = strategy == Some(ROLLING_WINDOW_STRATEGY);
+    if rolling_window && values.cursor_type.as_deref() != Some(TIMESTAMP_CURSOR) {
+        return Err(config.error("rolling_window requires cursor_type=timestamp"));
     }
     let inputs = values.cursor_inputs.as_ref();
     if inputs.is_some() && values.cursor.is_none() {
-        return Err(Rejected);
+        return Err(config.error("cursor_inputs requires cursor"));
     }
-    if inputs.is_none()
-        && (strategy == Some(WATERMARK_STRATEGY)
-            || (strategy == Some(ROLLING_WINDOW_STRATEGY) && reference_count > 0))
-    {
-        return Err(Rejected);
+    if inputs.is_none() && (watermark || (rolling_window && reference_count > 0)) {
+        return Err(config.error("microbatch strategy requires cursor_inputs"));
     }
     let input_names: HashSet<&str> = facts
         .references
@@ -107,147 +149,249 @@ fn check_cursor_inputs<N: AuthoredNode>(
         .map(|reference| reference.name.as_str())
         .collect();
     if let Some(inputs) = inputs {
-        if strategy == Some(WATERMARK_STRATEGY) {
-            check_watermark_inputs(inputs, &input_names)?;
+        if watermark {
+            check_watermark_inputs(config, inputs, &input_names)?;
         } else {
-            check_input_map(inputs, &input_names)?;
+            check_input_map(config, inputs, &input_names)?;
         }
     }
     let watermark_mode = values.cursor_watermark_mode.as_deref();
-    if (strategy == Some(WATERMARK_STRATEGY) && !optional_one_of(watermark_mode, &WATERMARK_MODES))
-        || (strategy != Some(WATERMARK_STRATEGY) && watermark_mode.is_some())
-    {
-        return Err(Rejected);
+    if watermark && !watermark_mode.is_some_and(|mode| one_of(mode, &WATERMARK_MODES)) {
+        return Err(config.error("watermark strategy requires cursor_watermark_mode all or any"));
     }
-    if let Some(limit) = &values.max_microbatches
-        && (limit.integer().is_none_or(|value| value < 1) || strategy != Some(WATERMARK_STRATEGY))
-    {
-        return Err(Rejected);
+    if !watermark && watermark_mode.is_some() {
+        return Err(
+            config.error("cursor_watermark_mode is only valid with microbatch_strategy=watermark")
+        );
+    }
+    if let Some(limit) = &values.max_microbatches {
+        if !is_positive_integer(limit) {
+            return Err(config.error("max_microbatches must be a positive integer"));
+        }
+        if !watermark {
+            return Err(
+                config.error("max_microbatches is only valid with microbatch_strategy=watermark")
+            );
+        }
     }
     if values.cursor.is_some() && reference_count > 1 && inputs.is_none() {
-        return Err(Rejected);
+        return Err(
+            config.error("models with cursor and multiple inputs require explicit cursor_inputs")
+        );
     }
     Ok(())
 }
 
-fn check_input_map<N: AuthoredNode>(inputs: &N, input_names: &HashSet<&str>) -> Check {
-    let entries = map_entries(inputs)?;
+fn is_positive_integer<N: AuthoredNode>(value: &N) -> bool {
+    match (value.kind(), value.integer()) {
+        (NodeKind::Int { negative: false }, Some(number)) => number >= 1,
+        (NodeKind::Int { negative: false }, None) => true,
+        _ => false,
+    }
+}
+
+fn expected_inputs(input_names: &HashSet<&str>) -> String {
+    let mut names: Vec<&str> = input_names.iter().copied().collect();
+    names.sort_unstable();
+    names.join(", ")
+}
+
+fn check_input_map<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    inputs: &N,
+    input_names: &HashSet<&str>,
+) -> Check {
+    if inputs.kind() != NodeKind::Map {
+        return Err(config.error("cursor_inputs must be a relation map"));
+    }
+    let entries = inputs.entries();
     if entries.is_empty() {
-        return Err(Rejected);
+        return Err(config.error("cursor_inputs must not be empty"));
     }
     for (relation, column) in &entries {
-        let relation = non_blank_string(relation)?;
-        non_blank_string(column)?;
+        if !non_blank_string_check(relation)? {
+            return Err(config.error("cursor_inputs relation names must be non-empty strings"));
+        }
+        if !non_blank_string_check(column)? {
+            let relation = relation.text().ok_or(Rejected)?;
+            return Err(config.error(format!(
+                "cursor_inputs column for relation '{relation}' must be a non-empty string"
+            )));
+        }
+    }
+    for (relation, _) in &entries {
+        let relation = relation.text().ok_or(Rejected)?;
         if !input_names.contains(relation.as_str()) {
-            return Err(Rejected);
+            return Err(config.error(format!(
+                "cursor_inputs references unknown input '{relation}'; expected one of: {}",
+                expected_inputs(input_names)
+            )));
         }
     }
     Ok(())
 }
 
-fn check_watermark_inputs<N: AuthoredNode>(inputs: &N, input_names: &HashSet<&str>) -> Check {
-    let entries = map_entries(inputs)?;
-    if entries.is_empty() {
-        return Err(Rejected);
+fn check_watermark_inputs<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    inputs: &N,
+    input_names: &HashSet<&str>,
+) -> Check {
+    let entries = inputs.entries();
+    if inputs.kind() != NodeKind::Map || entries.is_empty() {
+        return Err(config.error("watermark cursor_inputs must be a non-empty relation map"));
     }
     let mut has_watermark = false;
     for (relation, block) in &entries {
-        let relation = non_blank_string(relation)?;
-        let block = keyed_entries(block, &WATERMARK_BLOCK_KEYS)?;
-        non_blank_string(&block[0])?;
-        let roles = &block[1];
-        if roles.kind() != NodeKind::List {
-            return Err(Rejected);
+        if !non_blank_string_check(relation)? || block.kind() != NodeKind::Map {
+            let relation = python_str(relation)?;
+            return Err(config.error(format!(
+                "watermark cursor_inputs relation '{relation}' must use \
+                 (column ..., roles [...])"
+            )));
         }
-        let roles = roles
-            .items()
-            .iter()
-            .map(string_value)
-            .collect::<Result<Vec<_>, _>>()?;
-        let distinct: HashSet<&String> = roles.iter().collect();
-        if roles.is_empty()
-            || roles.iter().any(|role| !one_of(role, &CURSOR_INPUT_ROLES))
-            || distinct.len() != roles.len()
-        {
-            return Err(Rejected);
+        let relation = relation.text().ok_or(Rejected)?;
+        let block = block.entries();
+        if !has_exact_keys(&block, &WATERMARK_BLOCK_KEYS) {
+            return Err(config.error(format!(
+                "cursor_inputs relation '{relation}' requires exactly column and roles"
+            )));
         }
-        has_watermark |= roles.iter().any(|role| role == WATERMARK_ROLE);
-        if roles.iter().any(|role| role == FILTER_ROLE) && !input_names.contains(relation.as_str())
-        {
-            return Err(Rejected);
+        let column = block_value(&block, COLUMN_KEY).ok_or(Rejected)?;
+        if !non_blank_string_check(column)? {
+            return Err(config.error(format!(
+                "cursor_inputs column for relation '{relation}' must be a non-empty string"
+            )));
+        }
+        let roles = block_value(&block, ROLES_KEY).ok_or(Rejected)?;
+        let Some(roles) = valid_roles(roles)? else {
+            return Err(config.error(format!(
+                "cursor_inputs roles for relation '{relation}' must be a non-empty list \
+                 containing only filter and/or watermark"
+            )));
+        };
+        let distinct: HashSet<&&str> = roles.iter().collect();
+        if distinct.len() != roles.len() {
+            return Err(config.error(format!(
+                "cursor_inputs relation '{relation}' contains duplicate roles"
+            )));
+        }
+        has_watermark |= roles.contains(&WATERMARK_ROLE);
+        if roles.contains(&FILTER_ROLE) && !input_names.contains(relation.as_str()) {
+            return Err(config.error(format!(
+                "filter role references input '{relation}' that is not directly filterable; \
+                 expected one of: {}",
+                expected_inputs(input_names)
+            )));
         }
     }
-    if has_watermark { Ok(()) } else { Err(Rejected) }
-}
-
-fn map_entries<N: AuthoredNode>(value: &N) -> Result<Vec<(N, N)>, Rejected> {
-    if value.kind() == NodeKind::Map {
-        Ok(value.entries())
+    if has_watermark {
+        Ok(())
     } else {
-        Err(Rejected)
+        Err(config.error("watermark strategy requires at least one watermark role"))
     }
 }
 
-/// Return a mapping's values in `keys` order when its keys are exactly `keys`.
-fn keyed_entries<N: AuthoredNode>(value: &N, keys: &[&str]) -> Result<Vec<N>, Rejected> {
-    let entries = map_entries(value)?;
-    if entries.len() != keys.len() {
-        return Err(Rejected);
+/// Return whether a mapping's keys are exactly the strings `keys`, as `set(mapping) == keys`.
+fn has_exact_keys<N: AuthoredNode>(block: &[(N, N)], keys: &[&str]) -> bool {
+    if block.len() != keys.len() {
+        return false;
+    }
+    for key in keys {
+        if block_value(block, key).is_none() {
+            return false;
+        }
     }
-    keys.iter().map(|key| entry_value(&entries, key)).collect()
+    true
 }
 
-fn entry_value<N: AuthoredNode>(entries: &[(N, N)], key: &str) -> Result<N, Rejected> {
-    for (name, item) in entries {
-        if name.kind() == NodeKind::Str && name.is_text(key) {
-            return Ok(item.clone());
+fn block_value<'b, N: AuthoredNode>(block: &'b [(N, N)], key: &str) -> Option<&'b N> {
+    block
+        .iter()
+        .find(|(name, _)| name.is_text(key))
+        .map(|(_, value)| value)
+}
+
+/// Return a non-empty list of valid roles, `None` when Python rejects it, or defer.
+fn valid_roles<N: AuthoredNode>(roles: &N) -> Result<Option<Vec<&'static str>>, Rejected> {
+    if roles.kind() != NodeKind::List {
+        return Ok(None);
+    }
+    let items = roles.items();
+    if items.is_empty() {
+        return Ok(None);
+    }
+    let mut valid: Vec<&'static str> = Vec::with_capacity(items.len());
+    for item in &items {
+        match item.kind() {
+            NodeKind::Str => match CURSOR_INPUT_ROLES.iter().find(|role| item.is_text(role)) {
+                Some(role) => valid.push(role),
+                None => return Ok(None),
+            },
+            NodeKind::Int { .. } | NodeKind::Bool(_) | NodeKind::Null => return Ok(None),
+            _ => return Err(Rejected),
         }
     }
-    Err(Rejected)
+    Ok(Some(valid))
 }
 
 /// The resolved batch limit and its action, as `_validate_model_microbatch_limit` returns them.
 struct MicrobatchLimit {
-    max_batches: i64,
+    /// The limit, or `None` for an integer too large to fall short of any requirement.
+    max_batches: Option<i64>,
     cap_from_start: bool,
 }
 
 fn microbatch_limit<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
-) -> Result<Option<MicrobatchLimit>, Rejected> {
+) -> Result<Option<MicrobatchLimit>, ValidationStop> {
     let Some(limit) = &values.microbatch_limit else {
         return Ok(values
             .max_microbatches
             .as_ref()
-            .and_then(AuthoredNode::integer)
-            .map(|max_batches| MicrobatchLimit {
-                max_batches,
+            .filter(|limit| matches!(limit.kind(), NodeKind::Int { .. }))
+            .map(|limit| MicrobatchLimit {
+                max_batches: limit.integer(),
                 cap_from_start: false,
             }));
     };
     if values.max_microbatches.is_some() {
-        return Err(Rejected);
-    }
-    let block = keyed_entries(limit, &MICROBATCH_LIMIT_KEYS)?;
-    let max_batches = block[0]
-        .integer()
-        .filter(|value| *value >= 1)
-        .ok_or(Rejected)?;
-    let action = string_value(&block[1])?;
-    if !one_of(&action, &MICROBATCH_LIMIT_ACTIONS)
-        || values.microbatch_strategy.as_deref() != Some(WATERMARK_STRATEGY)
-    {
-        return Err(Rejected);
+        return Err(config.error("use either max_microbatches or microbatch_limit, not both"));
+    }
+    let block = limit.entries();
+    if limit.kind() != NodeKind::Map || !has_exact_keys(&block, &MICROBATCH_LIMIT_KEYS) {
+        return Err(config.error("microbatch_limit requires exactly max_batches and action"));
+    }
+    let [max_key, action_key] = MICROBATCH_LIMIT_KEYS;
+    let max_batches = block_value(&block, max_key).ok_or(Rejected)?;
+    if !is_positive_integer(max_batches) {
+        return Err(config.error("microbatch_limit max_batches must be a positive integer"));
+    }
+    let action = block_value(&block, action_key).ok_or(Rejected)?;
+    let Some(action) = MICROBATCH_LIMIT_ACTIONS
+        .iter()
+        .find(|valid| action.is_text(valid))
+    else {
+        return Err(config.error(format!(
+            "microbatch_limit action must be one of: {}",
+            sorted_values(&MICROBATCH_LIMIT_ACTIONS)
+        )));
+    };
+    if values.microbatch_strategy.as_deref() != Some(WATERMARK_STRATEGY) {
+        return Err(
+            config.error("microbatch_limit is only valid with microbatch_strategy=watermark")
+        );
     }
     Ok(Some(MicrobatchLimit {
-        max_batches,
-        cap_from_start: action == CAP_FROM_START_ACTION,
+        max_batches: max_batches.integer(),
+        cap_from_start: *action == CAP_FROM_START_ACTION,
     }))
 }
 
 fn check_static_watermark_limit<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
     values: &IncrementalValues<N>,
-    limit: MicrobatchLimit,
+    limit: &MicrobatchLimit,
 ) -> Check {
     let batch_size = values.effective_batch_size();
     let rewrites_lookback = limit.cap_from_start
@@ -277,14 +421,23 @@ fn check_static_watermark_limit<N: AuthoredNode>(
         }
         lookback.total_months.div_ceil(batch.total_months)
     } else if limit.cap_from_start {
-        return Err(Rejected);
+        return Err(config.error(
+            "cap_from_start cannot prove forward progress when lookback and batch_size mix \
+             calendar and fixed duration components; use compatible fixed or calendar durations",
+        ));
     } else {
         return Ok(());
     };
     let required = lookback_batches + 1 + u128::from(limit.cap_from_start);
-    let max_batches = u128::try_from(limit.max_batches).map_err(|_| Rejected)?;
-    if max_batches < required {
-        Err(Rejected)
+    let Some(max_batches) = limit.max_batches else {
+        return Ok(());
+    };
+    let max = u128::try_from(max_batches).map_err(|_| Rejected)?;
+    if max < required {
+        Err(config.error(format!(
+            "max_microbatches {max_batches} is below the ordinary lookback requirement of \
+             {required} batches"
+        )))
     } else {
         Ok(())
     }
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/references.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/references.rs
index 5bc4380f87..bb8967c152 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/references.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/references.rs
@@ -1,32 +1,71 @@
-//! `validate_model_references` for references every discovered name resolves.
+//! `validate_model_references`, raising the error Python raises for the first bad reference.
 
+use crate::errors::ConfigError;
 use crate::model_validation::constants::{
     REF_KIND, SEED_KIND, SOURCE_KIND, TABLE_FUNCTION_KIND, UDF_KIND,
 };
-use crate::model_validation::models::{ModelReference, ProjectValidationFacts, Rejected};
+use crate::model_validation::models::{
+    ModelReference, ModelValidationFacts, ProjectValidationFacts, ValidationStop,
+};
 use crate::model_validation::types::Check;
 
-/// Accept references that name discovered resources of their own kind.
+/// Check each reference in order; external dbt references and unknown kinds defer to Python.
 pub(crate) fn check_references(
-    references: &[ModelReference],
+    facts: &ModelValidationFacts<'_>,
     project: &ProjectValidationFacts,
 ) -> Check {
-    let resolves = |reference: &ModelReference| {
-        let name = &reference.name;
-        match reference.kind.as_str() {
-            REF_KIND => project.models.contains(name),
-            SEED_KIND => project.seeds.contains(name),
-            SOURCE_KIND => project.sources.contains(name),
-            UDF_KIND => project.functions.contains(name) && !project.table_functions.contains(name),
-            TABLE_FUNCTION_KIND => {
-                project.functions.contains(name) && project.table_functions.contains(name)
-            }
-            _ => false,
+    for reference in facts.references {
+        if let Some(problem) = reference_problem(reference, project)? {
+            return Err(ValidationStop::Error(ConfigError::compile(format!(
+                "Model file {} {problem}",
+                facts.relative_path
+            ))));
         }
-    };
-    if references.iter().all(resolves) {
-        Ok(())
-    } else {
-        Err(Rejected)
     }
+    Ok(())
+}
+
+fn reference_problem(
+    reference: &ModelReference,
+    project: &ProjectValidationFacts,
+) -> Result<Option<String>, ValidationStop> {
+    let name = &reference.name;
+    let model = project.models.contains(name);
+    let seed = project.seeds.contains(name);
+    let function = project.functions.contains(name);
+    let table_function = project.table_functions.contains(name);
+    Ok(match reference.kind.as_str() {
+        REF_KIND if !model && seed => Some(format!(
+            "references seed '{name}' with __ref(...). Use {} for seed references; __ref only \
+             resolves models.",
+            example_call("__seed", name)
+        )),
+        REF_KIND if !model => Some(format!("references unknown model '{name}'")),
+        SEED_KIND if !seed && model => Some(format!(
+            "references model '{name}' with __seed(...). Use {} for model references.",
+            example_call("__ref", name)
+        )),
+        SEED_KIND if !seed => Some(format!("references unknown seed '{name}'")),
+        SOURCE_KIND if !project.sources.contains(name) => {
+            Some(format!("references unknown source '{name}'"))
+        }
+        UDF_KIND if !function => Some(format!("references unknown SQL function '{name}'")),
+        UDF_KIND if table_function => Some(format!(
+            "references table function '{name}' with __udf(); use __table_fn() in SQL contexts \
+             that support table-valued functions"
+        )),
+        TABLE_FUNCTION_KIND if !function => {
+            Some(format!("references unknown table function '{name}'"))
+        }
+        TABLE_FUNCTION_KIND if !table_function => Some(format!(
+            "references scalar function '{name}' with __table_fn(); use __udf() for scalar UDFs"
+        )),
+        REF_KIND | SEED_KIND | SOURCE_KIND | UDF_KIND | TABLE_FUNCTION_KIND => None,
+        _ => return Err(ValidationStop::Defer),
+    })
+}
+
+/// Return `SqlReferenceKind.example_call(name, quote='"')`.
+fn example_call(function: &str, name: &str) -> String {
+    format!("{function}(\"{}\")", name.replace('"', "\"\""))
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/snapshot.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/snapshot.rs
index 555298802b..6c5c302bc2 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/snapshot.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/snapshot.rs
@@ -1,104 +1,248 @@
-//! `validate_snapshot_config` for configs Python certainly accepts.
+//! `validate_snapshot_config`, raising the first error the Python validator raises.
 
 use crate::model_validation::_helpers::config::{
-    ConfigView, has_config_value, one_of, string_sequence,
+    ConfigView, has_config_value, one_of, same_lowered, sorted_values, string_sequence,
 };
 use crate::model_validation::_helpers::incremental::{contract_declared_columns, require_declared};
-use crate::model_validation::_helpers::text::python_lower;
 use crate::model_validation::constants::{
     APPEND_NEW_COLUMNS_POLICY, CHANGES_HISTORICAL_INPUT, CHECK_SNAPSHOT_STRATEGY,
-    ENFORCED_CONTRACT, HISTORICAL_INPUTS, INITIAL_VALID_FROM_VALUES, SNAPSHOT_DISALLOWED_KEYS,
-    SNAPSHOT_FULL_REFRESH_POLICIES, SNAPSHOT_MATERIALIZATION, SNAPSHOT_SCHEMA_CHANGE_POLICIES,
-    SNAPSHOT_STRATEGIES, SQL_WILDCARD, TIMESTAMP_SNAPSHOT_STRATEGY,
+    CONTRACT_SCHEMA_CHANGE_CODE, ENFORCED_CONTRACT, HISTORICAL_INPUTS, INITIAL_VALID_FROM_VALUES,
+    SNAPSHOT_DISALLOWED_KEYS, SNAPSHOT_FULL_REFRESH_POLICIES, SNAPSHOT_MATERIALIZATION,
+    SNAPSHOT_SCHEMA_CHANGE_POLICIES, SNAPSHOT_STRATEGIES, SQL_WILDCARD,
+    TIMESTAMP_SNAPSHOT_STRATEGY,
 };
-use crate::model_validation::models::{ModelValidationFacts, Rejected};
+use crate::model_validation::models::{ModelValidationFacts, ValidationStop};
 use crate::model_validation::types::Check;
 use crate::types::{AuthoredNode, NodeKind};
 
 const UPDATED_AT: &str = "updated_at";
 const OBSERVED_AT: &str = "observed_at";
 
-/// Accept the snapshot rules for one model's layered config.
+/// The snapshot config values `validate_snapshot_config` reads, in its order.
+struct SnapshotValues<N> {
+    strategy: Option<String>,
+    updated_at: Option<String>,
+    observed_at: Option<String>,
+    historical_input: Option<String>,
+    initial_valid_from: Option<String>,
+    full_refresh: Option<String>,
+    schema_change: Option<String>,
+    unique_key: Option<N>,
+    check_columns: Option<N>,
+    valid_from_column: Option<String>,
+    valid_to_column: Option<String>,
+}
+
+impl<N: AuthoredNode> SnapshotValues<N> {
+    fn read(config: &ConfigView<'_, N>) -> Result<Self, ValidationStop> {
+        let strategy = config.string("snapshot_strategy")?;
+        let updated_at = config.string(UPDATED_AT)?;
+        let observed_at = config.string(OBSERVED_AT)?;
+        let historical_input = config.string("historical_input")?;
+        let initial_valid_from = config.string("initial_valid_from")?;
+        let full_refresh = config.string("snapshot_full_refresh")?;
+        let schema_change = config.string("snapshot_schema_change")?;
+        let unique_key = config.get("unique_key").cloned();
+        let check_columns = config.get("check_columns").cloned();
+        let valid_from_column = config.string("valid_from_column")?;
+        let valid_to_column = config.string("valid_to_column")?;
+        Ok(Self {
+            strategy,
+            updated_at,
+            observed_at,
+            historical_input,
+            initial_valid_from,
+            full_refresh,
+            schema_change,
+            unique_key,
+            check_columns,
+            valid_from_column,
+            valid_to_column,
+        })
+    }
+}
+
+/// Check the snapshot rules for one model's layered config.
 pub(crate) fn check_snapshot<N: AuthoredNode>(
-    config: &ConfigView<N>,
+    config: &ConfigView<'_, N>,
     facts: &ModelValidationFacts<'_>,
 ) -> Check {
     if config.string("materialized")?.as_deref() != Some(SNAPSHOT_MATERIALIZATION) {
         return Ok(());
     }
-    let strategy = config.string("snapshot_strategy")?;
-    let updated_at = config.string(UPDATED_AT)?;
-    let observed_at = config.string(OBSERVED_AT)?;
-    let historical_input = config.string("historical_input")?;
-    let initial_valid_from = config.string("initial_valid_from")?;
-    let full_refresh = config.string("snapshot_full_refresh")?;
-    let schema_change = config.string("snapshot_schema_change")?;
-    let valid_from_column = config.string("valid_from_column")?;
-    let valid_to_column = config.string("valid_to_column")?;
-    let unique_key = config.get("unique_key");
-    let check_columns = config.get("check_columns");
-    let strategy = strategy.as_deref();
-    let historical_input = historical_input.as_deref();
-    let changes = historical_input == Some(CHANGES_HISTORICAL_INPUT);
-    let check = strategy == Some(CHECK_SNAPSHOT_STRATEGY);
-    let timestamp = strategy == Some(TIMESTAMP_SNAPSHOT_STRATEGY);
-    if config.any_present(&SNAPSHOT_DISALLOWED_KEYS)
-        || !has_config_value(unique_key)
-        || !strategy.is_some_and(|value| one_of(value, &SNAPSHOT_STRATEGIES))
-        || (timestamp && updated_at.is_none())
-        || (check && !has_config_value(check_columns))
-        || (check && check_columns.is_some_and(mixes_wildcard))
-        || (historical_input.is_some() && observed_at.is_none())
-        || historical_input.is_some_and(|value| !one_of(value, &HISTORICAL_INPUTS))
-        || (observed_at.is_some() && timestamp && historical_input.is_none())
-        || (check && changes)
+    let values = SnapshotValues::read(config)?;
+    if let Some(key) = config.first_present(&SNAPSHOT_DISALLOWED_KEYS) {
+        return Err(config.error(format!("{key} is not allowed on snapshot models")));
+    }
+    check_strategy(config, &values)?;
+    check_history(config, &values)?;
+    check_policies(config, &values)?;
+    if let (Some(valid_from), Some(valid_to)) = (&values.valid_from_column, &values.valid_to_column)
+        && same_lowered(valid_from, valid_to)?
+    {
+        return Err(config.error("valid_from_column and valid_to_column must differ"));
+    }
+    check_contract_columns(config, &values, facts)
+}
+
+fn check_strategy<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    values: &SnapshotValues<N>,
+) -> Check {
+    if !has_config_value(values.unique_key.as_ref()) {
+        return Err(config.error("snapshot materialization requires unique_key"));
+    }
+    let Some(strategy) = values.strategy.as_deref() else {
+        return Err(config.error("snapshot materialization requires snapshot_strategy"));
+    };
+    if !one_of(strategy, &SNAPSHOT_STRATEGIES) {
+        return Err(config.error(format!(
+            "unknown snapshot_strategy '{strategy}'; valid values: {}",
+            sorted_values(&SNAPSHOT_STRATEGIES)
+        )));
+    }
+    if strategy == TIMESTAMP_SNAPSHOT_STRATEGY && values.updated_at.is_none() {
+        return Err(config.error("snapshot_strategy=timestamp requires updated_at"));
+    }
+    let check = strategy == CHECK_SNAPSHOT_STRATEGY;
+    if check && !has_config_value(values.check_columns.as_ref()) {
+        return Err(config.error("snapshot_strategy=check requires check_columns"));
+    }
+    if check && values.check_columns.as_ref().is_some_and(mixes_wildcard) {
+        return Err(config.error("check_columns [*] cannot be combined with explicit columns"));
+    }
+    Ok(())
+}
+
+fn check_history<N: AuthoredNode>(config: &ConfigView<'_, N>, values: &SnapshotValues<N>) -> Check {
+    let historical_input = values.historical_input.as_deref();
+    let strategy = values.strategy.as_deref();
+    if historical_input.is_some() && values.observed_at.is_none() {
+        return Err(config.error("historical_input requires observed_at"));
+    }
+    if let Some(historical_input) = historical_input
+        && !one_of(historical_input, &HISTORICAL_INPUTS)
+    {
+        return Err(config.error(format!(
+            "unknown historical_input '{historical_input}'; valid values: {}",
+            sorted_values(&HISTORICAL_INPUTS)
+        )));
+    }
+    if values.observed_at.is_some()
+        && strategy == Some(TIMESTAMP_SNAPSHOT_STRATEGY)
+        && historical_input.is_none()
     {
-        return Err(Rejected);
+        return Err(config.error(
+            "timestamp snapshots with observed_at require historical_input snapshot or changes",
+        ));
+    }
+    let changes = historical_input == Some(CHANGES_HISTORICAL_INPUT);
+    if strategy == Some(CHECK_SNAPSHOT_STRATEGY) && changes {
+        return Err(
+            config.error("historical_input=changes is not valid with snapshot_strategy=check")
+        );
     }
     match config
         .get("invalidate_hard_deletes")
         .map(AuthoredNode::kind)
     {
-        None | Some(NodeKind::Bool(false)) => {}
-        Some(NodeKind::Bool(true)) if !changes => {}
-        Some(_) => return Err(Rejected),
-    }
-    let initial_valid_from = initial_valid_from.as_deref();
-    if initial_valid_from.is_some_and(|value| !one_of(value, &INITIAL_VALID_FROM_VALUES))
-        || (initial_valid_from == Some(UPDATED_AT) && updated_at.is_none())
-        || (initial_valid_from == Some(OBSERVED_AT) && observed_at.is_none())
-        || full_refresh
-            .as_deref()
-            .is_some_and(|value| !one_of(value, &SNAPSHOT_FULL_REFRESH_POLICIES))
-    {
-        return Err(Rejected);
+        None | Some(NodeKind::Bool(false)) => Ok(()),
+        Some(NodeKind::Bool(true)) if !changes => Ok(()),
+        Some(NodeKind::Bool(true)) => {
+            Err(config.error("invalidate_hard_deletes is not valid with historical_input=changes"))
+        }
+        Some(_) => Err(config.error("invalidate_hard_deletes must be a boolean")),
     }
-    if let Some(schema_change) = schema_change.as_deref()
-        && (!one_of(schema_change, &SNAPSHOT_SCHEMA_CHANGE_POLICIES)
-            || (config.equals("contract", ENFORCED_CONTRACT)
-                && schema_change == APPEND_NEW_COLUMNS_POLICY))
+}
+
+fn check_policies<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    values: &SnapshotValues<N>,
+) -> Check {
+    let initial_valid_from = values.initial_valid_from.as_deref();
+    if let Some(initial) = initial_valid_from
+        && !one_of(initial, &INITIAL_VALID_FROM_VALUES)
     {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "unknown initial_valid_from '{initial}'; valid values: {}",
+            sorted_values(&INITIAL_VALID_FROM_VALUES)
+        )));
+    }
+    if initial_valid_from == Some(UPDATED_AT) && values.updated_at.is_none() {
+        return Err(config.error("initial_valid_from=updated_at requires updated_at"));
+    }
+    if initial_valid_from == Some(OBSERVED_AT) && values.observed_at.is_none() {
+        return Err(config.error("initial_valid_from=observed_at requires observed_at"));
     }
-    if let (Some(valid_from), Some(valid_to)) = (&valid_from_column, &valid_to_column)
-        && python_lower(valid_from)? == python_lower(valid_to)?
+    if let Some(full_refresh) = values.full_refresh.as_deref()
+        && !one_of(full_refresh, &SNAPSHOT_FULL_REFRESH_POLICIES)
     {
-        return Err(Rejected);
+        return Err(config.error(format!(
+            "unknown snapshot_full_refresh '{full_refresh}'; valid values: {}",
+            sorted_values(&SNAPSHOT_FULL_REFRESH_POLICIES)
+        )));
     }
-    let Some(declared) = contract_declared_columns(config, facts) else {
+    let Some(schema_change) = values.schema_change.as_deref() else {
         return Ok(());
     };
-    let checked_columns = if check_columns.is_some_and(is_wildcard_only) {
-        Vec::new()
-    } else {
-        string_sequence(check_columns)?
+    if !one_of(schema_change, &SNAPSHOT_SCHEMA_CHANGE_POLICIES) {
+        return Err(config.error(format!(
+            "unknown snapshot_schema_change '{schema_change}'; valid values: {}",
+            sorted_values(&SNAPSHOT_SCHEMA_CHANGE_POLICIES)
+        )));
+    }
+    if config.equals("contract", ENFORCED_CONTRACT) && schema_change == APPEND_NEW_COLUMNS_POLICY {
+        return Err(ValidationStop::Error(
+            config
+                .config_error(
+                    "snapshot_schema_change=append_new_columns is not valid with contract \
+                     enforced; add new columns to the contract or set contract none",
+                )
+                .with_code(CONTRACT_SCHEMA_CHANGE_CODE),
+        ));
+    }
+    Ok(())
+}
+
+fn check_contract_columns<N: AuthoredNode>(
+    config: &ConfigView<'_, N>,
+    values: &SnapshotValues<N>,
+    facts: &ModelValidationFacts<'_>,
+) -> Check {
+    let Some(declared) = contract_declared_columns(config, facts) else {
+        return Ok(());
     };
-    let named = string_sequence(unique_key)?
-        .into_iter()
-        .chain(updated_at)
-        .chain(observed_at)
-        .chain(checked_columns);
-    require_declared(named, &declared)
+    require_declared(
+        config,
+        "unique_key",
+        &string_sequence(values.unique_key.as_ref())?,
+        &declared,
+    )?;
+    if let Some(updated_at) = &values.updated_at {
+        require_declared(
+            config,
+            UPDATED_AT,
+            std::slice::from_ref(updated_at),
+            &declared,
+        )?;
+    }
+    if let Some(observed_at) = &values.observed_at {
+        require_declared(
+            config,
+            OBSERVED_AT,
+            std::slice::from_ref(observed_at),
+            &declared,
+        )?;
+    }
+    if values.check_columns.as_ref().is_some_and(is_wildcard_only) {
+        return Ok(());
+    }
+    require_declared(
+        config,
+        "check_columns",
+        &string_sequence(values.check_columns.as_ref())?,
+        &declared,
+    )
 }
 
 fn mixes_wildcard<N: AuthoredNode>(columns: &N) -> bool {
diff --git a/crates/sqlbuild-model-config/src/model_validation/_helpers/text.rs b/crates/sqlbuild-model-config/src/model_validation/_helpers/text.rs
index 378f679bb2..67bca29187 100644
--- a/crates/sqlbuild-model-config/src/model_validation/_helpers/text.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/_helpers/text.rs
@@ -1,5 +1,6 @@
 //! ASCII text operations that match Python's `str` methods; other text is left to Python.
 
+use crate::model_validation::constants::SETTING_SNIPPET_INDENT;
 use crate::model_validation::models::Rejected;
 
 /// Return Python's `text.strip()` for ASCII text, or reject other text.
@@ -23,3 +24,12 @@ pub(crate) fn python_lower(text: &str) -> Result<String, Rejected> {
 fn is_python_space(byte: u8) -> bool {
     matches!(byte, b'\t'..=b'\r' | 0x1c..=0x1f | b' ')
 }
+
+/// Return `model_header_help`: the purpose, then the exact MODEL header entry to add.
+pub(crate) fn model_header_help(purpose: &str, entry: &str) -> String {
+    let indent = SETTING_SNIPPET_INDENT;
+    format!(
+        "{purpose}, add this to the MODEL header:\n{indent}MODEL (\n{indent}  {entry},\n\
+         {indent}  ...\n{indent});"
+    )
+}
diff --git a/crates/sqlbuild-model-config/src/model_validation/constants.rs b/crates/sqlbuild-model-config/src/model_validation/constants.rs
index a92e79efd2..fc5140ce97 100644
--- a/crates/sqlbuild-model-config/src/model_validation/constants.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/constants.rs
@@ -95,6 +95,22 @@ pub const SNAPSHOT_SCHEMA_CHANGE_POLICIES: [&str; 3] =
     ["deny", "require_confirmation", "append_new_columns"];
 /// The snapshot schema-change policy that conflicts with an enforced contract.
 pub const APPEND_NEW_COLUMNS_POLICY: &str = "append_new_columns";
+/// The `on_schema_change` value the change-policy help shows.
+pub const ON_SCHEMA_CHANGE_EXAMPLE: &str = "append_new_columns";
+/// The `replay_on_change` value the change-policy help shows.
+pub const REPLAY_ON_CHANGE_EXAMPLE: &str = "bounded-14d";
+/// The `replay_on_change` values the change-policy message lists, in its order.
+pub const REPLAY_ON_CHANGE_VALID_VALUES: [&str; 3] = ["forward", "full", "bounded-<duration>"];
+/// The code of the snapshot schema-change conflict with an enforced contract.
+pub const CONTRACT_SCHEMA_CHANGE_CODE: &str = "K012";
+/// The note naming the project setting that keeps microbatches sequential.
+pub const MICROBATCH_CONCURRENCY_NOTE: &str = "the current value is [settings] \
+microbatch_concurrency = false (from sqlbuild_project.toml or its default)";
+/// The help showing the project setting that allows concurrent microbatches.
+pub const MICROBATCH_CONCURRENCY_HELP: &str = "to run microbatches concurrently, set this in \
+sqlbuild_project.toml:\n            [settings]\n            microbatch_concurrency = true";
+/// The indent of the setting snippet lines in help text.
+pub const SETTING_SNIPPET_INDENT: &str = "            ";
 /// The duration-disabled cursor policy value.
 pub const CURSOR_POLICY_DISABLED: &str = "disabled";
 /// The zero-day cursor duration.
@@ -209,6 +225,8 @@ pub const UTC_OFFSET_LENGTH: usize = 5;
 pub const MIN_YEAR: i128 = 1;
 /// The last year Python's `datetime` represents.
 pub const MAX_YEAR: i128 = 9999;
+/// Prefixes of the special values `Decimal` parses, after any sign.
+pub const DECIMAL_SPECIAL_PREFIXES: [&str; 3] = ["inf", "nan", "snan"];
 /// The last month whose civil-day computation shifts the year back.
 pub const LAST_SHIFTED_MONTH: i128 = 2;
 /// The position of days among duration units.
diff --git a/crates/sqlbuild-model-config/src/model_validation/main/mod.rs b/crates/sqlbuild-model-config/src/model_validation/main/mod.rs
index bd1459bc69..0e18dcfe87 100644
--- a/crates/sqlbuild-model-config/src/model_validation/main/mod.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/main/mod.rs
@@ -1,3 +1,3 @@
-pub mod accept_model_config;
 pub mod retention_override;
 pub mod table_type_override;
+pub mod validate_model_config;
diff --git a/crates/sqlbuild-model-config/src/model_validation/main/retention_override.rs b/crates/sqlbuild-model-config/src/model_validation/main/retention_override.rs
index a6f3222f9d..42c65c51d7 100644
--- a/crates/sqlbuild-model-config/src/model_validation/main/retention_override.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/main/retention_override.rs
@@ -1,18 +1,28 @@
 //! Read a MODEL header's `time_travel_retention` as `resolve_time_travel_retention` does.
 
-use crate::model_validation::_helpers::config::optional_text;
+use crate::errors::ConfigError;
+use crate::model_validation::_helpers::config::text_if_string;
 use crate::model_validation::_helpers::durations::parse_duration;
 use crate::model_validation::constants::{DISABLED_RETENTION, INHERIT_POLICY, ZERO_DAY_DURATION};
-use crate::model_validation::models::{Rejected, RetentionOverride};
-use crate::types::AuthoredNode;
+use crate::model_validation::models::{RetentionOverride, ValidationStop};
+use crate::types::{AuthoredNode, NodeKind};
 
-/// Return the header retention override, or reject a value Python refuses.
+/// Return the header retention override, the error Python raises, or a deferral.
 pub fn retention_override<N: AuthoredNode>(
     value: Option<&N>,
-) -> Result<RetentionOverride, Rejected> {
-    let Some(text) = optional_text(value)? else {
+    model_name: &str,
+) -> Result<RetentionOverride, ValidationStop> {
+    let invalid = |expected: &str| {
+        ValidationStop::Error(ConfigError::compile(format!(
+            "model '{model_name}': time_travel_retention must be a whole-day string like {expected}"
+        )))
+    };
+    let Some(value) = value.filter(|node| node.kind() != NodeKind::Null) else {
         return Ok(RetentionOverride::Inherit);
     };
+    let Some(text) = text_if_string(value)? else {
+        return Err(invalid("'7d'"));
+    };
     match text.as_str() {
         INHERIT_POLICY => Ok(RetentionOverride::Inherit),
         DISABLED_RETENTION => Ok(RetentionOverride::Unmanaged),
@@ -20,8 +30,8 @@ pub fn retention_override<N: AuthoredNode>(
         _ => match parse_duration(&text)? {
             Some(duration) if duration.is_whole_days() => u64::try_from(duration.days())
                 .map(RetentionOverride::Days)
-                .map_err(|_| Rejected),
-            _ => Err(Rejected),
+                .map_err(|_| ValidationStop::Defer),
+            _ => Err(invalid("'7d', 'inherit', or 'disabled'")),
         },
     }
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/main/table_type_override.rs b/crates/sqlbuild-model-config/src/model_validation/main/table_type_override.rs
index daed7e16e8..c449a5aa99 100644
--- a/crates/sqlbuild-model-config/src/model_validation/main/table_type_override.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/main/table_type_override.rs
@@ -1,20 +1,27 @@
 //! Read a MODEL header's `table_type` as `resolve_table_type` does.
 
-use crate::model_validation::_helpers::config::optional_text;
+use crate::errors::ConfigError;
+use crate::model_validation::_helpers::config::text_if_string;
 use crate::model_validation::constants::{
     INHERIT_POLICY, PERMANENT_TABLE_TYPE, TRANSIENT_TABLE_TYPE,
 };
-use crate::model_validation::models::{Rejected, TableTypeOverride};
-use crate::types::AuthoredNode;
+use crate::model_validation::models::{TableTypeOverride, ValidationStop};
+use crate::types::{AuthoredNode, NodeKind};
 
-/// Return the header table-type override, or reject a value Python refuses.
+/// Return the header table-type override, the error Python raises, or a deferral.
 pub fn table_type_override<N: AuthoredNode>(
     value: Option<&N>,
-) -> Result<TableTypeOverride, Rejected> {
-    match optional_text(value)?.as_deref() {
-        None | Some(INHERIT_POLICY) => Ok(TableTypeOverride::Inherit),
+    model_name: &str,
+) -> Result<TableTypeOverride, ValidationStop> {
+    let Some(value) = value.filter(|node| node.kind() != NodeKind::Null) else {
+        return Ok(TableTypeOverride::Inherit);
+    };
+    match text_if_string(value)?.as_deref() {
+        Some(INHERIT_POLICY) => Ok(TableTypeOverride::Inherit),
         Some(PERMANENT_TABLE_TYPE) => Ok(TableTypeOverride::Permanent),
         Some(TRANSIENT_TABLE_TYPE) => Ok(TableTypeOverride::Transient),
-        Some(_) => Err(Rejected),
+        _ => Err(ValidationStop::Error(ConfigError::compile(format!(
+            "model '{model_name}': table_type must be permanent, transient, or inherit"
+        )))),
     }
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/main/accept_model_config.rs b/crates/sqlbuild-model-config/src/model_validation/main/validate_model_config.rs
similarity index 57%
rename from crates/sqlbuild-model-config/src/model_validation/main/accept_model_config.rs
rename to crates/sqlbuild-model-config/src/model_validation/main/validate_model_config.rs
index c166ecd066..7c1d046875 100644
--- a/crates/sqlbuild-model-config/src/model_validation/main/accept_model_config.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/main/validate_model_config.rs
@@ -1,28 +1,30 @@
-//! Accept a model's effective config when every Python model validator would.
+//! Validate a model's effective config, raising the first error the Python validators raise.
 
 use crate::model_validation::_helpers::config::ConfigView;
 use crate::model_validation::_helpers::incremental::check_incremental;
 use crate::model_validation::_helpers::materialization::{
-    check_contract_and_incremental_keys, check_custom_materialization, check_migration,
+    check_contract, check_custom_materialization, check_migration, check_non_incremental,
     check_placeholders, check_project_capability, check_storage_policies,
 };
 use crate::model_validation::_helpers::references::check_references;
 use crate::model_validation::_helpers::snapshot::check_snapshot;
-use crate::model_validation::models::{ModelValidationFacts, ProjectValidationFacts};
-use crate::model_validation::types::Check;
+use crate::model_validation::models::{
+    ModelValidationFacts, ProjectValidationFacts, ValidationStop,
+};
 use crate::types::AuthoredNode;
 
-/// Accept only what every Python validator accepts; a rejection means Python must decide.
-pub fn accept_model_config<N: AuthoredNode>(
+/// Run the Python validators' rules in their order; defer where only Python can decide.
+pub fn validate_model_config<N: AuthoredNode>(
     entries: Vec<(N, N)>,
     project: &ProjectValidationFacts,
     facts: &ModelValidationFacts<'_>,
-) -> Check {
-    let config = ConfigView::new(entries);
-    check_references(facts.references, project)?;
+) -> Result<(), ValidationStop> {
+    let config = ConfigView::new(entries, facts.model_name);
+    check_references(facts, project)?;
     check_incremental(&config, facts)?;
     check_project_capability(&config, project)?;
-    check_contract_and_incremental_keys(&config)?;
+    check_contract(&config)?;
+    check_non_incremental(&config)?;
     check_snapshot(&config, facts)?;
     check_custom_materialization(&config, project)?;
     check_storage_policies(&config, facts)?;
diff --git a/crates/sqlbuild-model-config/src/model_validation/models.rs b/crates/sqlbuild-model-config/src/model_validation/models.rs
index 342c566bbc..9a7ed254c7 100644
--- a/crates/sqlbuild-model-config/src/model_validation/models.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/models.rs
@@ -2,6 +2,8 @@
 
 use std::collections::HashSet;
 
+use crate::errors::ConfigError;
+
 /// Project-wide facts every model's validation reads.
 #[derive(Clone, Debug, Default)]
 pub struct ProjectValidationFacts {
@@ -32,6 +34,8 @@ pub struct ModelReference {
 #[derive(Clone, Debug)]
 pub struct ModelValidationFacts<'a> {
     pub model_name: &'a str,
+    /// The model file's project-relative path, as reference errors name it.
+    pub relative_path: &'a str,
     /// Merged references in extraction order.
     pub references: &'a [ModelReference],
     /// Column names of the model's declared schema, when one applies.
@@ -44,10 +48,25 @@ pub struct ModelValidationFacts<'a> {
     pub table_type_declared: bool,
 }
 
-/// Why native validation cannot accept a config: Python must run and decide.
+/// Why native validation cannot decide a value: Python must run and decide.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Rejected;
 
+/// Why native validation stops: Python must decide, or the exact error the validators raise.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ValidationStop {
+    /// The config holds a value only Python can judge; the Python validators run.
+    Defer,
+    /// The first error the Python validators raise.
+    Error(ConfigError),
+}
+
+impl From<Rejected> for ValidationStop {
+    fn from(_: Rejected) -> Self {
+        Self::Defer
+    }
+}
+
 /// The header's `time_travel_retention`, applied over the inherited policy.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum RetentionOverride {
diff --git a/crates/sqlbuild-model-config/src/model_validation/tests.rs b/crates/sqlbuild-model-config/src/model_validation/tests.rs
index eac226ccf3..5fbe948817 100644
--- a/crates/sqlbuild-model-config/src/model_validation/tests.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/tests.rs
@@ -1,8 +1,8 @@
-#[path = "tests/test_accept_model_config.rs"]
-mod accept_model_config;
 #[path = "tests/helpers.rs"]
 mod helpers;
 #[path = "tests/test_storage_overrides.rs"]
 mod storage_overrides;
 #[path = "tests/test_types.rs"]
 mod test_types;
+#[path = "tests/test_validate_model_config.rs"]
+mod validate_model_config;
diff --git a/crates/sqlbuild-model-config/src/model_validation/tests/helpers.rs b/crates/sqlbuild-model-config/src/model_validation/tests/helpers.rs
index 036cd9cd19..4f2b5c2fb6 100644
--- a/crates/sqlbuild-model-config/src/model_validation/tests/helpers.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/tests/helpers.rs
@@ -1,6 +1,55 @@
-use crate::model_validation::models::ProjectValidationFacts;
+use crate::errors::ConfigError;
+use crate::model_validation::main::validate_model_config::validate_model_config;
+use crate::model_validation::models::{
+    ModelReference, ModelValidationFacts, ProjectValidationFacts, ValidationStop,
+};
 use crate::tests::test_types::Value;
 
+/// The validator error `model 'orders_daily': <text>`.
+pub(super) fn validator_error(text: &str) -> ValidationStop {
+    ValidationStop::Error(ConfigError::compile(format!(
+        "model 'orders_daily': {text}"
+    )))
+}
+
+/// Validate `config` for `orders_daily`: `accepted`, `deferred`, or the error message.
+pub(super) fn validation_outcome(
+    config: Vec<(&'static str, Value)>,
+    references: &[&str],
+    query_sql: &str,
+) -> String {
+    let references: Vec<ModelReference> = references
+        .iter()
+        .filter_map(|reference| reference.split_once(':'))
+        .map(|(kind, name)| ModelReference {
+            kind: kind.to_owned(),
+            name: name.to_owned(),
+        })
+        .collect();
+    let facts = ModelValidationFacts {
+        model_name: "orders_daily",
+        relative_path: "models/marts/orders_daily.sql",
+        references: &references,
+        declared_columns: None,
+        query_sql,
+        retention_unmanaged: true,
+        table_type_declared: false,
+    };
+    let entries: Vec<(Value, Value)> = config
+        .into_iter()
+        .map(|(key, value)| (Value::Str(key), value))
+        .collect();
+    validate_model_config(entries, &project(), &facts)
+        .map_or_else(stop_text, |()| "accepted".to_owned())
+}
+
+fn stop_text(stop: ValidationStop) -> String {
+    let ValidationStop::Error(error) = stop else {
+        return "deferred".to_owned();
+    };
+    error.message
+}
+
 /// A list of strings.
 pub(super) fn strings(values: &[&str]) -> Value {
     Value::List(values.iter().map(|value| Value::Str(leak(value))).collect())
diff --git a/crates/sqlbuild-model-config/src/model_validation/tests/test_storage_overrides.rs b/crates/sqlbuild-model-config/src/model_validation/tests/test_storage_overrides.rs
index 5e780d1315..c4a076a42d 100644
--- a/crates/sqlbuild-model-config/src/model_validation/tests/test_storage_overrides.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/tests/test_storage_overrides.rs
@@ -1,6 +1,7 @@
 use crate::model_validation::main::retention_override::retention_override;
 use crate::model_validation::main::table_type_override::table_type_override;
-use crate::model_validation::models::{Rejected, RetentionOverride, TableTypeOverride};
+use crate::model_validation::models::{RetentionOverride, TableTypeOverride};
+use crate::model_validation::tests::helpers::validator_error;
 use crate::model_validation::tests::test_types::{
     RetentionOverrideTestCase, TableTypeOverrideTestCase,
 };
@@ -37,17 +38,22 @@ fn given_header_retention_values_when_reading_then_python_policies_result() {
         RetentionOverrideTestCase {
             description: "hours are not whole days",
             value: Some(Value::Str("1d6h")),
-            expected_override: Err(Rejected),
+            expected_override: Err(validator_error(
+                "time_travel_retention must be a whole-day string like '7d', 'inherit', or \
+                 'disabled'",
+            )),
         },
         RetentionOverrideTestCase {
             description: "not a string",
             value: Some(Value::Int(7)),
-            expected_override: Err(Rejected),
+            expected_override: Err(validator_error(
+                "time_travel_retention must be a whole-day string like '7d'",
+            )),
         },
     ];
 
     for test_case in test_cases {
-        let resolved = retention_override(test_case.value.as_ref());
+        let resolved = retention_override(test_case.value.as_ref(), "orders_daily");
 
         assert_eq!(
             resolved, test_case.expected_override,
@@ -83,12 +89,14 @@ fn given_header_table_types_when_reading_then_python_types_result() {
         TableTypeOverrideTestCase {
             description: "unknown",
             value: Some(Value::Str("temporary")),
-            expected_override: Err(Rejected),
+            expected_override: Err(validator_error(
+                "table_type must be permanent, transient, or inherit",
+            )),
         },
     ];
 
     for test_case in test_cases {
-        let resolved = table_type_override(test_case.value.as_ref());
+        let resolved = table_type_override(test_case.value.as_ref(), "orders_daily");
 
         assert_eq!(
             resolved, test_case.expected_override,
diff --git a/crates/sqlbuild-model-config/src/model_validation/tests/test_types.rs b/crates/sqlbuild-model-config/src/model_validation/tests/test_types.rs
index 1f962f3aa8..669a7675df 100644
--- a/crates/sqlbuild-model-config/src/model_validation/tests/test_types.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/tests/test_types.rs
@@ -1,26 +1,27 @@
-use crate::model_validation::models::{Rejected, RetentionOverride, TableTypeOverride};
+use crate::model_validation::models::{RetentionOverride, TableTypeOverride, ValidationStop};
 use crate::tests::test_types::Value;
 
-/// One effective config, its references, and whether native validation accepts it.
-pub(super) struct AcceptTestCase {
+/// One effective config, its references, and the outcome native validation reaches.
+pub(super) struct ValidateTestCase {
     pub(super) description: &'static str,
     pub(super) config: Vec<(&'static str, Value)>,
     /// `kind:name` per reference.
     pub(super) references: &'static [&'static str],
     pub(super) query_sql: &'static str,
-    pub(super) expected_accepted: bool,
+    /// `accepted`, `deferred`, or the exact error message.
+    pub(super) expected_outcome: &'static str,
 }
 
 /// One header `time_travel_retention` value and the override Python resolves.
 pub(super) struct RetentionOverrideTestCase {
     pub(super) description: &'static str,
     pub(super) value: Option<Value>,
-    pub(super) expected_override: Result<RetentionOverride, Rejected>,
+    pub(super) expected_override: Result<RetentionOverride, ValidationStop>,
 }
 
 /// One header `table_type` value and the override Python resolves.
 pub(super) struct TableTypeOverrideTestCase {
     pub(super) description: &'static str,
     pub(super) value: Option<Value>,
-    pub(super) expected_override: Result<TableTypeOverride, Rejected>,
+    pub(super) expected_override: Result<TableTypeOverride, ValidationStop>,
 }
diff --git a/crates/sqlbuild-model-config/src/model_validation/tests/test_accept_model_config.rs b/crates/sqlbuild-model-config/src/model_validation/tests/test_validate_model_config.rs
similarity index 71%
rename from crates/sqlbuild-model-config/src/model_validation/tests/test_accept_model_config.rs
rename to crates/sqlbuild-model-config/src/model_validation/tests/test_validate_model_config.rs
index 981b501074..cfe5224f06 100644
--- a/crates/sqlbuild-model-config/src/model_validation/tests/test_accept_model_config.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/tests/test_validate_model_config.rs
@@ -1,13 +1,13 @@
-use crate::model_validation::main::accept_model_config::accept_model_config;
-use crate::model_validation::models::{ModelReference, ModelValidationFacts};
-use crate::model_validation::tests::helpers::{incremental, map, project, snapshot, strings};
-use crate::model_validation::tests::test_types::AcceptTestCase;
+use crate::model_validation::tests::helpers::{
+    incremental, map, snapshot, strings, validation_outcome,
+};
+use crate::model_validation::tests::test_types::ValidateTestCase;
 use crate::tests::test_types::Value;
 
 #[test]
-fn given_effective_configs_when_validating_natively_then_only_python_valid_configs_pass() {
+fn given_effective_configs_when_validating_natively_then_python_outcomes_result() {
     let test_cases = [
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a plain table with known references",
             config: vec![("materialized", Value::Str("table"))],
             references: &[
@@ -17,30 +17,30 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
                 "udf:cents",
             ],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an unknown model reference",
             config: vec![("materialized", Value::Str("table"))],
             references: &["ref:invoices"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "Model file models/marts/orders_daily.sql references unknown model 'invoices'",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a table function called as a scalar function",
             config: vec![],
             references: &["udf:order_lines"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "Model file models/marts/orders_daily.sql references table function 'order_lines' with __udf(); use __table_fn() in SQL contexts that support table-valued functions",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a dbt reference always defers to Python",
             config: vec![],
             references: &["dbt_ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "deferred",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an append incremental with ordered ISO bounds",
             config: incremental(vec![
                 ("cursor_start", Value::Str("2024-01-01")),
@@ -49,9 +49,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "cursor bounds out of order",
             config: incremental(vec![
                 ("cursor_start", Value::Str("2024-02-01")),
@@ -59,29 +59,29 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': cursor_start must be before exclusive cursor_end",
         },
-        AcceptTestCase {
-            description: "a start bound shifted before year 1 in UTC defers",
+        ValidateTestCase {
+            description: "a start bound shifted before year 1 in UTC fails",
             config: incremental(vec![
                 ("cursor_start", Value::Str("0001-01-01T00:00:00+01:00")),
                 ("cursor_end", Value::Str("2024-01-01")),
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': cursor_start value '0001-01-01T00:00:00+01:00' falls outside years 1-9999 once converted to UTC",
         },
-        AcceptTestCase {
-            description: "an end bound shifted past year 9999 in UTC defers",
+        ValidateTestCase {
+            description: "an end bound shifted past year 9999 in UTC fails",
             config: incremental(vec![
                 ("cursor_start", Value::Str("2024-01-01")),
                 ("cursor_end", Value::Str("9999-12-31T23:59:00-01:00")),
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': cursor_end value '9999-12-31T23:59:00-01:00' falls outside years 1-9999 once converted to UTC",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "bounds at the edges of years 1 and 9999 in UTC",
             config: incremental(vec![
                 ("cursor_start", Value::Str("0001-01-01T01:00:00+01:00")),
@@ -89,16 +89,16 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an unusual ISO timestamp defers",
             config: incremental(vec![("cursor_start", Value::Str("2024-W01-1"))]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "deferred",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a timestamp cursor without a grain",
             config: vec![
                 ("materialized", Value::Str("incremental")),
@@ -108,9 +108,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ],
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': cursor_type=timestamp requires cursor_grain (valid values: day, hour, minute, month, second, year)",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a watermark microbatch with a satisfiable limit",
             config: incremental(vec![
                 ("incremental_strategy", Value::Str("delete_insert")),
@@ -139,9 +139,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a watermark limit below the lookback requirement",
             config: incremental(vec![
                 ("incremental_strategy", Value::Str("delete_insert")),
@@ -164,9 +164,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': max_microbatches 3 is below the ordinary lookback requirement of 4 batches",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "merge exclusions overlapping the unique key",
             config: incremental(vec![
                 ("incremental_strategy", Value::Str("merge")),
@@ -175,16 +175,16 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': merge_exclude_columns cannot include unique_key column(s): order_id",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a bounded replay policy",
             config: incremental(vec![("replay_on_change", Value::Str("bounded- 14d"))]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an incremental-only key on a table",
             config: vec![
                 ("materialized", Value::Str("table")),
@@ -192,9 +192,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ],
             references: &[],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': full_refresh is only valid for incremental models",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a timestamp snapshot with observed history",
             config: snapshot(vec![
                 ("observed_at", Value::Str("loaded_at")),
@@ -203,9 +203,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a check snapshot mixing the wildcard",
             config: snapshot(vec![
                 ("snapshot_strategy", Value::Str("check")),
@@ -213,9 +213,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': check_columns [*] cannot be combined with explicit columns",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an enforced contract naming an undeclared unique key",
             config: snapshot(vec![
                 ("contract", Value::Str("enforced")),
@@ -223,9 +223,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': unique_key references column 'order_id' not declared in enforced contract",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a custom materialization with matching placeholders",
             config: vec![
                 ("materialized", Value::Str("ledger")),
@@ -233,23 +233,23 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ],
             references: &[],
             query_sql: "select @@@region, '@@@' as marker",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "placeholders on a built-in materialization",
             config: vec![("materialized", Value::Str("view"))],
             references: &[],
             query_sql: "select @@@region",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': @@@placeholders are only allowed on custom materializations",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an unknown custom materialization",
             config: vec![("materialized", Value::Str("archive"))],
             references: &[],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': unknown materialization 'archive'; not a built-in type and no custom materialization with that name was discovered",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a table migrating from an old name with an old-name view",
             config: vec![
                 ("materialized", Value::Str("table")),
@@ -258,9 +258,9 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ],
             references: &[],
             query_sql: "select 1",
-            expected_accepted: true,
+            expected_outcome: "accepted",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "a view forcing a migration",
             config: vec![
                 ("materialized", Value::Str("view")),
@@ -269,52 +269,30 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             ],
             references: &[],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': migrate_force is only valid for incremental and snapshot models; nothing is replaced when a 'view' model migrates, because tables and views are rebuilt under their new name",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "an old-name view without a duration",
             config: vec![("old_name_view", Value::Null)],
             references: &[],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': old_name_view must be a positive duration such as 7d, or false; got None",
         },
-        AcceptTestCase {
+        ValidateTestCase {
             description: "concurrent batches without the project capability",
             config: incremental(vec![("batch_concurrency", Value::Int(2))]),
             references: &["ref:orders"],
             query_sql: "select 1",
-            expected_accepted: false,
+            expected_outcome: "model 'orders_daily': batch_concurrency > 1 requires incremental_mode=microbatch",
         },
     ];
 
     for test_case in test_cases {
-        let references: Vec<ModelReference> = test_case
-            .references
-            .iter()
-            .filter_map(|reference| reference.split_once(':'))
-            .map(|(kind, name)| ModelReference {
-                kind: kind.to_owned(),
-                name: name.to_owned(),
-            })
-            .collect();
-        let facts = ModelValidationFacts {
-            model_name: "orders_daily",
-            references: &references,
-            declared_columns: None,
-            query_sql: test_case.query_sql,
-            retention_unmanaged: true,
-            table_type_declared: false,
-        };
-        let entries = test_case
-            .config
-            .into_iter()
-            .map(|(key, value)| (Value::Str(key), value))
-            .collect();
-
-        let accepted = accept_model_config(entries, &project(), &facts) == Ok(());
+        let outcome =
+            validation_outcome(test_case.config, test_case.references, test_case.query_sql);
 
         assert_eq!(
-            accepted, test_case.expected_accepted,
+            outcome, test_case.expected_outcome,
             "{}",
             test_case.description
         );
diff --git a/crates/sqlbuild-model-config/src/model_validation/types.rs b/crates/sqlbuild-model-config/src/model_validation/types.rs
index a0c3be4a76..df97c761d4 100644
--- a/crates/sqlbuild-model-config/src/model_validation/types.rs
+++ b/crates/sqlbuild-model-config/src/model_validation/types.rs
@@ -1,6 +1,6 @@
 //! The outcome type native validation threads through every check.
 
-use crate::model_validation::models::Rejected;
+use crate::model_validation::models::ValidationStop;
 
-/// Native validation's outcome; any rejection re-runs the Python validators.
-pub type Check = Result<(), Rejected>;
+/// Native validation's outcome: accepted, the first Python error, or a deferral to Python.
+pub type Check = Result<(), ValidationStop>;
diff --git a/crates/sqlbuild-model-config/src/path_defaults/_helpers/matching.rs b/crates/sqlbuild-model-config/src/path_defaults/_helpers/matching.rs
index fe4ffcfb18..4cdc531add 100644
--- a/crates/sqlbuild-model-config/src/path_defaults/_helpers/matching.rs
+++ b/crates/sqlbuild-model-config/src/path_defaults/_helpers/matching.rs
@@ -1,6 +1,8 @@
 //! Path-default glob matching and specificity, as `path_defaults/_helpers/matching.py`.
 
-use crate::path_defaults::constants::{RECURSIVE_SEGMENT_GLOB, SINGLE_SEGMENT_GLOB};
+use crate::errors::{ConfigError, ErrorClass};
+use crate::path_defaults::constants::{CONFLICT_HELP, RECURSIVE_SEGMENT_GLOB, SINGLE_SEGMENT_GLOB};
+use crate::path_defaults::models::PathDefaultChoice;
 
 /// Return whether a path-default pattern matches a prefix of the model path's segments.
 pub(crate) fn matches_prefix(path_parts: &[&str], key: &str) -> bool {
@@ -55,3 +57,29 @@ pub(crate) fn specificity(key: &str) -> (usize, usize, isize) {
         -isize::try_from(recursive).unwrap_or(isize::MAX),
     )
 }
+
+/// Choose the most specific wildcard key, or the conflict Python raises for equal matches.
+pub(crate) fn wildcard_choice(normalized_path: &str, matched: &[&String]) -> PathDefaultChoice {
+    let Some(best_score) = matched.iter().map(|key| specificity(key)).max() else {
+        return PathDefaultChoice::Selected(None);
+    };
+    let best: Vec<&&String> = matched
+        .iter()
+        .filter(|key| specificity(key) == best_score)
+        .collect();
+    if let [key] = best.as_slice() {
+        return PathDefaultChoice::Selected(Some((**key).clone()));
+    }
+    PathDefaultChoice::Conflict(conflict_error(normalized_path, &best))
+}
+
+/// The `DiscoveryConflictError` Python raises when `keys` match equally specifically.
+fn conflict_error(normalized_path: &str, keys: &[&&String]) -> ConfigError {
+    let conflicting: Vec<String> = keys.iter().map(|key| format!("'{key}'")).collect();
+    ConfigError::compile(format!(
+        "Model path '{normalized_path}' matches equally specific path_defaults keys: {}.",
+        conflicting.join(", ")
+    ))
+    .with_class(ErrorClass::DiscoveryConflict)
+    .with_help(CONFLICT_HELP)
+}
diff --git a/crates/sqlbuild-model-config/src/path_defaults/constants.rs b/crates/sqlbuild-model-config/src/path_defaults/constants.rs
index 3ae717449b..df9b7f4ef6 100644
--- a/crates/sqlbuild-model-config/src/path_defaults/constants.rs
+++ b/crates/sqlbuild-model-config/src/path_defaults/constants.rs
@@ -6,3 +6,6 @@ pub const SINGLE_SEGMENT_GLOB: &str = "*";
 pub const RECURSIVE_SEGMENT_GLOB: &str = "**";
 /// The project-relative folder prefix model paths drop before matching.
 pub const MODELS_PREFIX: &str = "models/";
+/// The help a path-default conflict shows.
+pub const CONFLICT_HELP: &str = "Make one pattern narrower by adding literal or '*' path segments, \
+or remove the overlap. Path-default selection never depends on declaration order.";
diff --git a/crates/sqlbuild-model-config/src/path_defaults/main/select_path_default.rs b/crates/sqlbuild-model-config/src/path_defaults/main/select_path_default.rs
index c0ec644032..6c9b467071 100644
--- a/crates/sqlbuild-model-config/src/path_defaults/main/select_path_default.rs
+++ b/crates/sqlbuild-model-config/src/path_defaults/main/select_path_default.rs
@@ -1,7 +1,7 @@
 //! `select_path_default`: the nearest path-default key for a model path.
 
 use crate::path_defaults::_helpers::matching::{
-    is_wildcard, matches_prefix, segment_count, specificity,
+    is_wildcard, matches_prefix, segment_count, wildcard_choice,
 };
 use crate::path_defaults::constants::MODELS_PREFIX;
 use crate::path_defaults::models::PathDefaultChoice;
@@ -31,12 +31,5 @@ pub fn select_path_default(model_path: &str, keys: &[String]) -> PathDefaultChoi
         }
         return PathDefaultChoice::Selected(best.cloned());
     }
-    let Some(best_score) = matched.iter().map(|key| specificity(key)).max() else {
-        return PathDefaultChoice::Selected(None);
-    };
-    let mut best = matched.iter().filter(|key| specificity(key) == best_score);
-    match (best.next(), best.next()) {
-        (Some(key), None) => PathDefaultChoice::Selected(Some((*key).clone())),
-        _ => PathDefaultChoice::Conflict,
-    }
+    wildcard_choice(normalized, &matched)
 }
diff --git a/crates/sqlbuild-model-config/src/path_defaults/models.rs b/crates/sqlbuild-model-config/src/path_defaults/models.rs
index f7f90b4a0a..271c381dbc 100644
--- a/crates/sqlbuild-model-config/src/path_defaults/models.rs
+++ b/crates/sqlbuild-model-config/src/path_defaults/models.rs
@@ -1,10 +1,12 @@
 //! The outcome of selecting one model's path default.
 
+use crate::errors::ConfigError;
+
 /// The selected path-default key, or a conflict Python reports.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PathDefaultChoice {
     /// The nearest matching key, or `None` when no key matches.
     Selected(Option<String>),
-    /// Several equally specific wildcard keys match.
-    Conflict,
+    /// Several equally specific wildcard keys match; the `DiscoveryConflictError` Python raises.
+    Conflict(ConfigError),
 }
diff --git a/crates/sqlbuild-model-config/src/path_defaults/tests/test_select_path_default.rs b/crates/sqlbuild-model-config/src/path_defaults/tests/test_select_path_default.rs
index 67eae9897b..7431baeb5e 100644
--- a/crates/sqlbuild-model-config/src/path_defaults/tests/test_select_path_default.rs
+++ b/crates/sqlbuild-model-config/src/path_defaults/tests/test_select_path_default.rs
@@ -1,3 +1,5 @@
+use crate::errors::{ConfigError, ErrorClass};
+use crate::path_defaults::constants::CONFLICT_HELP;
 use crate::path_defaults::main::select_path_default::select_path_default;
 use crate::path_defaults::models::PathDefaultChoice;
 use crate::path_defaults::tests::test_types::SelectTestCase;
@@ -33,7 +35,15 @@ fn given_path_default_keys_when_selecting_then_the_python_choice_is_made() {
             description: "equally specific wildcards conflict",
             model_path: "marts/finance/revenue.sql",
             keys: &["*/finance", "marts/*"],
-            expected_choice: PathDefaultChoice::Conflict,
+            expected_choice: PathDefaultChoice::Conflict(
+                ConfigError::compile(
+                    "Model path 'marts/finance/revenue.sql' matches equally specific \
+                     path_defaults keys: '*/finance', 'marts/*'."
+                        .to_owned(),
+                )
+                .with_class(ErrorClass::DiscoveryConflict)
+                .with_help(CONFLICT_HELP),
+            ),
         },
         SelectTestCase {
             description: "no key matches",
diff --git a/crates/sqlbuild-model-config/src/templates/_helpers/evaluation.rs b/crates/sqlbuild-model-config/src/templates/_helpers/evaluation.rs
index 8a581660e9..9564a6139e 100644
--- a/crates/sqlbuild-model-config/src/templates/_helpers/evaluation.rs
+++ b/crates/sqlbuild-model-config/src/templates/_helpers/evaluation.rs
@@ -16,6 +16,9 @@ const EQ_FUNCTION: &str = "eq";
 const NE_FUNCTION: &str = "ne";
 const COALESCE_FUNCTION: &str = "coalesce";
 const CONTEXT_NAMESPACE: &str = "CTX";
+const CONDITIONAL_ARGUMENTS: &str = "3 arguments";
+const COMPARISON_ARGUMENTS: &str = "2 arguments";
+const COALESCE_ARGUMENTS: &str = "at least 1 argument";
 
 /// Evaluate one expression to the value Python's resolver returns.
 pub(crate) fn evaluate<H: TemplateHost>(
@@ -58,7 +61,7 @@ fn evaluate_reference<H: TemplateHost>(
     };
     match namespace {
         ENVIRONMENT_NAMESPACE => host.environment(name)?.ok_or_else(|| {
-            TemplateFailure::Missing(TemplateError::MissingEnvironmentVariable(name.to_owned()))
+            TemplateFailure::Missing(TemplateError::MissingEnvironment(name.to_owned()))
         }),
         CONTEXT_NAMESPACE if !options.allow_context => {
             if options.preserve_context_tokens {
@@ -72,11 +75,11 @@ fn evaluate_reference<H: TemplateHost>(
             ContextValue::Unknown if options.preserve_unknown_context => {
                 host.text(&format!("${{{CONTEXT_NAMESPACE}:{name}}}"))
             }
-            ContextValue::Unknown => Err(TemplateFailure::Missing(
-                TemplateError::UnknownContextKey(name.to_owned()),
-            )),
+            ContextValue::Unknown => Err(TemplateFailure::Missing(TemplateError::UnknownContext(
+                name.to_owned(),
+            ))),
             ContextValue::Unavailable => Err(TemplateFailure::Missing(
-                TemplateError::UnavailableContextKey(name.to_owned()),
+                TemplateError::UnavailableContext(name.to_owned()),
             )),
         },
         _ => Err(TemplateFailure::Invalid(
@@ -100,12 +103,15 @@ fn evaluate_function<H: TemplateHost>(
                 evaluate(host, when_false, options)
             }
         }
+        (IF_FUNCTION, _) => Err(argument_count(IF_FUNCTION, CONDITIONAL_ARGUMENTS)),
         (EQ_FUNCTION | NE_FUNCTION, [left, right]) => {
             let left = evaluate(host, left, options)?;
             let right = evaluate(host, right, options)?;
             let equal = comparison_text(host, &left)? == comparison_text(host, &right)?;
             host.boolean(equal == (name == EQ_FUNCTION))
         }
+        (EQ_FUNCTION, _) => Err(argument_count(EQ_FUNCTION, COMPARISON_ARGUMENTS)),
+        (NE_FUNCTION, _) => Err(argument_count(NE_FUNCTION, COMPARISON_ARGUMENTS)),
         (COALESCE_FUNCTION, [.., last]) => {
             for argument in arguments {
                 match evaluate(host, argument, options) {
@@ -116,26 +122,15 @@ fn evaluate_function<H: TemplateHost>(
             }
             evaluate(host, last, options)
         }
-        (IF_FUNCTION, _) => Err(argument_count(IF_FUNCTION, 3)),
-        (EQ_FUNCTION | NE_FUNCTION, _) => Err(argument_count(
-            if name == EQ_FUNCTION {
-                EQ_FUNCTION
-            } else {
-                NE_FUNCTION
-            },
-            2,
-        )),
-        (COALESCE_FUNCTION, []) => Err(TemplateFailure::Invalid(
-            TemplateError::CoalesceWithoutArguments,
-        )),
+        (COALESCE_FUNCTION, []) => Err(argument_count(COALESCE_FUNCTION, COALESCE_ARGUMENTS)),
         _ => Err(TemplateFailure::Invalid(
             TemplateError::UnsupportedFunction(name.to_owned()),
         )),
     }
 }
 
-fn argument_count(function: &'static str, count: usize) -> TemplateFailure {
-    TemplateFailure::Invalid(TemplateError::ArgumentCount(function, count))
+fn argument_count(function: &'static str, expected: &'static str) -> TemplateFailure {
+    TemplateFailure::Invalid(TemplateError::ArgumentCount { function, expected })
 }
 
 fn comparison_text<H: TemplateHost>(host: &H, value: &H::Value) -> Result<String, TemplateFailure> {
diff --git a/crates/sqlbuild-model-config/src/templates/_helpers/expressions.rs b/crates/sqlbuild-model-config/src/templates/_helpers/expressions.rs
index 8847d7ba45..f61c2df1f2 100644
--- a/crates/sqlbuild-model-config/src/templates/_helpers/expressions.rs
+++ b/crates/sqlbuild-model-config/src/templates/_helpers/expressions.rs
@@ -9,11 +9,10 @@ pub(crate) fn parse_expression(body: &str) -> Result<Expression, TemplateFailure
     let tokens: Vec<Token> = tokenize(body)?;
     let mut parser = Parser { tokens, index: 0 };
     let expression = parser.expression()?;
-    let token: &Token = parser.peek();
-    if token.kind == TokenKind::End {
+    if parser.peek().kind == TokenKind::End {
         Ok(expression)
     } else {
-        Err(unexpected(token))
+        Err(parser.unexpected())
     }
 }
 
@@ -22,18 +21,19 @@ struct Parser {
     index: usize,
 }
 
-fn unexpected(token: &Token) -> TemplateFailure {
-    TemplateFailure::Invalid(TemplateError::UnexpectedToken(
-        token.value(),
-        token.position,
-    ))
-}
-
 impl Parser {
     fn peek(&self) -> &Token {
         &self.tokens[self.index]
     }
 
+    fn unexpected(&self) -> TemplateFailure {
+        let token = self.peek();
+        TemplateFailure::Invalid(TemplateError::UnexpectedToken {
+            token: token.value(),
+            position: token.position,
+        })
+    }
+
     fn match_symbol(&mut self, symbol: char) -> bool {
         if self.peek().kind == TokenKind::Symbol(symbol) {
             self.index += 1;
@@ -44,8 +44,7 @@ impl Parser {
     }
 
     fn expression(&mut self) -> Result<Expression, TemplateFailure> {
-        let token: Token = self.peek().clone();
-        match token.kind {
+        match self.peek().kind.clone() {
             TokenKind::Text(text) => {
                 self.index += 1;
                 Ok(Expression::Text(text))
@@ -58,7 +57,7 @@ impl Parser {
                     Ok(Expression::Reference(word))
                 }
             }
-            TokenKind::Symbol(_) | TokenKind::End => Err(unexpected(&token)),
+            TokenKind::Symbol(_) | TokenKind::End => Err(self.unexpected()),
         }
     }
 
@@ -73,10 +72,10 @@ impl Parser {
         if self.match_symbol(')') {
             Ok(Expression::Function { name, arguments })
         } else {
-            Err(TemplateFailure::Invalid(TemplateError::ExpectedSymbol(
-                ')',
-                self.peek().position,
-            )))
+            Err(TemplateFailure::Invalid(TemplateError::ExpectedSymbol {
+                symbol: ')',
+                position: self.peek().position,
+            }))
         }
     }
 }
diff --git a/crates/sqlbuild-model-config/src/templates/_helpers/tokens.rs b/crates/sqlbuild-model-config/src/templates/_helpers/tokens.rs
index 37ac76555e..83a2f6aa79 100644
--- a/crates/sqlbuild-model-config/src/templates/_helpers/tokens.rs
+++ b/crates/sqlbuild-model-config/src/templates/_helpers/tokens.rs
@@ -11,7 +11,7 @@ pub(crate) enum TokenKind {
     End,
 }
 
-/// One token and the character position it starts at; tokenized text is ASCII.
+/// One token and its character position in the expression.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct Token {
     pub(crate) kind: TokenKind,
@@ -19,7 +19,7 @@ pub(crate) struct Token {
 }
 
 impl Token {
-    /// Python's `token.value`: the word, the unquoted text, the symbol or nothing at the end.
+    /// Return the token's value as Python's error messages show it.
     pub(crate) fn value(&self) -> String {
         match &self.kind {
             TokenKind::Word(text) | TokenKind::Text(text) => text.clone(),
@@ -32,46 +32,44 @@ impl Token {
 const SYMBOLS: [char; 3] = ['(', ')', ','];
 const ESCAPE: char = '\\';
 
-/// Split one template expression into tokens; positions count characters, as Python's do.
+/// Split one template expression into tokens.
 pub(crate) fn tokenize(expression: &str) -> Result<Vec<Token>, TemplateFailure> {
     let characters: Vec<char> = expression.chars().collect();
     let mut tokens: Vec<Token> = Vec::new();
-    let mut index: usize = 0;
+    let mut index = 0;
     while let Some(&character) = characters.get(index) {
         if !character.is_ascii() {
             return Err(TemplateFailure::Unsupported);
         }
-        let position: usize = index;
         if is_python_space(character) {
             index += 1;
         } else if SYMBOLS.contains(&character) {
             tokens.push(Token {
                 kind: TokenKind::Symbol(character),
-                position,
+                position: index,
             });
             index += 1;
-        } else if let Some(quote_name) = quote_name(character) {
-            let (text, end) = quoted_text(&characters, index, quote_name)?;
+        } else if is_quote(character) {
+            let (text, next) = quoted_text(&characters, index)?;
             tokens.push(Token {
                 kind: TokenKind::Text(text),
-                position,
+                position: index,
             });
-            index = end;
+            index = next;
         } else {
-            let mut word = String::new();
+            let start = index;
             while let Some(&next) = characters.get(index) {
                 if !next.is_ascii() {
                     return Err(TemplateFailure::Unsupported);
                 }
-                if is_python_space(next) || SYMBOLS.contains(&next) || quote_name(next).is_some() {
+                if is_python_space(next) || SYMBOLS.contains(&next) || is_quote(next) {
                     break;
                 }
-                word.push(next);
                 index += 1;
             }
             tokens.push(Token {
-                kind: TokenKind::Word(word),
-                position,
+                kind: TokenKind::Word(characters[start..index].iter().collect()),
+                position: start,
             });
         }
     }
@@ -82,20 +80,17 @@ pub(crate) fn tokenize(expression: &str) -> Result<Vec<Token>, TemplateFailure>
     Ok(tokens)
 }
 
-/// The text quoted at `start` and the index after its closing quote.
-fn quoted_text(
-    characters: &[char],
-    start: usize,
-    quote_name: &'static str,
-) -> Result<(String, usize), TemplateFailure> {
-    let quote: char = characters[start];
+fn quoted_text(characters: &[char], start: usize) -> Result<(String, usize), TemplateFailure> {
+    let quote = characters[start];
     let mut text = String::new();
-    let mut index: usize = start + 1;
+    let mut index = start + 1;
     while let Some(&character) = characters.get(index) {
         if character == ESCAPE {
-            let escaped: char = *characters.get(index + 1).ok_or(TemplateFailure::Invalid(
-                TemplateError::UnterminatedEscape(index),
-            ))?;
+            let Some(&escaped) = characters.get(index + 1) else {
+                return Err(TemplateFailure::Invalid(
+                    TemplateError::UnterminatedEscape { position: index },
+                ));
+            };
             text.push(escaped);
             index += 2;
         } else if character == quote {
@@ -105,17 +100,17 @@ fn quoted_text(
             index += 1;
         }
     }
-    Err(TemplateFailure::Invalid(TemplateError::UnterminatedString(
-        quote_name, start,
-    )))
+    let quote = if quote == '\'' { "single" } else { "double" };
+    Err(TemplateFailure::Invalid(
+        TemplateError::UnterminatedString {
+            quote,
+            position: start,
+        },
+    ))
 }
 
-fn quote_name(character: char) -> Option<&'static str> {
-    match character {
-        '\'' => Some("single"),
-        '"' => Some("double"),
-        _ => None,
-    }
+fn is_quote(character: char) -> bool {
+    matches!(character, '\'' | '"')
 }
 
 /// ASCII characters Python's `str.isspace` accepts, including the information separators.
diff --git a/crates/sqlbuild-model-config/src/templates/errors.rs b/crates/sqlbuild-model-config/src/templates/errors.rs
index 2f96b3399c..a22eb11942 100644
--- a/crates/sqlbuild-model-config/src/templates/errors.rs
+++ b/crates/sqlbuild-model-config/src/templates/errors.rs
@@ -1,68 +1,35 @@
-//! The errors Python's template resolver raises.
+//! The template errors the Python resolver raises.
 
-/// The error Python's template resolver raises.
+/// One template error the Python resolver raises.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum TemplateError {
     UnknownVariable(String),
-    MissingEnvironmentVariable(String),
-    UnknownContextKey(String),
-    UnavailableContextKey(String),
+    MissingEnvironment(String),
+    UnknownContext(String),
+    UnavailableContext(String),
     ContextNotAllowed,
     UnsupportedNamespace(String),
-    /// `if`, `eq` or `ne` with the wrong number of arguments, and the number it expects.
-    ArgumentCount(&'static str, usize),
-    CoalesceWithoutArguments,
+    /// A function called with the wrong number of arguments, and the count it expects.
+    ArgumentCount {
+        function: &'static str,
+        expected: &'static str,
+    },
     UnsupportedFunction(String),
-    /// A token's text and character position where the parser expected another.
-    UnexpectedToken(String, usize),
-    ExpectedSymbol(char, usize),
-    UnterminatedEscape(usize),
-    /// The quote's name, `single` or `double`, and the position it opens at.
-    UnterminatedString(&'static str, usize),
-}
-
-impl TemplateError {
-    /// Python's message for templates in `context_label`; parse errors do not name it.
-    #[must_use]
-    pub fn message(&self, context_label: &str) -> String {
-        match self {
-            Self::UnknownVariable(name) => {
-                format!("{context_label} references unknown variable '{name}'")
-            }
-            Self::MissingEnvironmentVariable(name) => {
-                format!("{context_label} references missing ENV variable '{name}'")
-            }
-            Self::UnknownContextKey(name) => {
-                format!("{context_label} references unknown CTX key '{name}'")
-            }
-            Self::UnavailableContextKey(name) => {
-                format!("{context_label} references CTX key '{name}' but no value is available")
-            }
-            Self::ContextNotAllowed => format!("{context_label} does not allow CTX templates"),
-            Self::UnsupportedNamespace(namespace) => {
-                format!("{context_label} references unsupported template namespace '{namespace}'")
-            }
-            Self::ArgumentCount(function, count) => {
-                format!("{context_label} {function}(...) expects {count} arguments")
-            }
-            Self::CoalesceWithoutArguments => {
-                format!("{context_label} coalesce(...) expects at least 1 argument")
-            }
-            Self::UnsupportedFunction(name) => {
-                format!("{context_label} references unsupported template function '{name}'")
-            }
-            Self::UnexpectedToken(token, position) => format!(
-                "template expression contains unexpected token '{token}' at position {position}"
-            ),
-            Self::ExpectedSymbol(symbol, position) => {
-                format!("template expression expected '{symbol}' at position {position}")
-            }
-            Self::UnterminatedEscape(position) => {
-                format!("template expression has unterminated escape at position {position}")
-            }
-            Self::UnterminatedString(quote, position) => format!(
-                "template expression has unterminated {quote}-quoted string at position {position}"
-            ),
-        }
-    }
+    /// A token the parser does not expect, at its character position in the expression.
+    UnexpectedToken {
+        token: String,
+        position: usize,
+    },
+    ExpectedSymbol {
+        symbol: char,
+        position: usize,
+    },
+    UnterminatedEscape {
+        position: usize,
+    },
+    /// A string missing its closing quote, named `single` or `double`.
+    UnterminatedString {
+        quote: &'static str,
+        position: usize,
+    },
 }
diff --git a/crates/sqlbuild-model-config/src/templates/main/mod.rs b/crates/sqlbuild-model-config/src/templates/main/mod.rs
index d1b5730df4..7ea112bac5 100644
--- a/crates/sqlbuild-model-config/src/templates/main/mod.rs
+++ b/crates/sqlbuild-model-config/src/templates/main/mod.rs
@@ -1 +1,2 @@
 pub mod expand_template_string;
+pub mod template_error_message;
diff --git a/crates/sqlbuild-model-config/src/templates/main/template_error_message.rs b/crates/sqlbuild-model-config/src/templates/main/template_error_message.rs
new file mode 100644
index 0000000000..65c24ad112
--- /dev/null
+++ b/crates/sqlbuild-model-config/src/templates/main/template_error_message.rs
@@ -0,0 +1,45 @@
+//! Word a template error exactly as the Python template resolver does.
+
+use crate::templates::errors::TemplateError;
+
+/// Return the `CompileInputError` message for `error` in the context named `label`.
+pub fn template_error_message(error: &TemplateError, label: &str) -> String {
+    match error {
+        TemplateError::UnknownVariable(name) => {
+            format!("{label} references unknown variable '{name}'")
+        }
+        TemplateError::MissingEnvironment(name) => {
+            format!("{label} references missing ENV variable '{name}'")
+        }
+        TemplateError::UnknownContext(name) => {
+            format!("{label} references unknown CTX key '{name}'")
+        }
+        TemplateError::UnavailableContext(name) => {
+            format!("{label} references CTX key '{name}' but no value is available")
+        }
+        TemplateError::ContextNotAllowed => format!("{label} does not allow CTX templates"),
+        TemplateError::UnsupportedNamespace(namespace) => {
+            format!("{label} references unsupported template namespace '{namespace}'")
+        }
+        TemplateError::ArgumentCount { function, expected } => {
+            format!("{label} {function}(...) expects {expected}")
+        }
+        TemplateError::UnsupportedFunction(name) => {
+            format!("{label} references unsupported template function '{name}'")
+        }
+        TemplateError::UnexpectedToken { token, position } => {
+            format!(
+                "template expression contains unexpected token '{token}' at position {position}"
+            )
+        }
+        TemplateError::ExpectedSymbol { symbol, position } => {
+            format!("template expression expected '{symbol}' at position {position}")
+        }
+        TemplateError::UnterminatedEscape { position } => {
+            format!("template expression has unterminated escape at position {position}")
+        }
+        TemplateError::UnterminatedString { quote, position } => format!(
+            "template expression has unterminated {quote}-quoted string at position {position}"
+        ),
+    }
+}
diff --git a/crates/sqlbuild-model-config/src/templates/models.rs b/crates/sqlbuild-model-config/src/templates/models.rs
index 06c75d1aff..ac9385f925 100644
--- a/crates/sqlbuild-model-config/src/templates/models.rs
+++ b/crates/sqlbuild-model-config/src/templates/models.rs
@@ -36,7 +36,7 @@ pub enum ContextValue<V> {
 pub enum TemplateFailure {
     /// A missing variable, environment variable or context value, which `coalesce` skips.
     Missing(TemplateError),
-    /// Python raises this error for the template.
+    /// Another error Python raises for this template.
     Invalid(TemplateError),
     /// Python expands this template with rules the native expansion does not reproduce.
     Unsupported,
diff --git a/crates/sqlbuild-model-config/src/templates/tests/test_expand_template_string.rs b/crates/sqlbuild-model-config/src/templates/tests/test_expand_template_string.rs
index 8aef73d97c..0d66e68a3f 100644
--- a/crates/sqlbuild-model-config/src/templates/tests/test_expand_template_string.rs
+++ b/crates/sqlbuild-model-config/src/templates/tests/test_expand_template_string.rs
@@ -60,35 +60,35 @@ fn given_template_strings_when_expanding_then_values_and_reads_match_python() {
         TemplateTestCase {
             description: "a context key without a value is missing",
             text: "${CTX:model.schema}",
-            expected: Err(TemplateFailure::Missing(
-                TemplateError::UnavailableContextKey("model.schema".to_owned()),
-            )),
+            expected: Err(TemplateFailure::Missing(TemplateError::UnavailableContext(
+                "model.schema".to_owned(),
+            ))),
             expected_reads: &["CTX:model.schema"],
         },
         TemplateTestCase {
             description: "a missing variable after a coalesce names itself",
             text: "${coalesce(missing, '')}_${ENV:UNSET}",
-            expected: Err(TemplateFailure::Missing(
-                TemplateError::MissingEnvironmentVariable("UNSET".to_owned()),
-            )),
+            expected: Err(TemplateFailure::Missing(TemplateError::MissingEnvironment(
+                "UNSET".to_owned(),
+            ))),
             expected_reads: &["ENV:UNSET"],
         },
         TemplateTestCase {
             description: "an unexpected token reports its unquoted value and position",
             text: "${coalesce(a,,b)}",
-            expected: Err(TemplateFailure::Invalid(TemplateError::UnexpectedToken(
-                ",".to_owned(),
-                11,
-            ))),
+            expected: Err(TemplateFailure::Invalid(TemplateError::UnexpectedToken {
+                token: ",".to_owned(),
+                position: 11,
+            })),
             expected_reads: &[],
         },
         TemplateTestCase {
             description: "a trailing token after the expression",
             text: "${env 'x y'}",
-            expected: Err(TemplateFailure::Invalid(TemplateError::UnexpectedToken(
-                "x y".to_owned(),
-                4,
-            ))),
+            expected: Err(TemplateFailure::Invalid(TemplateError::UnexpectedToken {
+                token: "x y".to_owned(),
+                position: 4,
+            })),
             expected_reads: &[],
         },
         TemplateTestCase {
@@ -100,33 +100,38 @@ fn given_template_strings_when_expanding_then_values_and_reads_match_python() {
         TemplateTestCase {
             description: "an unclosed call inside a template expects its parenthesis",
             text: "${eq(flag env)}",
-            expected: Err(TemplateFailure::Invalid(TemplateError::ExpectedSymbol(
-                ')', 8,
-            ))),
+            expected: Err(TemplateFailure::Invalid(TemplateError::ExpectedSymbol {
+                symbol: ')',
+                position: 8,
+            })),
             expected_reads: &[],
         },
         TemplateTestCase {
             description: "an unterminated string reports where it opens",
             text: "${'abc}",
-            expected: Err(TemplateFailure::Invalid(TemplateError::UnterminatedString(
-                "single", 0,
-            ))),
+            expected: Err(TemplateFailure::Invalid(
+                TemplateError::UnterminatedString {
+                    quote: "single",
+                    position: 0,
+                },
+            )),
             expected_reads: &[],
         },
         TemplateTestCase {
             description: "an escape at the end of the expression",
             text: "${\"ab\\}",
-            expected: Err(TemplateFailure::Invalid(TemplateError::UnterminatedEscape(
-                3,
-            ))),
+            expected: Err(TemplateFailure::Invalid(
+                TemplateError::UnterminatedEscape { position: 3 },
+            )),
             expected_reads: &[],
         },
         TemplateTestCase {
             description: "argument counts are checked before arguments are evaluated",
             text: "${ne(missing)}",
-            expected: Err(TemplateFailure::Invalid(TemplateError::ArgumentCount(
-                "ne", 2,
-            ))),
+            expected: Err(TemplateFailure::Invalid(TemplateError::ArgumentCount {
+                function: "ne",
+                expected: "2 arguments",
+            })),
             expected_reads: &[],
         },
         TemplateTestCase {
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_errors.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_errors.rs
new file mode 100644
index 0000000000..ee7d58978a
--- /dev/null
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_errors.rs
@@ -0,0 +1,40 @@
+//! Native config errors handed to Python, which raises them as the Python stages would.
+
+use pyo3::Py;
+use pyo3::prelude::{Bound, PyModule, PyModuleMethods, PyResult, Python};
+use sqlbuild_model_config::errors::{ConfigError, ErrorClass};
+
+use crate::bindings::_helpers::model_config::errors::NativeConfigError;
+
+const COMPILE_INPUT_CLASS: &str = "compile_input";
+const CONFIG_VALUE_TYPE_CLASS: &str = "config_value_type";
+const RESOURCE_IDENTITY_CLASS: &str = "resource_identity";
+const DISCOVERY_CONFLICT_CLASS: &str = "discovery_conflict";
+
+/// Wrap `error` for Python.
+pub(crate) fn native_config_error(
+    py: Python<'_>,
+    error: ConfigError,
+) -> PyResult<Py<NativeConfigError>> {
+    let class_name = match error.class {
+        ErrorClass::CompileInput => COMPILE_INPUT_CLASS,
+        ErrorClass::ConfigValueType => CONFIG_VALUE_TYPE_CLASS,
+        ErrorClass::ResourceIdentity => RESOURCE_IDENTITY_CLASS,
+        ErrorClass::DiscoveryConflict => DISCOVERY_CONFLICT_CLASS,
+    };
+    Py::new(
+        py,
+        NativeConfigError {
+            class_name,
+            message: error.message,
+            code: error.code,
+            help: error.help,
+            key: error.key,
+        },
+    )
+}
+
+pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_class::<NativeConfigError>()?;
+    Ok(())
+}
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_templates.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_templates.rs
index 55408d370f..f5993fc70a 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_templates.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/config_templates.rs
@@ -8,16 +8,19 @@ use pyo3::types::{
     PyStringMethods, PyTuple, PyTupleMethods,
 };
 use pyo3::{FromPyObject, IntoPyObject, PyErr, pyfunction, wrap_pyfunction};
+use sqlbuild_model_config::errors::ConfigError;
 use sqlbuild_model_config::templates::main::expand_template_string::expand_template_string;
+use sqlbuild_model_config::templates::main::template_error_message::template_error_message;
 use sqlbuild_model_config::templates::models::{
     ContextValue, Scalar, StringExpansion, TemplateFailure, TemplateOptions,
 };
 use sqlbuild_model_config::templates::types::TemplateHost;
 
+use crate::bindings::_helpers::model_config::config_errors::native_config_error;
+
 const TEMPLATE_OPEN_TOKEN: &str = "${";
 const ENVIRONMENT_READ: &str = "env";
 const CONTEXT_READ: &str = "ctx";
-const INVALID_OUTCOME: &str = "invalid";
 const UNSUPPORTED_OUTCOME: &str = "unsupported";
 
 /// Variables, the process environment and context values, all read through Python.
@@ -51,9 +54,9 @@ pub(crate) struct TemplateSources<'py>(
     pub(crate) Bound<'py, PyDict>,
 );
 
-/// The three resolution flags, then a label making rejections `("invalid", message, reads)`.
+/// `allow_context`, `preserve_context_tokens`, `preserve_unknown_context` and the context label.
 #[derive(FromPyObject)]
-struct TemplateFlags(bool, bool, bool, Option<String>);
+struct TemplateFlags(bool, bool, bool, String);
 
 /// A template failure, or a Python error raised while building the expanded containers.
 pub(crate) enum Stop {
@@ -67,6 +70,16 @@ impl From<TemplateFailure> for Stop {
     }
 }
 
+/// The `CompileInputError` Python raises for a failed template in the context `label`.
+pub(crate) fn template_error(failure: &TemplateFailure, label: &str) -> Option<ConfigError> {
+    match failure {
+        TemplateFailure::Missing(error) | TemplateFailure::Invalid(error) => {
+            Some(ConfigError::compile(template_error_message(error, label)))
+        }
+        TemplateFailure::Unsupported => None,
+    }
+}
+
 fn unsupported(_: PyErr) -> TemplateFailure {
     TemplateFailure::Unsupported
 }
@@ -132,7 +145,7 @@ impl<'py> TemplateHost for PythonHost<'py> {
     }
 }
 
-/// Return `(value, reads)` as `expand_template_data` would, a rejection, or `unsupported`.
+/// Return `(value, reads)` as `expand_template_data` would, `(error, reads)` or `unsupported`.
 #[pyfunction]
 fn expand_config_templates<'py>(
     py: Python<'py>,
@@ -142,7 +155,6 @@ fn expand_config_templates<'py>(
 ) -> PyResult<Py<PyAny>> {
     let TemplateFlags(allow_context, preserve_context_tokens, preserve_unknown_context, label) =
         flags;
-    let context_label: Option<&str> = label.as_deref();
     let options = TemplateOptions {
         allow_context,
         preserve_context_tokens,
@@ -154,22 +166,13 @@ fn expand_config_templates<'py>(
             .into_pyobject(py)?
             .into_any()
             .unbind()),
-        Err(Stop::Failure(TemplateFailure::Missing(error) | TemplateFailure::Invalid(error))) => {
-            match context_label {
-                Some(label) => Ok((
-                    INVALID_OUTCOME,
-                    error.message(label),
-                    host.reads.into_inner(),
-                )
-                    .into_pyobject(py)?
-                    .into_any()
-                    .unbind()),
-                None => Ok(PyString::new(py, INVALID_OUTCOME).into_any().unbind()),
-            }
-        }
-        Err(Stop::Failure(TemplateFailure::Unsupported)) => {
-            Ok(PyString::new(py, UNSUPPORTED_OUTCOME).into_any().unbind())
-        }
+        Err(Stop::Failure(failure)) => match template_error(&failure, &label) {
+            Some(error) => Ok((native_config_error(py, error)?, host.into_reads())
+                .into_pyobject(py)?
+                .into_any()
+                .unbind()),
+            None => Ok(PyString::new(py, UNSUPPORTED_OUTCOME).into_any().unbind()),
+        },
         Err(Stop::Python(error)) => Err(error),
     }
 }
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/errors.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/errors.rs
new file mode 100644
index 0000000000..80b69f4d79
--- /dev/null
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/errors.rs
@@ -0,0 +1,13 @@
+//! The exact config error handed to Python.
+
+use pyo3::pyclass;
+
+/// One exact error: the Python class to raise, its message, code, help and named config key.
+#[pyclass(module = "sqlbuild._native", frozen, get_all)]
+pub(crate) struct NativeConfigError {
+    pub(crate) class_name: &'static str,
+    pub(crate) message: String,
+    pub(crate) code: Option<&'static str>,
+    pub(crate) help: Option<String>,
+    pub(crate) key: Option<String>,
+}
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/header_metadata.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/header_metadata.rs
index 070a51dbe5..3a75decbfb 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/model_config/header_metadata.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/header_metadata.rs
@@ -5,15 +5,15 @@ use pyo3::types::{PyBool, PyDict, PyDictMethods, PyString, PyTuple};
 use pyo3::{FromPyObject, IntoPyObject, pyfunction, wrap_pyfunction};
 use sqlbuild_model_config::header_metadata::main::parse_header_metadata::parse_header_metadata;
 use sqlbuild_model_config::header_metadata::models::{
-    HeaderMetadata, HeaderMetadataDeferral, ParsedAudit, ParsedColumn,
+    HeaderMetadataStop, ParsedAudit, ParsedColumn,
 };
 
 use crate::bindings::_helpers::model_config::authored_nodes::PyNode;
+use crate::bindings::_helpers::model_config::config_errors::native_config_error;
 
-/// A model's `(columns, audits)` tuples, or the outcome name `invalid` or `unsupported`.
+/// A model's columns and audits, each a contract tuple or its error, or `unsupported`.
 type ParsedMetadataRow = Py<PyAny>;
 
-const INVALID_OUTCOME: &str = "invalid";
 const UNSUPPORTED_OUTCOME: &str = "unsupported";
 
 /// The Python classes the parsed metadata becomes, read from a Python mapping.
@@ -26,11 +26,16 @@ struct ContractClasses<'py> {
     allocate: Bound<'py, PyAny>,
 }
 
-/// One model's authored `columns` and `audits` values and its column locations.
+/// One model's authored `columns` and `audits` values, its column locations and its file path.
 #[derive(FromPyObject)]
-struct HeaderMetadataRequest<'py>(Bound<'py, PyAny>, Bound<'py, PyAny>, Bound<'py, PyDict>);
+struct HeaderMetadataRequest<'py>(
+    Bound<'py, PyAny>,
+    Bound<'py, PyAny>,
+    Bound<'py, PyDict>,
+    String,
+);
 
-/// Return each model's `(columns, audits)` contract tuples, or why Python must parse it.
+/// Return each model's columns and audits, each as contract tuples or its error, or `unsupported`.
 #[pyfunction]
 fn parse_model_header_metadata<'py>(
     py: Python<'py>,
@@ -38,41 +43,62 @@ fn parse_model_header_metadata<'py>(
     classes: ContractClasses<'py>,
 ) -> PyResult<Vec<ParsedMetadataRow>> {
     let mut rows: Vec<ParsedMetadataRow> = Vec::with_capacity(requests.len());
-    for HeaderMetadataRequest(columns, audits, locations) in requests {
-        rows.push(
-            match parse_header_metadata(&PyNode(columns), &PyNode(audits)) {
-                Ok(metadata) => metadata_row(py, &classes, &metadata, &locations)?,
-                Err(HeaderMetadataDeferral::Invalid) => {
-                    PyString::new(py, INVALID_OUTCOME).into_any().unbind()
-                }
-                Err(HeaderMetadataDeferral::Unsupported) => {
-                    PyString::new(py, UNSUPPORTED_OUTCOME).into_any().unbind()
-                }
-            },
-        );
+    for HeaderMetadataRequest(columns, audits, locations, path) in requests {
+        let metadata = parse_header_metadata(&PyNode(columns), &PyNode(audits), &path);
+        rows.push(match (metadata.columns, metadata.audits) {
+            (Err(HeaderMetadataStop::Unsupported), _)
+            | (Ok(_), Err(HeaderMetadataStop::Unsupported)) => {
+                PyString::new(py, UNSUPPORTED_OUTCOME).into_any().unbind()
+            }
+            (Err(HeaderMetadataStop::Error(error)), _) => {
+                (native_config_error(py, error)?, py.None())
+                    .into_pyobject(py)?
+                    .into_any()
+                    .unbind()
+            }
+            (Ok(columns), Err(HeaderMetadataStop::Error(error))) => (
+                column_tuple(py, &classes, &columns, &locations)?,
+                native_config_error(py, error)?,
+            )
+                .into_pyobject(py)?
+                .into_any()
+                .unbind(),
+            (Ok(columns), Ok(audits)) => (
+                column_tuple(py, &classes, &columns, &locations)?,
+                audit_tuple(py, &classes, &audits)?,
+            )
+                .into_pyobject(py)?
+                .into_any()
+                .unbind(),
+        });
     }
     Ok(rows)
 }
 
-fn metadata_row<'py>(
+fn column_tuple<'py>(
     py: Python<'py>,
     classes: &ContractClasses<'py>,
-    metadata: &HeaderMetadata<PyNode<'py>>,
+    parsed: &[ParsedColumn<PyNode<'py>>],
     locations: &Bound<'py, PyDict>,
-) -> PyResult<ParsedMetadataRow> {
-    let no_location: Bound<'py, PyAny> = py.None().into_bound(py);
-    let mut columns: Vec<Bound<'py, PyAny>> = Vec::with_capacity(metadata.columns.len());
-    for column in &metadata.columns {
+) -> PyResult<Bound<'py, PyTuple>> {
+    let mut columns: Vec<Bound<'py, PyAny>> = Vec::with_capacity(parsed.len());
+    for column in parsed {
         columns.push(schema_column(py, classes, column, locations)?);
     }
-    let mut audits: Vec<Bound<'py, PyAny>> = Vec::with_capacity(metadata.audits.len());
-    for audit in &metadata.audits {
+    PyTuple::new(py, columns)
+}
+
+fn audit_tuple<'py>(
+    py: Python<'py>,
+    classes: &ContractClasses<'py>,
+    parsed: &[ParsedAudit<PyNode<'py>>],
+) -> PyResult<Bound<'py, PyTuple>> {
+    let no_location: Bound<'py, PyAny> = py.None().into_bound(py);
+    let mut audits: Vec<Bound<'py, PyAny>> = Vec::with_capacity(parsed.len());
+    for audit in parsed {
         audits.push(audit_instance(py, classes, audit, &no_location)?);
     }
-    Ok((PyTuple::new(py, columns)?, PyTuple::new(py, audits)?)
-        .into_pyobject(py)?
-        .into_any()
-        .unbind())
+    PyTuple::new(py, audits)
 }
 
 /// Build a frozen contract dataclass the way `copy` does: allocate, then fill its `__dict__`.
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/mod.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/mod.rs
index aef698874b..8644d5c08b 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/model_config/mod.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/mod.rs
@@ -1,6 +1,8 @@
 pub(crate) mod authored_nodes;
+pub(crate) mod config_errors;
 pub(crate) mod config_presence;
 pub(crate) mod config_templates;
+pub(crate) mod errors;
 pub(crate) mod header_metadata;
 pub(crate) mod model_config_builder;
 pub(crate) mod model_validator;
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_config_builder.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_config_builder.rs
index 74310c02e2..4370cec3df 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_config_builder.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_config_builder.rs
@@ -5,24 +5,33 @@ use pyo3::types::{
     PyDict, PyDictMethods, PyList, PyListMethods, PyString, PyTuple, PyTupleMethods,
 };
 use pyo3::{IntoPyObject, PyErr, pyclass, pymethods};
-use sqlbuild_model_config::config_presence::main::contains_macro_call::contains_macro_call;
 use sqlbuild_model_config::config_presence::main::contains_template::contains_template;
-use sqlbuild_model_config::config_presence::models::Presence;
+use sqlbuild_model_config::config_presence::main::first_macro_path::first_macro_path;
+use sqlbuild_model_config::config_presence::models::{MacroPath, Presence};
+use sqlbuild_model_config::errors::ConfigError;
 use sqlbuild_model_config::model_validation::main::retention_override::retention_override;
 use sqlbuild_model_config::model_validation::main::table_type_override::table_type_override;
-use sqlbuild_model_config::model_validation::models::{RetentionOverride, TableTypeOverride};
+use sqlbuild_model_config::model_validation::models::{
+    RetentionOverride, TableTypeOverride, ValidationStop,
+};
 use sqlbuild_model_config::path_defaults::main::select_path_default::select_path_default;
 use sqlbuild_model_config::path_defaults::models::PathDefaultChoice;
-use sqlbuild_model_config::templates::models::{TemplateFailure, TemplateOptions};
+use sqlbuild_model_config::templates::models::TemplateOptions;
 use sqlbuild_model_config::types::AuthoredNode;
 
 use crate::bindings::_helpers::boundary::panics::compiler_guard;
 use crate::bindings::_helpers::model_config::authored_nodes::PyNode;
+use crate::bindings::_helpers::model_config::config_errors::native_config_error;
 use crate::bindings::_helpers::model_config::config_templates::{
-    PythonHost, Stop, TemplateSources, expanded,
+    PythonHost, Stop, TemplateSources, expanded, template_error,
 };
 
 const HOOK_KEYS: [&str; 2] = ["pre_hooks", "post_hooks"];
+/// Hook keys in the sorted order `validate_model_hook_config` checks them.
+const SORTED_HOOK_KEYS: [&str; 2] = ["post_hooks", "pre_hooks"];
+const MODEL_CONFIG_LABEL: &str = "model config";
+const ENVIRONMENT_DATABASE_LABEL: &str = "environment database";
+const ENVIRONMENT_SCHEMA_LABEL: &str = "environment schema";
 const TAGS_KEY: &str = "tags";
 const ROW_DIFF_EXCLUDE_COLUMNS_KEY: &str = "row_diff_exclude_columns";
 const ROW_DIFF_TOLERANCES_KEY: &str = "row_diff_tolerances";
@@ -47,9 +56,10 @@ const DESTINATION_SCHEMA_CONTEXT: &str = "destination.schema";
 const DESTINATION_TABLE_CONTEXT: &str = "destination.table";
 const DESTINATION_QUALIFIED_CONTEXT: &str = "destination.qualified";
 
-/// Why the native build stops: Python builds this model's config, or a Python error.
+/// Why the native build stops: a deferral to Python, the exact error, or a Python error.
 enum Halt {
     Defer,
+    Config(ConfigError),
     Error(PyErr),
 }
 
@@ -59,19 +69,18 @@ impl From<PyErr> for Halt {
     }
 }
 
-impl From<Stop> for Halt {
-    fn from(stop: Stop) -> Self {
+impl From<ValidationStop> for Halt {
+    fn from(stop: ValidationStop) -> Self {
         match stop {
-            Stop::Failure(_) => Self::Defer,
-            Stop::Python(error) => Self::Error(error),
+            ValidationStop::Defer => Self::Defer,
+            ValidationStop::Error(error) => Self::Config(error),
         }
     }
 }
 
-impl From<TemplateFailure> for Halt {
-    fn from(_: TemplateFailure) -> Self {
-        Self::Defer
-    }
+/// The `CompileInputError` `model '<name>' <text>`, raised by the model config build.
+fn model_error(model_name: &str, text: &str) -> Halt {
+    Halt::Config(ConfigError::compile(format!("model '{model_name}' {text}")))
 }
 
 type Built<T> = Result<T, Halt>;
@@ -132,28 +141,29 @@ impl NativeModelConfigBuilder {
         })
     }
 
-    /// Return `(True, key)` for the selected path default, or `(False, None)` on a conflict.
-    fn path_default(&self, model_path: &str) -> PyResult<(bool, Option<String>)> {
+    /// Return the selected path-default key, `None`, or the conflict error Python raises.
+    fn path_default(&self, py: Python<'_>, model_path: &str) -> PyResult<Py<PyAny>> {
         compiler_guard(|| {
             Ok(match select_path_default(model_path, &self.path_keys) {
-                PathDefaultChoice::Selected(key) => (true, key),
-                PathDefaultChoice::Conflict => (false, None),
+                PathDefaultChoice::Selected(key) => key.into_pyobject(py)?.into_any().unbind(),
+                PathDefaultChoice::Conflict(error) => native_config_error(py, error)?.into_any(),
             })
         })
     }
 
-    /// Return the built config parts, or `None` when Python must build this model's config.
+    /// Return the built config parts, the first error, or `None` when Python must build it.
     fn build<'py>(
         &self,
         py: Python<'py>,
         header: Bound<'py, PyDict>,
         matched_path_default: Option<&str>,
         model_name: &str,
-    ) -> PyResult<Option<Bound<'py, PyTuple>>> {
+    ) -> PyResult<Option<Py<PyAny>>> {
         compiler_guard(
             || match self.build_config(py, &header, matched_path_default, model_name) {
-                Ok(built) => built_tuple(py, built).map(Some),
+                Ok(built) => built_tuple(py, built).map(|built| Some(built.into_any().unbind())),
                 Err(Halt::Defer) => Ok(None),
+                Err(Halt::Config(error)) => Ok(Some(native_config_error(py, error)?.into_any())),
                 Err(Halt::Error(error)) => Err(error),
             },
         )
@@ -168,7 +178,7 @@ impl NativeModelConfigBuilder {
         matched_path_default: Option<&str>,
         model_name: &str,
     ) -> Built<BuiltConfig<'py>> {
-        check_header_tags(header)?;
+        check_header_tags(header, model_name)?;
         let path_values = matched_path_default
             .map(|key| self.path_default_values(py, key))
             .transpose()?;
@@ -177,7 +187,7 @@ impl NativeModelConfigBuilder {
             layered = merged_layer(py, &layered, path_values)?;
         }
         let layered = merged_layer(py, &layered, header)?;
-        self.check_hooks(py, &layered)?;
+        self.check_hooks(py, &layered, model_name)?;
         let mut hooks: Vec<(&str, Bound<'py, PyAny>)> = Vec::new();
         for key in HOOK_KEYS {
             if let Some(value) = layered.get_item(key)? {
@@ -197,20 +207,20 @@ impl NativeModelConfigBuilder {
                 &layered,
                 &self.variables.bind(py).clone(),
                 expansion.run_context()?,
-                true,
+                (true, MODEL_CONFIG_LABEL),
             )?;
             let empty = PyDict::new(py);
             let first = expansion.expand(
                 &early,
                 &empty,
                 expansion.model_context(&early, false)?,
-                true,
+                (true, MODEL_CONFIG_LABEL),
             )?;
             expansion.expand(
                 &first,
                 &empty,
                 expansion.model_context(&first, false)?,
-                true,
+                (true, MODEL_CONFIG_LABEL),
             )?
         } else {
             layered
@@ -238,7 +248,7 @@ impl NativeModelConfigBuilder {
                 &namespaced,
                 &empty,
                 expansion.model_context(&namespaced, true)?,
-                false,
+                (false, MODEL_CONFIG_LABEL),
             )?
         } else {
             namespaced
@@ -247,11 +257,15 @@ impl NativeModelConfigBuilder {
             resolved.set_item(key, value)?;
         }
         let values = storage_free_values(py, &resolved, header)?;
-        let retention = retention_override(header.get_item(RETENTION_KEY)?.map(PyNode).as_ref())
-            .map_err(|_| Halt::Defer)?;
-        let table_type = table_type_override(header.get_item(TABLE_TYPE_KEY)?.map(PyNode).as_ref())
-            .map_err(|_| Halt::Defer)?;
-        check_no_config_macros(py, &values)?;
+        let retention = retention_override(
+            header.get_item(RETENTION_KEY)?.map(PyNode).as_ref(),
+            model_name,
+        )?;
+        let table_type = table_type_override(
+            header.get_item(TABLE_TYPE_KEY)?.map(PyNode).as_ref(),
+            model_name,
+        )?;
+        check_no_config_macros(&values)?;
         Ok(BuiltConfig {
             values,
             header_keys: sorted_keys(header)?,
@@ -283,17 +297,33 @@ impl NativeModelConfigBuilder {
         Ok(defaults)
     }
 
-    /// Accept hook keys `validate_model_hook_config` accepts.
-    fn check_hooks(&self, py: Python<'_>, values: &Bound<'_, PyDict>) -> Built<()> {
+    /// Check hook keys as `validate_model_hook_config` does.
+    fn check_hooks(
+        &self,
+        py: Python<'_>,
+        values: &Bound<'_, PyDict>,
+        model_name: &str,
+    ) -> Built<()> {
         let entry_types = self.hook_entry_types.bind(py);
-        for key in HOOK_KEYS {
+        for key in SORTED_HOOK_KEYS {
             let Some(value) = values.get_item(key)? else {
                 continue;
             };
-            let entries = sequence_items(&value).ok_or(Halt::Defer)?;
+            let Some(entries) = sequence_items(&value) else {
+                return Err(model_error(
+                    model_name,
+                    &format!("{key} must be a list of typed hook entries"),
+                ));
+            };
             for entry in entries {
                 if !entry.is_instance(entry_types)? {
-                    return Err(Halt::Defer);
+                    return Err(model_error(
+                        model_name,
+                        &format!(
+                            "{key} entries must use typed inline_sql(...), sql(...), or \
+                             python(...) hook syntax"
+                        ),
+                    ));
                 }
             }
         }
@@ -310,19 +340,15 @@ struct Expansion<'a, 'py> {
 }
 
 impl<'py> Expansion<'_, 'py> {
+    /// Expand `values`; `scope` is `preserve_unknown_context` and the context label.
     fn expand(
         &mut self,
         values: &Bound<'py, PyDict>,
         variables: &Bound<'py, PyDict>,
         context: Bound<'py, PyDict>,
-        preserve_unknown_context: bool,
+        scope: (bool, &str),
     ) -> Built<Bound<'py, PyDict>> {
-        let result = self.expand_value(
-            values.as_any(),
-            variables,
-            context,
-            preserve_unknown_context,
-        )?;
+        let result = self.expand_value(values.as_any(), variables, context, scope)?;
         result.downcast_into::<PyDict>().map_err(|_| Halt::Defer)
     }
 
@@ -331,8 +357,9 @@ impl<'py> Expansion<'_, 'py> {
         value: &Bound<'py, PyAny>,
         variables: &Bound<'py, PyDict>,
         context: Bound<'py, PyDict>,
-        preserve_unknown_context: bool,
+        scope: (bool, &str),
     ) -> Built<Bound<'py, PyAny>> {
+        let (preserve_unknown_context, label) = scope;
         let environment = self.builder.environment.bind(self.py).clone();
         let host = PythonHost::new(
             self.py,
@@ -345,7 +372,12 @@ impl<'py> Expansion<'_, 'py> {
         };
         let result = expanded(&host, value, options);
         self.reads.extend(host.into_reads());
-        Ok(result?)
+        result.map_err(|stop| match stop {
+            Stop::Failure(failure) => {
+                template_error(&failure, label).map_or(Halt::Defer, Halt::Config)
+            }
+            Stop::Python(error) => Halt::Error(error),
+        })
     }
 
     fn run_context(&self) -> Built<Bound<'py, PyDict>> {
@@ -433,19 +465,38 @@ impl<'py> Expansion<'_, 'py> {
         ];
         let preserved =
             |value: &Bound<'py, PyAny>| PyNode(value.clone()).is_text(PRESERVE_TARGET_VALUE);
-        if namespace
+        let missing: Vec<&str> = namespace
             .iter()
-            .any(|(_, value, logical)| preserved(value) && !logical)
-        {
-            return Err(Halt::Defer);
+            .filter(|(_, value, logical)| preserved(value) && !logical)
+            .map(|(key, _, _)| *key)
+            .collect();
+        if !missing.is_empty() {
+            let dimensions = missing.join(" and ");
+            return Err(Halt::Config(
+                ConfigError::compile(format!(
+                    "Model '{}' has no logical {dimensions}, but the selected target sets \
+                     {dimensions} to 'preserve'",
+                    self.model_name
+                ))
+                .with_help(format!(
+                    "Set {dimensions} on the resource or its defaults, or configure a literal \
+                     target {dimensions}."
+                )),
+            ));
         }
         let context = self.model_context(values, false)?;
         for (key, value, _) in namespace {
             if value.is_none() || preserved(&value) {
                 continue;
             }
+            let label = if key == DATABASE_KEY {
+                ENVIRONMENT_DATABASE_LABEL
+            } else {
+                ENVIRONMENT_SCHEMA_LABEL
+            };
             let variables = self.builder.variables.bind(py).clone();
-            let expanded_value = self.expand_value(&value, &variables, context.copy()?, false)?;
+            let expanded_value =
+                self.expand_value(&value, &variables, context.copy()?, (false, label))?;
             overridden.set_item(key, expanded_value)?;
         }
         Ok(overridden)
@@ -587,16 +638,18 @@ fn entry_has_template(values: &Bound<'_, PyDict>, key: &str) -> Built<bool> {
     }
 }
 
-/// Accept header tags `_validate_model_header_tags` accepts.
-fn check_header_tags(header: &Bound<'_, PyDict>) -> Built<()> {
+/// Check header tags as `_validate_model_header_tags` does.
+fn check_header_tags(header: &Bound<'_, PyDict>, model_name: &str) -> Built<()> {
     let Some(tags) = set_entry(header, TAGS_KEY)? else {
         return Ok(());
     };
-    let tags = tags.downcast::<PyList>().map_err(|_| Halt::Defer)?;
+    let Ok(tags) = tags.downcast::<PyList>() else {
+        return Err(model_error(model_name, "tags must be a list"));
+    };
     if tags.iter().all(|tag| tag.is_instance_of::<PyString>()) {
         Ok(())
     } else {
-        Err(Halt::Defer)
+        Err(model_error(model_name, "tags entries must be strings"))
     }
 }
 
@@ -629,21 +682,15 @@ fn storage_free_values<'py>(
     Ok(values)
 }
 
-/// Defer when config outside hooks holds a macro call `validate_model_config_has_no_macros` rejects.
-fn check_no_config_macros(py: Python<'_>, values: &Bound<'_, PyDict>) -> Built<()> {
-    let scanned = PyList::empty(py);
-    for (key, value) in values.iter() {
-        if !HOOK_KEYS
-            .iter()
-            .any(|hook| PyNode(key.clone()).is_text(hook))
-        {
-            scanned.append(value)?;
-        }
-    }
-    if present(contains_macro_call(&PyNode(scanned.into_any())))? {
-        Err(Halt::Defer)
-    } else {
-        Ok(())
+/// Raise for the first config field outside hooks holding a macro call, as Python's walk does.
+fn check_no_config_macros(values: &Bound<'_, PyDict>) -> Built<()> {
+    match first_macro_path(&PyNode(values.clone().into_any()), &HOOK_KEYS) {
+        MacroPath::Absent => Ok(()),
+        MacroPath::Deferred => Err(Halt::Defer),
+        MacroPath::Found(path) => Err(Halt::Config(ConfigError::compile(format!(
+            "model config field '{}' does not allow macros",
+            path.join(".")
+        )))),
     }
 }
 
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_validator.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_validator.rs
index 72aca263a1..6e40b3e283 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_validator.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/model_validator.rs
@@ -1,17 +1,18 @@
-//! The Python model validators' happy path, decided natively.
+//! The Python model validators, run natively up to the first error they raise.
 
 use std::collections::HashSet;
 
-use pyo3::prelude::{Bound, PyAnyMethods, PyModule, PyModuleMethods, PyResult};
-use pyo3::types::{PyDict, PyDictMethods, PyTuple, PyTupleMethods};
+use pyo3::prelude::{Bound, Py, PyAny, PyAnyMethods, PyModule, PyModuleMethods, PyResult, Python};
+use pyo3::types::{PyBool, PyDict, PyDictMethods, PyTuple, PyTupleMethods};
 use pyo3::{pyclass, pymethods};
-use sqlbuild_model_config::model_validation::main::accept_model_config::accept_model_config;
+use sqlbuild_model_config::model_validation::main::validate_model_config::validate_model_config;
 use sqlbuild_model_config::model_validation::models::{
-    ModelReference, ModelValidationFacts, ProjectValidationFacts, Rejected,
+    ModelReference, ModelValidationFacts, ProjectValidationFacts, ValidationStop,
 };
 
 use crate::bindings::_helpers::boundary::panics::compiler_guard;
 use crate::bindings::_helpers::model_config::authored_nodes::PyNode;
+use crate::bindings::_helpers::model_config::config_errors::native_config_error;
 
 /// Model, seed, source, function and table function names.
 type ResourceNames = (
@@ -53,15 +54,16 @@ impl NativeModelValidator {
         }
     }
 
-    /// Return whether every Python model validator accepts this model; `False` runs them.
-    fn accepts(
+    /// Return `True` when the validators accept, the first error, or `False` to run Python's.
+    fn validate(
         &self,
+        py: Python<'_>,
         values: Bound<'_, PyDict>,
-        model: (String, String),
+        model: (String, String, String),
         facts: ModelFacts<'_>,
-    ) -> PyResult<bool> {
+    ) -> PyResult<Py<PyAny>> {
         compiler_guard(|| {
-            let (model_name, query_sql) = model;
+            let (model_name, query_sql, relative_path) = model;
             let (references, declared_columns, retention_unmanaged, table_type_declared) = facts;
             let references = references
                 .iter()
@@ -78,16 +80,22 @@ impl NativeModelValidator {
                 .collect();
             let facts = ModelValidationFacts {
                 model_name: &model_name,
+                relative_path: &relative_path,
                 references: &references,
                 declared_columns: declared_columns.as_deref(),
                 query_sql: &query_sql,
                 retention_unmanaged,
                 table_type_declared,
             };
-            Ok(match accept_model_config(entries, &self.project, &facts) {
-                Ok(()) => true,
-                Err(Rejected) => false,
-            })
+            Ok(
+                match validate_model_config(entries, &self.project, &facts) {
+                    Ok(()) => PyBool::new(py, true).to_owned().into_any().unbind(),
+                    Err(ValidationStop::Defer) => {
+                        PyBool::new(py, false).to_owned().into_any().unbind()
+                    }
+                    Err(ValidationStop::Error(error)) => native_config_error(py, error)?.into_any(),
+                },
+            )
         })
     }
 }
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/model_config/registration.rs b/crates/sqlbuild-python/src/bindings/_helpers/model_config/registration.rs
index 0e31b5dade..936ccaa273 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/model_config/registration.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/model_config/registration.rs
@@ -3,10 +3,12 @@
 use pyo3::prelude::{Bound, PyModule, PyResult};
 
 use crate::bindings::_helpers::model_config::{
-    config_presence, config_templates, header_metadata, model_config_builder, model_validator,
+    config_errors, config_presence, config_templates, header_metadata, model_config_builder,
+    model_validator,
 };
 
 pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    config_errors::register(module)?;
     header_metadata::register(module)?;
     config_presence::register(module)?;
     config_templates::register(module)?;
diff --git a/scripts/compiler_differential/_helpers/corpus/config_failure_cases.py b/scripts/compiler_differential/_helpers/corpus/config_failure_cases.py
index 688ad48e97..651d227f83 100644
--- a/scripts/compiler_differential/_helpers/corpus/config_failure_cases.py
+++ b/scripts/compiler_differential/_helpers/corpus/config_failure_cases.py
@@ -3,6 +3,7 @@
 from scripts.compiler_differential._helpers.corpus.case_builder import (
     config_files,
     failure_case,
+    mart_body_files,
     staging_files,
 )
 from scripts.compiler_differential.constants import FAILURE_BASE_STAGING
@@ -31,7 +32,14 @@ def _staging_header(extra: str) -> dict[str, str]:
 def config_failure_cases() -> tuple[FailureCase, ...]:
     """Return the model config validator failure cases in a stable order."""
 
-    return (*_layering_cases(), *_incremental_cases(), *_materialization_cases())
+    return (
+        *_layering_cases(),
+        *_incremental_cases(),
+        *_materialization_cases(),
+        *_template_cases(),
+        *_header_metadata_cases(),
+        *_combined_fault_cases(),
+    )
 
 
 def _layering_cases() -> tuple[FailureCase, ...]:
@@ -169,3 +177,130 @@ def _materialization_cases() -> tuple[FailureCase, ...]:
             files=_staging_header("  materialized table,\n  old_name_view soon,"),
         ),
     )
+
+
+def _template_cases() -> tuple[FailureCase, ...]:
+    return (
+        failure_case(
+            name="config-template-unknown-variable",
+            expected_code="P001",
+            expected_message="model config references unknown variable 'missing_region'",
+            files=_staging_header('  schema "${missing_region}_core",'),
+        ),
+        failure_case(
+            name="config-template-unsupported-function",
+            expected_code="P001",
+            expected_message="references unsupported template function 'upper'",
+            files=_staging_header("  alias \"${upper('orders')}\","),
+        ),
+        failure_case(
+            name="config-template-unterminated-string",
+            expected_code="P001",
+            expected_message="unterminated single-quoted string at position 9",
+            files=_staging_header('  alias "${coalesce(\'orders)}",'),
+        ),
+        failure_case(
+            name="config-template-wrong-argument-count",
+            expected_code="P001",
+            expected_message="model config if(...) expects 3 arguments",
+            files=_staging_header("  alias \"${if(true, 'orders')}\","),
+        ),
+        failure_case(
+            name="config-template-missing-environment-variable",
+            expected_code="P001",
+            expected_message="references missing ENV variable 'SQB_CORPUS_UNSET_SCHEMA'",
+            files=_staging_header('  schema "${ENV:SQB_CORPUS_UNSET_SCHEMA}",'),
+        ),
+        failure_case(
+            name="config-template-unknown-namespace",
+            expected_code="P001",
+            expected_message="references unsupported template namespace 'VAULT'",
+            files=_staging_header('  alias "${VAULT:orders}",'),
+        ),
+    )
+
+
+def _header_metadata_cases() -> tuple[FailureCase, ...]:
+    return (
+        failure_case(
+            name="header-column-unknown-metadata-key",
+            expected_code="P001",
+            expected_message="column 'order_id' has unknown metadata keys: format",
+            files=_staging_header("  columns (order_id (type INTEGER, format plain)),"),
+        ),
+        failure_case(
+            name="header-duplicate-column",
+            expected_code="P001",
+            expected_message="has duplicate column 'ORDER_ID'",
+            files=_staging_header("  columns (order_id (type INTEGER), ORDER_ID (type INTEGER)),"),
+        ),
+        failure_case(
+            name="header-column-type-not-text",
+            expected_code="P001",
+            expected_message="column 'order_id' 'type' must be a non-empty string",
+            files=_staging_header("  columns (order_id (type 5)),"),
+        ),
+        failure_case(
+            name="header-audit-severity",
+            expected_code="P001",
+            expected_message="'severity' must be one of: warn, error",
+            files=_staging_header(
+                "  audits [unique_combination (columns [order_id], severity fatal)],"
+            ),
+        ),
+        failure_case(
+            name="header-audit-identity",
+            expected_code="D016",
+            expected_message="Invalid model audit definition identity 'NotNull'",
+            files=_staging_header("  audits [NotNull],"),
+        ),
+        failure_case(
+            name="header-column-audits-not-a-list",
+            expected_code="P001",
+            expected_message="column 'order_id' audits must be a list",
+            files=_staging_header("  columns (order_id (audits not_null)),"),
+        ),
+    )
+
+
+def _combined_fault_cases() -> tuple[FailureCase, ...]:
+    return (
+        failure_case(
+            name="config-several-faults-reports-the-first",
+            expected_code="P001",
+            expected_message="table_type must be permanent, transient, or inherit",
+            files=_staging_header(
+                "  materialized incremental,\n  incremental_strategy upsert,\n"
+                "  cursor_type date,\n  contract strict,\n  table_type temporary,"
+            ),
+        ),
+        failure_case(
+            name="config-cursor-bound-outside-utc-years",
+            expected_code="P001",
+            expected_message="falls outside years 1-9999 once converted to UTC",
+            files=_staging_header(
+                "  materialized incremental,\n  incremental_strategy append,\n"
+                "  cursor placed_at,\n  cursor_type timestamp,\n  cursor_grain day,\n"
+                "  cursor_start '0001-01-01T00:00:00+01:00',\n  cursor_end '2024-01-01',"
+            ),
+        ),
+        failure_case(
+            name="config-unknown-model-reference",
+            expected_code="P001",
+            expected_message="references unknown model 'stg_refunds'",
+            files=mart_body_files(
+                "SELECT customer_id, SUM(amount) AS total_amount\n"
+                'FROM __ref("stg_refunds")\nGROUP BY customer_id\n'
+            ),
+        ),
+        failure_case(
+            name="config-placeholder-on-built-in-materialization",
+            expected_code="P001",
+            expected_message="@@@placeholders are only allowed on custom materializations",
+            files=staging_files(
+                'MODEL (\n  description "Staged orders",\n);\n\n'
+                "SELECT order_id, customer_id, amount, status\n"
+                'FROM __source("raw_orders")\nWHERE status = @@@status\n'
+            ),
+        ),
+    )
diff --git a/src/sqlbuild/_native.pyi b/src/sqlbuild/_native.pyi
index 5dc76a2ff4..04342ef5a4 100644
--- a/src/sqlbuild/_native.pyi
+++ b/src/sqlbuild/_native.pyi
@@ -155,16 +155,28 @@ def build_native_scope_index(
         ]
     ],
 ) -> NativeScopeIndex | None: ...
+
+class NativeConfigError:
+    class_name: str
+    message: str
+    code: str | None
+    help: str | None
+    key: str | None
+
 def parse_model_header_metadata(
-    requests: list[tuple[object, object, dict[str, Any]]], classes: dict[str, object]
-) -> list[tuple[tuple[Any, ...], tuple[Any, ...]] | str]: ...
+    requests: list[tuple[object, object, dict[str, Any], str]], classes: dict[str, object]
+) -> list[
+    tuple[tuple[Any, ...] | NativeConfigError, tuple[Any, ...] | NativeConfigError | None] | str
+]: ...
 def config_contains_template(value: object) -> bool | None: ...
 def config_contains_macro_call(value: object) -> bool | None: ...
 def expand_config_templates(
     value: object,
     sources: tuple[dict[str, object], object, dict[str, str | None]],
-    flags: tuple[bool, bool, bool, str | None],
-) -> tuple[object, list[tuple[str, str]]] | tuple[str, str, list[tuple[str, str]]] | str: ...
+    flags: tuple[bool, bool, bool, str],
+) -> (
+    tuple[object, list[tuple[str, str]]] | tuple[NativeConfigError, list[tuple[str, str]]] | str
+): ...
 
 class NativeModelConfigBuilder:
     def __init__(
@@ -174,7 +186,7 @@ class NativeModelConfigBuilder:
         run: tuple[str | None, str],
         target_namespace: tuple[str | None, str | None] | None,
     ) -> None: ...
-    def path_default(self, model_path: str) -> tuple[bool, str | None]: ...
+    def path_default(self, model_path: str) -> str | NativeConfigError | None: ...
     def build(
         self, header: dict[str, object], matched_path_default: str | None, model_name: str
     ) -> (
@@ -185,6 +197,7 @@ class NativeModelConfigBuilder:
             tuple[tuple[int | None, bool] | None, str | None],
             list[tuple[str, str]],
         ]
+        | NativeConfigError
         | None
     ): ...
 
@@ -195,12 +208,12 @@ class NativeModelValidator:
         custom_materializations: set[str],
         microbatch_concurrency: bool,
     ) -> None: ...
-    def accepts(
+    def validate(
         self,
         values: dict[str, object],
-        model: tuple[str, str],
+        model: tuple[str, str, str],
         facts: tuple[tuple[object, ...], list[str] | None, bool, bool],
-    ) -> bool: ...
+    ) -> bool | NativeConfigError: ...
 
 class SqlReferenceScanner:
     def __init__(self, syntax: dict[str, object]) -> None: ...
diff --git a/src/sqlbuild/compiler/compile/_helpers/attachment/functions.py b/src/sqlbuild/compiler/compile/_helpers/attachment/functions.py
index e1194d71b8..f748035c3f 100644
--- a/src/sqlbuild/compiler/compile/_helpers/attachment/functions.py
+++ b/src/sqlbuild/compiler/compile/_helpers/attachment/functions.py
@@ -879,7 +879,6 @@ def _expand_function_header_value(
             preserve_context_tokens=True,
             preserve_unknown_context=False,
             native=native_stage_enabled(NativeStage.ATTACHMENTS),
-            exact_errors=True,
         )
     )
 
@@ -979,6 +978,5 @@ def _expand_function_environment_value(
             preserve_context_tokens=True,
             preserve_unknown_context=False,
             native=native_stage_enabled(NativeStage.ATTACHMENTS),
-            exact_errors=True,
         )
     )
diff --git a/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py b/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py
index 5ba375aded..9b2f477783 100644
--- a/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py
+++ b/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py
@@ -65,13 +65,13 @@
     PythonHookEntry,
     SqlHookEntry,
 )
-from sqlbuild.compiler.frontier.exceptions import NativeStageMismatchError
 from sqlbuild.compiler.model_config.main._native_config_contains_macro_call import (
     native_config_contains_macro_call,
 )
 from sqlbuild.compiler.model_config.main._native_config_contains_template import (
     native_config_contains_template,
 )
+from sqlbuild.compiler.model_config.main._native_config_error import native_config_error
 from sqlbuild.compiler.model_config.models import NativeHeaderMetadata
 from sqlbuild.compiler.path_defaults.main._select import select_path_default
 from sqlbuild.compiler.planner.types import MaterializationType
@@ -372,9 +372,11 @@ def build_model_header_schema_entry(
         )
         else None
     )
+    if native is not None and native.columns_error is not None:
+        raise native_config_error(error=native.columns_error)
     local_columns: tuple[SchemaColumn, ...] = (
         native.columns
-        if native is not None and not native.invalid
+        if native is not None
         else _parse_model_header_columns(
             raw_columns=raw_columns,
             file_path=file_path,
@@ -393,9 +395,11 @@ def build_model_header_schema_entry(
         model_name=model_name,
         file_path=file_path,
     )
+    if native is not None and native.audits_error is not None:
+        raise native_config_error(error=native.audits_error)
     audits: tuple[SchemaAuditInstance, ...] = (
         native.audits
-        if native is not None and not native.invalid
+        if native is not None
         else parse_audit_instances(
             raw_audits=raw_audits,
             file_path=file_path,
@@ -404,11 +408,6 @@ def build_model_header_schema_entry(
             null_as_empty=True,
         )
     )
-    if native is not None and native.invalid:
-        raise NativeStageMismatchError(
-            f"{file_path}: native model config rejected MODEL columns or audits that the Python "
-            "model config accepts; run with SQLBUILD_COMPILER_ENGINE=python"
-        )
     generated_audits: tuple[SchemaAuditInstance, ...] = parse_model_header_audit_factories(
         raw_audit_factories=raw_audit_factories,
         file_path=file_path,
@@ -910,12 +909,14 @@ def native_model_config_session(
 def native_path_default(
     *, session: NativeModelConfigSession, model_file: DiscoveredSqlModelFile
 ) -> str | None:
-    """Select a model's path default natively; Python reports equally specific matches."""
+    """Select a model's path default natively, raising Python's error for equal matches."""
 
-    selected, key = session.builder.path_default(str(model_file.relative_path))
-    if selected:
-        return key
-    return find_matching_path_default(model_file=model_file, path_defaults=session.path_defaults)
+    selected: str | _native.NativeConfigError | None = session.builder.path_default(
+        str(model_file.relative_path)
+    )
+    if isinstance(selected, _native.NativeConfigError):
+        raise native_config_error(error=selected)
+    return selected
 
 
 def build_native_model_config(
@@ -924,13 +925,15 @@ def build_native_model_config(
     model_file: DiscoveredSqlModelFile,
     matched_path_default: str | None,
 ) -> CompileModelConfig | None:
-    """Build a model's effective config natively, or return None where Python must build it."""
+    """Build a model's effective config natively, raising Python's error; None defers to Python."""
 
-    built: _BuiltConfig | None = session.builder.build(
+    built: _BuiltConfig | _native.NativeConfigError | None = session.builder.build(
         model_file.header_values, matched_path_default, model_file.file_path.stem
     )
     if built is None:
         return None
+    if isinstance(built, _native.NativeConfigError):
+        raise native_config_error(error=built)
     values, header_keys, namespace, overrides, reads = built
     logical_schema, layer_schema_configured, logical_database = namespace
     retention_override, table_type_override = overrides
@@ -969,15 +972,19 @@ def build_native_model_config(
     )
 
 
-def native_model_validators_accept(
+def native_model_validation(
     *, session: NativeModelConfigSession, request: ModelValidationRequest
-) -> bool:
-    """Return whether every Python model validator accepts the model; False runs them."""
+) -> bool | _native.NativeConfigError:
+    """Return True when every model validator accepts, the first error, or False to run Python."""
 
     config: CompileModelConfig = request.config
-    return session.validator.accepts(
+    return session.validator.validate(
         config.values,
-        (request.model_file.file_path.stem, request.query_sql),
+        (
+            request.model_file.file_path.stem,
+            request.query_sql,
+            str(request.model_file.relative_path),
+        ),
         (
             request.references,
             (
@@ -994,12 +1001,16 @@ def native_model_validators_accept(
 def validate_model_config(
     *, context: ModelValidatorContext, request: ModelValidationRequest
 ) -> None:
-    """Validate one model; a native acceptance skips Python, any rejection runs it."""
+    """Validate one model natively, raising the first validator error; deferrals run Python."""
 
-    if context.native_config is not None and native_model_validators_accept(
-        session=context.native_config, request=request
-    ):
-        return
+    if context.native_config is not None:
+        outcome: bool | _native.NativeConfigError = native_model_validation(
+            session=context.native_config, request=request
+        )
+        if isinstance(outcome, _native.NativeConfigError):
+            raise native_config_error(error=outcome, values=request.config.values)
+        if outcome:
+            return
     run_python_model_validators(context=context, request=request)
 
 
diff --git a/src/sqlbuild/compiler/compile/_helpers/attachment/sources.py b/src/sqlbuild/compiler/compile/_helpers/attachment/sources.py
index d784bdbaf0..eee929f819 100644
--- a/src/sqlbuild/compiler/compile/_helpers/attachment/sources.py
+++ b/src/sqlbuild/compiler/compile/_helpers/attachment/sources.py
@@ -329,5 +329,4 @@ def _expand_source_template_object(
         preserve_context_tokens=False,
         preserve_unknown_context=False,
         native=native_stage_enabled(NativeStage.ATTACHMENTS),
-        exact_errors=True,
     )
diff --git a/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py b/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py
index f2aec618f8..57c4f5c21e 100644
--- a/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py
+++ b/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py
@@ -14,13 +14,12 @@
     MISSING_TEMPLATE_VALUE_MESSAGE_PARTS,
     PRESERVE_TARGET_VALUE,
 )
-from sqlbuild.compiler.compile.exceptions import CompileInputError
 from sqlbuild.compiler.compile.types import CompileContextKey
-from sqlbuild.compiler.frontier.exceptions import NativeStageMismatchError
-from sqlbuild.compiler.model_config.constants import ENVIRONMENT_READ, INVALID_OUTCOME
+from sqlbuild.compiler.model_config.constants import ENVIRONMENT_READ
 from sqlbuild.compiler.model_config.main._expand_native_config_templates import (
     expand_native_config_templates,
 )
+from sqlbuild.compiler.model_config.main._native_config_error import native_config_error
 from sqlbuild.compiler.model_config.models import (
     NativeTemplateExpansion,
     NativeTemplateRejection,
@@ -259,9 +258,8 @@ def expand_config_templates(
     preserve_context_tokens: bool,
     preserve_unknown_context: bool,
     native: bool,
-    exact_errors: bool = False,
 ) -> object:
-    """Expand like `expand_template_data`, natively when set; rejections re-run or raise exactly."""
+    """Expand like `expand_template_data`, natively when set; unsupported values run Python."""
 
     outcome: NativeTemplateExpansion | NativeTemplateRejection | str | None = (
         expand_native_config_templates(
@@ -273,11 +271,7 @@ def expand_config_templates(
                 preserve_context_tokens=preserve_context_tokens,
                 preserve_unknown_context=preserve_unknown_context,
             ),
-            context_label=(
-                context_label
-                if exact_errors and not _names_missing_template_value(context_label)
-                else None
-            ),
+            context_label=context_label,
         )
         if native
         else None
@@ -285,10 +279,12 @@ def expand_config_templates(
     if isinstance(outcome, NativeTemplateExpansion):
         record_template_reads(outcome.reads)
         return outcome.value
-    if isinstance(outcome, NativeTemplateRejection):
+    if isinstance(outcome, NativeTemplateRejection) and not _names_missing_template_value(
+        context_label
+    ):
         record_template_reads(outcome.reads)
-        raise CompileInputError(outcome.message, bridge_independent=True)
-    expanded: object = expand_template_data(
+        raise native_config_error(error=outcome.error)
+    return expand_template_data(
         value=value,
         variables=variables,
         context_values=context_values,
@@ -297,12 +293,6 @@ def expand_config_templates(
         preserve_context_tokens=preserve_context_tokens,
         preserve_unknown_context=preserve_unknown_context,
     )
-    if outcome == INVALID_OUTCOME:
-        raise NativeStageMismatchError(
-            f"Native template expansion rejected {context_label} templates that Python "
-            "expands; run with SQLBUILD_COMPILER_ENGINE=python"
-        )
-    return expanded
 
 
 def _names_missing_template_value(context_label: str) -> bool:
diff --git a/src/sqlbuild/compiler/model_config/constants.py b/src/sqlbuild/compiler/model_config/constants.py
index 8d2f14051b..2285951990 100644
--- a/src/sqlbuild/compiler/model_config/constants.py
+++ b/src/sqlbuild/compiler/model_config/constants.py
@@ -25,9 +25,11 @@
     "evidence_limit",
     "location",
 )
-INVALID_OUTCOME: str = "invalid"
 UNSUPPORTED_OUTCOME: str = "unsupported"
 ENVIRONMENT_READ: str = "env"
 COLUMNS_HEADER_KEY: str = "columns"
 AUDITS_HEADER_KEY: str = "audits"
-NATIVE_TEMPLATE_REJECTION_LENGTH: int = 3
+CONFIG_VALUE_TYPE_ERROR: str = "config_value_type"
+RESOURCE_IDENTITY_ERROR: str = "resource_identity"
+DISCOVERY_CONFLICT_ERROR: str = "discovery_conflict"
+EXPECTED_STRING: str = "a string"
diff --git a/src/sqlbuild/compiler/model_config/main/_expand_native_config_templates.py b/src/sqlbuild/compiler/model_config/main/_expand_native_config_templates.py
index 33abc06c47..013d618892 100644
--- a/src/sqlbuild/compiler/model_config/main/_expand_native_config_templates.py
+++ b/src/sqlbuild/compiler/model_config/main/_expand_native_config_templates.py
@@ -6,10 +6,7 @@
 from typing import cast
 
 import sqlbuild._native as _native
-from sqlbuild.compiler.model_config.constants import (
-    NATIVE_TEMPLATE_REJECTION_LENGTH,
-    UNSUPPORTED_OUTCOME,
-)
+from sqlbuild.compiler.model_config.constants import UNSUPPORTED_OUTCOME
 from sqlbuild.compiler.model_config.models import (
     NativeTemplateExpansion,
     NativeTemplateRejection,
@@ -23,14 +20,12 @@ def expand_native_config_templates(
     variables: dict[str, object],
     context_values: dict[str, str | None],
     flags: TemplateResolutionFlags,
-    context_label: str | None = None,
+    context_label: str,
 ) -> NativeTemplateExpansion | NativeTemplateRejection | str:
-    """Return the expansion, a rejection (exact with `context_label`), or `unsupported`."""
+    """Return the expansion, the error Python raises, or `unsupported` (Python must run)."""
 
     try:
-        outcome: (
-            tuple[object, list[tuple[str, str]]] | tuple[str, str, list[tuple[str, str]]] | str
-        ) = _native.expand_config_templates(
+        outcome: tuple[object, list[tuple[str, str]]] | str = _native.expand_config_templates(
             value,
             (variables, os.environ, context_values),
             (
@@ -44,12 +39,8 @@ def expand_native_config_templates(
         return UNSUPPORTED_OUTCOME
     if isinstance(outcome, str):
         return outcome
-    if len(outcome) == NATIVE_TEMPLATE_REJECTION_LENGTH:
-        rejection: tuple[str, str, list[tuple[str, str]]] = cast(
-            tuple[str, str, list[tuple[str, str]]], outcome
+    if isinstance(outcome[0], _native.NativeConfigError):
+        return NativeTemplateRejection(
+            error=cast(_native.NativeConfigError, outcome[0]), reads=tuple(outcome[1])
         )
-        return NativeTemplateRejection(message=rejection[1], reads=tuple(rejection[2]))
-    expansion: tuple[object, list[tuple[str, str]]] = cast(
-        tuple[object, list[tuple[str, str]]], outcome
-    )
-    return NativeTemplateExpansion(value=expansion[0], reads=tuple(expansion[1]))
+    return NativeTemplateExpansion(value=outcome[0], reads=tuple(outcome[1]))
diff --git a/src/sqlbuild/compiler/model_config/main/_native_config_error.py b/src/sqlbuild/compiler/model_config/main/_native_config_error.py
new file mode 100644
index 0000000000..f1b42f5d68
--- /dev/null
+++ b/src/sqlbuild/compiler/model_config/main/_native_config_error.py
@@ -0,0 +1,35 @@
+"""Raise a native config stage's exact error as the Python stage raises it."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+import sqlbuild._native as _native
+from sqlbuild.compiler.compile.exceptions import CompileInputError
+from sqlbuild.compiler.discovery.exceptions import DiscoveryConflictError
+from sqlbuild.compiler.model_config.constants import (
+    CONFIG_VALUE_TYPE_ERROR,
+    DISCOVERY_CONFLICT_ERROR,
+    EXPECTED_STRING,
+    RESOURCE_IDENTITY_ERROR,
+)
+from sqlbuild.compiler.resource_names.exceptions import ResourceIdentityError
+from sqlbuild.spec.contracts.exceptions import ConfigValueTypeError
+
+
+def native_config_error(
+    *, error: _native.NativeConfigError, values: Mapping[str, object] | None = None
+) -> Exception:
+    """Return the exception Python raises for `error`; `values` holds a mistyped config key."""
+
+    if error.class_name == CONFIG_VALUE_TYPE_ERROR and error.key is not None and values is not None:
+        return ConfigValueTypeError(
+            key=error.key, expected=EXPECTED_STRING, actual_type=type(values[error.key])
+        )
+    if error.class_name == RESOURCE_IDENTITY_ERROR:
+        return ResourceIdentityError(error.message, help=error.help)
+    if error.class_name == DISCOVERY_CONFLICT_ERROR:
+        return DiscoveryConflictError(error.message, help=error.help)
+    return CompileInputError(
+        error.message, code=error.code, help=error.help, bridge_independent=True
+    )
diff --git a/src/sqlbuild/compiler/model_config/main/_parse_native_header_metadata.py b/src/sqlbuild/compiler/model_config/main/_parse_native_header_metadata.py
index 626043f964..6314d37b52 100644
--- a/src/sqlbuild/compiler/model_config/main/_parse_native_header_metadata.py
+++ b/src/sqlbuild/compiler/model_config/main/_parse_native_header_metadata.py
@@ -12,12 +12,12 @@
 from sqlbuild.compiler.model_config.constants import (
     AUDITS_HEADER_KEY,
     COLUMNS_HEADER_KEY,
-    INVALID_OUTCOME,
     SCHEMA_AUDIT_INSTANCE_FIELDS,
     SCHEMA_COLUMN_FIELDS,
     UNSUPPORTED_OUTCOME,
 )
 from sqlbuild.compiler.model_config.models import NativeHeaderMetadata
+from sqlbuild.compiler.model_config.types import NativeHeaderMetadataRow
 from sqlbuild.spec.contracts.models import SchemaAuditInstance, SchemaColumn
 
 
@@ -29,23 +29,22 @@ def parse_native_header_metadata(
     if not model_files or not _contract_shapes_match():
         return {}
     try:
-        parsed: list[tuple[tuple[SchemaColumn, ...], tuple[SchemaAuditInstance, ...]] | str] = (
-            _native.parse_model_header_metadata(
-                [
-                    (
-                        model_file.header_values.get(COLUMNS_HEADER_KEY),
-                        model_file.header_values.get(AUDITS_HEADER_KEY),
-                        model_file.header_column_locations,
-                    )
-                    for model_file in model_files
-                ],
-                {
-                    "schema_column": SchemaColumn,
-                    "schema_audit_instance": SchemaAuditInstance,
-                    "severities": {severity.value: severity for severity in AuditSeverity},
-                    "allocate": object.__new__,
-                },
-            )
+        parsed: list[NativeHeaderMetadataRow | str] = _native.parse_model_header_metadata(
+            [
+                (
+                    model_file.header_values.get(COLUMNS_HEADER_KEY),
+                    model_file.header_values.get(AUDITS_HEADER_KEY),
+                    model_file.header_column_locations,
+                    str(model_file.relative_path),
+                )
+                for model_file in model_files
+            ],
+            {
+                "schema_column": SchemaColumn,
+                "schema_audit_instance": SchemaAuditInstance,
+                "severities": {severity.value: severity for severity in AuditSeverity},
+                "allocate": object.__new__,
+            },
         )
     except (TypeError, ValueError):
         return {}
@@ -57,18 +56,17 @@ def parse_native_header_metadata(
 
 
 def _native_metadata(
-    *,
-    model_file: DiscoveredSqlModelFile,
-    metadata: tuple[tuple[SchemaColumn, ...], tuple[SchemaAuditInstance, ...]] | str,
+    *, model_file: DiscoveredSqlModelFile, metadata: NativeHeaderMetadataRow | str
 ) -> NativeHeaderMetadata:
     columns, audits = ((), ()) if isinstance(metadata, str) else metadata
     return NativeHeaderMetadata(
         raw_columns=model_file.header_values.get(COLUMNS_HEADER_KEY),
         raw_audits=model_file.header_values.get(AUDITS_HEADER_KEY),
         column_locations=model_file.header_column_locations,
-        columns=columns,
-        audits=audits,
-        invalid=metadata == INVALID_OUTCOME,
+        columns=() if isinstance(columns, _native.NativeConfigError) else columns,
+        audits=() if audits is None or isinstance(audits, _native.NativeConfigError) else audits,
+        columns_error=columns if isinstance(columns, _native.NativeConfigError) else None,
+        audits_error=audits if isinstance(audits, _native.NativeConfigError) else None,
     )
 
 
diff --git a/src/sqlbuild/compiler/model_config/models.py b/src/sqlbuild/compiler/model_config/models.py
index 795ca9afdc..b69ceb9c9d 100644
--- a/src/sqlbuild/compiler/model_config/models.py
+++ b/src/sqlbuild/compiler/model_config/models.py
@@ -4,19 +4,21 @@
 
 from dataclasses import dataclass
 
+import sqlbuild._native as _native
 from sqlbuild.spec.contracts.models import SchemaAuditInstance, SchemaColumn, SourceLocation
 
 
 @dataclass(frozen=True, slots=True)
 class NativeHeaderMetadata:
-    """One model's header columns and audits; `invalid` means Python must parse them and raise."""
+    """One model's header columns and audits, or the error Python raises parsing each."""
 
     raw_columns: object | None
     raw_audits: object | None
     column_locations: dict[str, SourceLocation]
     columns: tuple[SchemaColumn, ...]
     audits: tuple[SchemaAuditInstance, ...]
-    invalid: bool = False
+    columns_error: _native.NativeConfigError | None = None
+    audits_error: _native.NativeConfigError | None = None
 
     def applies_to(
         self,
@@ -46,7 +48,7 @@ class NativeTemplateExpansion:
 class NativeTemplateRejection:
     """Python's exact template error for a config value and the names read before it, in order."""
 
-    message: str
+    error: _native.NativeConfigError
     reads: tuple[tuple[str, str], ...]
 
 
diff --git a/src/sqlbuild/compiler/model_config/types.py b/src/sqlbuild/compiler/model_config/types.py
new file mode 100644
index 0000000000..7a0b52867a
--- /dev/null
+++ b/src/sqlbuild/compiler/model_config/types.py
@@ -0,0 +1,11 @@
+"""Shapes the native model config bindings return."""
+
+from __future__ import annotations
+
+import sqlbuild._native as _native
+from sqlbuild.spec.contracts.models import SchemaAuditInstance, SchemaColumn
+
+type NativeHeaderMetadataRow = tuple[
+    tuple[SchemaColumn, ...] | _native.NativeConfigError,
+    tuple[SchemaAuditInstance, ...] | _native.NativeConfigError | None,
+]
diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py
index bc3989c839..b28cfaa5af 100644
--- a/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py
+++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py
@@ -908,6 +908,17 @@ class NativeDeclarationErrorTestCase:
     expected_macro_calls: int
 
 
+@dataclass(frozen=True)
+class NativeConfigErrorTestCase:
+    """A failing project whose model config error both engines must report the same way."""
+
+    description: str
+    project_files: dict[str, str]
+    expected_report_text: str
+    expected_macro_calls: int
+    expected_python_fallbacks: list[str]
+
+
 @dataclass(frozen=True)
 class DeclarationErrorLifecycleTestCase:
     """A failing project whose invocation lifecycle every engine must report the same way."""
diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/helpers.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/helpers.py
index 0acd2a0030..91826449b3 100644
--- a/tests/e2e/src/sqlbuild/cli/commands/main/compile/helpers.py
+++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/helpers.py
@@ -48,6 +48,7 @@
 from scripts.cold_compile_performance.main.semantic_compile_fingerprint import (
     semantic_compile_fingerprint,
 )
+from scripts.compiler_differential.constants import FAILURE_BASE_FILES
 from sqlbuild.adapter.contract.classes.duckdb_backed_adapter import DuckDbBackedAdapter
 from sqlbuild.cli.commands.main.entrypoint.entry import main
 from sqlbuild.cli.compile_reuse._helpers.entry_file import (
@@ -4924,3 +4925,55 @@ def lifecycle_error_type(*, project_dir: Path, engine: str, monkeypatch: pytest.
         with redirect_stdout(StringIO()):
             _ = main(["--project-dir", str(project_dir), "--no-color", "compile"])
     return str(published[-1].payload.get("error_type"))
+
+
+def fallback_free_preview_compile(
+    *,
+    project_dir: Path,
+    fallbacks: tuple[tuple[ModuleType, str], ...],
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> tuple[CompileReuseRun, list[str]]:
+    """Compile under native-preview in this process; return the run and fallbacks it called."""
+
+    called: list[str] = []
+
+    def recorder(name: str) -> Callable[..., object]:
+        def fallback(**_kwargs: object) -> object:
+            called.append(name)
+            raise AssertionError(name)
+
+        return fallback
+
+    with monkeypatch.context() as patch:
+        for module, name in fallbacks:
+            patch.setattr(module, name, recorder(name))
+        for variable, value in {
+            COMPILER_ENGINE_ENV_VAR: "native-preview",
+            REUSE_DISABLE_ENV_VAR: "1",
+        }.items():
+            patch.setenv(variable, value)
+        run: CompileReuseRun = in_process_reuse_run(project_dir=project_dir, capsys=capsys)
+    return run, called
+
+
+def python_engine_compile(
+    *, project_dir: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> CompileReuseRun:
+    """Compile under the Python engine in this process."""
+
+    with monkeypatch.context() as patch:
+        for variable, value in {
+            COMPILER_ENGINE_ENV_VAR: "python",
+            REUSE_DISABLE_ENV_VAR: "1",
+        }.items():
+            patch.setenv(variable, value)
+        return in_process_reuse_run(project_dir=project_dir, capsys=capsys)
+
+
+def write_counted_error_project(*, project_dir: Path, files: dict[str, str]) -> None:
+    """Write the failure base project with `files` added or replaced into a fresh directory."""
+
+    shutil.rmtree(project_dir, ignore_errors=True)
+    for relative_path, contents in {**FAILURE_BASE_FILES, **files}.items():
+        write_project_file(project_dir, relative_path, contents)
diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py
new file mode 100644
index 0000000000..279eb8aa27
--- /dev/null
+++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py
@@ -0,0 +1,180 @@
+"""The preview engine reports model config, template and header errors as Python does, once."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+import sqlbuild.compiler.compile._helpers.attachment.core as attachment_core
+import sqlbuild.compiler.compile._helpers.attachment.model_config as model_config
+import sqlbuild.compiler.compile._helpers.render.context_templates as context_templates
+from scripts.compiler_differential.constants import FAILURE_BASE_MART
+from tests.e2e.src.sqlbuild.cli.commands.main.compile._test_types import (
+    NativeConfigErrorTestCase,
+)
+from tests.e2e.src.sqlbuild.cli.commands.main.compile.helpers import (
+    CompileReuseRun,
+    fallback_free_preview_compile,
+    python_engine_compile,
+    report_without_engine,
+    run_reuse_compile,
+    stderr_without_durations,
+    write_counted_error_project,
+)
+
+_ENGINES: tuple[str, str] = ("python", "native-preview")
+_CALL_LOG: str = "macro_calls.log"
+_COUNTED_MACRO: str = (
+    "from pathlib import Path\n\n\n"
+    "def counted(expression: str) -> str:\n"
+    '    """Return the expression, logging each execution."""\n\n'
+    f"    with (Path(__file__).resolve().parents[1] / {_CALL_LOG!r}).open(\n"
+    '        "a", encoding="utf-8"\n'
+    "    ) as log:\n"
+    '        _ = log.write("call\\n")\n'
+    "    return expression\n"
+)
+_COUNTED_MART: str = FAILURE_BASE_MART.replace("SUM(amount)", "SUM(@counted('amount'))")
+_STAGING_PATH: str = "models/staging/stg_orders.sql"
+_STAGING_BODY: str = (
+    '\n);\n\nSELECT order_id, customer_id, amount, status\nFROM __source("raw_orders")\n'
+)
+_INCREMENTAL: str = (
+    "  materialized incremental,\n  incremental_strategy append,\n  cursor order_id,\n"
+    "  cursor_type integer,\n"
+)
+_FALLBACKS: tuple[tuple[ModuleType, str], ...] = (
+    (model_config, "run_python_model_validators"),
+    (model_config, "_parse_model_header_columns"),
+    (model_config, "parse_audit_instances"),
+    (attachment_core, "build_model_config"),
+    (context_templates, "expand_template_data"),
+)
+_PROJECT_FILES: dict[str, str] = {
+    "macros/counted.py": _COUNTED_MACRO,
+    "models/marts/customer_totals.sql": _COUNTED_MART,
+    _CALL_LOG: "",
+}
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        NativeConfigErrorTestCase(
+            description="validator_error_after_a_macro_ran",
+            project_files={
+                _STAGING_PATH: "MODEL (\n  materialized incremental,\n  incremental_strategy upsert,"
+                + _STAGING_BODY
+            },
+            expected_report_text="unknown incremental_strategy 'upsert'",
+            expected_macro_calls=1,
+            expected_python_fallbacks=[],
+        ),
+        NativeConfigErrorTestCase(
+            description="first_of_several_validator_faults",
+            project_files={
+                _STAGING_PATH: "MODEL (\n"
+                + _INCREMENTAL
+                + "  cursor_start 20,\n  cursor_end 10,\n  contract strict,"
+                + _STAGING_BODY
+            },
+            expected_report_text="cursor_start must be before exclusive cursor_end",
+            expected_macro_calls=1,
+            expected_python_fallbacks=[],
+        ),
+        NativeConfigErrorTestCase(
+            description="template_error_after_a_macro_ran",
+            project_files={
+                _STAGING_PATH: 'MODEL (\n  schema "${missing_region}_core",' + _STAGING_BODY
+            },
+            expected_report_text="model config references unknown variable 'missing_region'",
+            expected_macro_calls=1,
+            expected_python_fallbacks=[],
+        ),
+        NativeConfigErrorTestCase(
+            description="header_column_error_after_a_macro_ran",
+            project_files={
+                _STAGING_PATH: "MODEL (\n  columns (order_id (type INTEGER, format plain)),"
+                + _STAGING_BODY
+            },
+            expected_report_text="column 'order_id' has unknown metadata keys: format",
+            expected_macro_calls=1,
+            expected_python_fallbacks=[],
+        ),
+        NativeConfigErrorTestCase(
+            description="header_audit_error_after_a_macro_ran",
+            project_files={
+                _STAGING_PATH: "MODEL (\n  audits [unique_combination (columns [order_id], "
+                "severity fatal)]," + _STAGING_BODY
+            },
+            expected_report_text="'severity' must be one of: warn, error",
+            expected_macro_calls=1,
+            expected_python_fallbacks=[],
+        ),
+        NativeConfigErrorTestCase(
+            description="config_build_error_after_a_macro_ran",
+            project_files={_STAGING_PATH: 'MODEL (\n  tags "orders",' + _STAGING_BODY},
+            expected_report_text="tags must be a list",
+            expected_macro_calls=1,
+            expected_python_fallbacks=[],
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_config_error_when_compiling_with_preview_then_error_matches_python_once(
+    test_case: NativeConfigErrorTestCase,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    project_dir: Path = tmp_path / "orders"
+    runs: list[CompileReuseRun] = []
+    macro_calls: list[int] = []
+    for engine in _ENGINES:
+        write_counted_error_project(
+            project_dir=project_dir, files={**_PROJECT_FILES, **test_case.project_files}
+        )
+        runs.append(
+            run_reuse_compile(project_dir=project_dir, global_args=("--compiler-engine", engine))
+        )
+        macro_calls.append(len((project_dir / _CALL_LOG).read_text(encoding="utf-8").splitlines()))
+    for name in ("python", "preview"):
+        write_counted_error_project(
+            project_dir=tmp_path / name, files={**_PROJECT_FILES, **test_case.project_files}
+        )
+    python_run: CompileReuseRun = python_engine_compile(
+        project_dir=tmp_path / "python", monkeypatch=monkeypatch, capsys=capsys
+    )
+    preview_run, fallbacks = fallback_free_preview_compile(
+        project_dir=tmp_path / "preview",
+        fallbacks=_FALLBACKS,
+        monkeypatch=monkeypatch,
+        capsys=capsys,
+    )
+
+    assert (
+        tuple(run.returncode for run in runs),
+        report_without_engine(runs[1]) == report_without_engine(runs[0]),
+        stderr_without_durations(stderr=runs[1].stderr)
+        == stderr_without_durations(stderr=runs[0].stderr),
+        test_case.expected_report_text in runs[0].report + runs[0].stderr,
+        macro_calls,
+        preview_run.returncode,
+        report_without_engine(preview_run).replace("preview", "python"),
+        fallbacks,
+    ) == (
+        (1, 1),
+        True,
+        True,
+        True,
+        [test_case.expected_macro_calls] * 2,
+        python_run.returncode,
+        report_without_engine(python_run).replace("preview", "python"),
+        test_case.expected_python_fallbacks,
+    ), (runs[0].report, runs[1].report, runs[1].stderr)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-vv"])
diff --git a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/_test_types.py b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/_test_types.py
index aaaaac98ca..4c46aa9acf 100644
--- a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/_test_types.py
+++ b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/_test_types.py
@@ -15,6 +15,7 @@ class ModelValidationParityTestCase:
     expected_minimum_native_accepted: int
     expected_minimum_python_rejected: int
     expected_minimum_acceptance_percent: int
+    expected_minimum_error_percent: int
 
 
 @dataclass(frozen=True)
@@ -27,6 +28,7 @@ class ModelConfigBuildParityTestCase:
     expected_minimum_built: int
     expected_minimum_python_raised: int
     expected_minimum_build_percent: int
+    expected_minimum_error_percent: int
 
 
 @dataclass(frozen=True)
@@ -39,10 +41,10 @@ class ModelConfigProjectTestCase:
 
 
 @dataclass(frozen=True)
-class NativeRejectionParityTestCase:
-    """A config native validation must reject so Python reports its exact outcome."""
+class NativeErrorParityTestCase:
+    """An invalid config whose native outcome must be Python's exact error or a deferral."""
 
     description: str
     values: dict[str, object]
-    expected_native_accepted: bool
-    expected_python_error: str
+    expected_native_outcome: object
+    expected_python_outcome: object
diff --git a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py
index f33aa3c4b9..0b2308f429 100644
--- a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py
+++ b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py
@@ -10,12 +10,13 @@
 from pathlib import Path
 from typing import cast
 
+import sqlbuild._native as _native
 from sqlbuild.compiler.compile._helpers.attachment.core import build_model_config
 from sqlbuild.compiler.compile._helpers.attachment.model_config import (
     build_native_model_config,
     find_matching_path_default,
     native_model_config_session,
-    native_model_validators_accept,
+    native_model_validation,
     native_path_default,
     run_python_model_validators,
 )
@@ -36,6 +37,7 @@
     PythonHookEntry,
     SqlHookEntry,
 )
+from sqlbuild.compiler.model_config.main._native_config_error import native_config_error
 from sqlbuild.spec.contracts.models import (
     AuthoredTimeTravelRetention,
     DefaultsConfig,
@@ -51,7 +53,7 @@
 from sqlbuild.spec.contracts.types import TableType, TableTypeSource
 
 _ABSENT: object = object()
-_RAISES: str = "Python raises"
+_ACCEPTED: str = "accepted"
 _DEFERRED: str = "native defers"
 _HOOK_KEYS: frozenset[str] = frozenset({"pre_hooks", "post_hooks"})
 _RUN_ID: str = "20261008T000000Z_orders"
@@ -294,8 +296,9 @@ def _reference(kind: str, name: str) -> CompileSqlReference:
 class ModelValidationParity:
     """How native validation compared with the Python validators over one corpus."""
 
-    mismatches: list[dict[str, object]]
+    mismatches: list[tuple[object, object, object]]
     native_accepted: int
+    native_errors: int
     python_accepted: int
     python_rejected: int
 
@@ -316,6 +319,7 @@ class ModelConfigBuildParity:
 
     mismatches: list[tuple[object, object, object]]
     built: int
+    native_errors: int
     deferred: int
     python_raised: int
 
@@ -329,30 +333,36 @@ def generated_validation_requests(
 
 
 def model_validation_parity(*, requests: list[ModelValidationRequest]) -> ModelValidationParity:
-    """Validate natively and in Python; native may reject valid configs but never accept invalid."""
+    """Validate natively and in Python; native may defer but never differ from Python."""
 
     session: NativeModelConfigSession = _session(
         project_config=ProjectConfig(name="orders", adapter="duckdb"),
         target_config=None,
         effective_target_name=None,
     )
-    native: list[bool] = [
-        native_model_validators_accept(session=session, request=request) for request in requests
-    ]
-    python: list[bool] = [_python_accepts(request) for request in requests]
-    wrongly_accepted: list[bool] = [
-        accepted and not valid for accepted, valid in zip(native, python, strict=True)
+    outcomes: list[tuple[object, object, object]] = [
+        (
+            request.config.values,
+            _python_validation(request),
+            _native_validation(session=session, request=request),
+        )
+        for request in requests
     ]
     return ModelValidationParity(
-        mismatches=[request.config.values for request in compress(requests, wrongly_accepted)],
-        native_accepted=sum(native),
-        python_accepted=sum(python),
-        python_rejected=len(python) - sum(python),
+        mismatches=list(
+            compress(
+                outcomes, [native not in (_DEFERRED, python) for _, python, native in outcomes]
+            )
+        ),
+        native_accepted=sum(native == _ACCEPTED for _, _, native in outcomes),
+        native_errors=sum(native not in (_ACCEPTED, _DEFERRED) for _, _, native in outcomes),
+        python_accepted=sum(python == _ACCEPTED for _, python, _ in outcomes),
+        python_rejected=sum(python != _ACCEPTED for _, python, _ in outcomes),
     )
 
 
-def validation_outcomes(*, values: dict[str, object]) -> tuple[bool, str]:
-    """Return whether native validation accepts `values` and the Python validators' error."""
+def validation_outcomes(*, values: dict[str, object]) -> tuple[object, object]:
+    """Return native validation's outcome for `values` and the Python validators' outcome."""
 
     request: ModelValidationRequest = ModelValidationRequest(
         model_file=_model_file(relative_path="marts/orders_daily.sql", header_values={}),
@@ -366,24 +376,68 @@ def validation_outcomes(*, values: dict[str, object]) -> tuple[bool, str]:
         target_config=None,
         effective_target_name=None,
     )
+    return (_native_validation(session=session, request=request), _python_validation(request))
+
+
+def header_help(*, purpose: str, entry: str) -> str:
+    """Return the help that shows the exact MODEL header entry to add."""
+
+    indent: str = " " * 12
+    return (
+        f"{purpose}, add this to the MODEL header:\n{indent}MODEL (\n"
+        f"{indent}  {entry},\n{indent}  ...\n{indent});"
+    )
+
+
+def raised_error_shape(error: Exception) -> tuple[object, ...]:
+    """Return the type, message, code and help of an error, and whether it skips the bridge."""
+
+    bridge_independent: object = getattr(error, "bridge_independent", None)
     return (
-        native_model_validators_accept(session=session, request=request),
-        _python_error(request),
+        type(error).__name__,
+        str(error),
+        getattr(error, "code", None),
+        getattr(error, "help", None),
+        bridge_independent,
     )
 
 
-def _python_error(request: ModelValidationRequest) -> str:
+def _python_error_shape(error: Exception) -> tuple[object, ...]:
+    shape: tuple[object, ...] = raised_error_shape(error)
+    return (*shape[:4], shape[4] is not None or None)
+
+
+def _python_validation(request: ModelValidationRequest) -> object:
     try:
         run_python_model_validators(context=_VALIDATOR_CONTEXT, request=request)
     except Exception as error:  # noqa: BLE001 - the exact Python outcome, whatever it is
-        return f"{type(error).__name__}: {error}"
-    return "accepted"
+        return _python_error_shape(error)
+    return _ACCEPTED
+
+
+def _native_validation(
+    *, session: NativeModelConfigSession, request: ModelValidationRequest
+) -> object:
+    outcome: bool | _native.NativeConfigError = native_model_validation(
+        session=session, request=request
+    )
+    errors: list[object] = [
+        raised_error_shape(
+            native_config_error(
+                error=cast(_native.NativeConfigError, error), values=request.config.values
+            )
+        )
+        for error in compress([outcome], [isinstance(outcome, _native.NativeConfigError)])
+    ]
+    return (*errors, {True: _ACCEPTED, False: _DEFERRED}[outcome is True])[0]
 
 
 def _validation_request(*, rng: random.Random) -> ModelValidationRequest:
     profile, references = rng.choice(_PROFILES)
     values: dict[str, object] = dict(profile)
-    mutated: list[str] = rng.sample(sorted(_VALIDATION_POOLS), k=rng.choice((0, 0, 1, 1, 2, 3)))
+    mutated: list[str] = rng.sample(
+        sorted(_VALIDATION_POOLS), k=rng.choice((0, 0, 1, 1, 2, 3, 5, 8))
+    )
     values.update((key, rng.choice(_VALIDATION_POOLS[key])) for key in mutated)
     return ModelValidationRequest(
         model_file=_model_file(relative_path="marts/orders_daily.sql", header_values={}),
@@ -402,14 +456,6 @@ def _validation_request(*, rng: random.Random) -> ModelValidationRequest:
     )
 
 
-def _python_accepts(request: ModelValidationRequest) -> bool:
-    try:
-        run_python_model_validators(context=_VALIDATOR_CONTEXT, request=request)
-    except Exception:  # noqa: BLE001 - any Python failure means native must not accept
-        return False
-    return True
-
-
 _DEFAULTS: tuple[DefaultsConfig, ...] = (
     DefaultsConfig(),
     DefaultsConfig(materialized="table", schema="analytics", tags=("core",)),
@@ -515,9 +561,10 @@ def model_config_build_parity(*, cases: list[ConfigBuildCase]) -> ModelConfigBui
                 [native not in (_DEFERRED, python) for _, python, native in outcomes],
             )
         ),
-        built=sum(native not in (_DEFERRED, _RAISES) for _, _, native in outcomes),
+        built=sum(isinstance(native, list) for _, _, native in outcomes),
+        native_errors=sum(isinstance(native, tuple) for _, _, native in outcomes),
         deferred=sum(native == _DEFERRED for _, _, native in outcomes),
-        python_raised=sum(python == _RAISES for _, python, _ in outcomes),
+        python_raised=sum(isinstance(python, tuple) for _, python, _ in outcomes),
     )
 
 
@@ -560,9 +607,9 @@ def _python_build(case: ConfigBuildCase) -> object:
                     materialization_defaults=case.project_config.materialization_defaults,
                 )
             )
-        except Exception:  # noqa: BLE001 - every Python failure must stop the native build too
-            return _RAISES
-    return (_config_shape(config), reads.environment_names, reads.read_run_id)
+        except Exception as error:  # noqa: BLE001 - the exact Python outcome, whatever it is
+            return _python_error_shape(error)
+    return [_config_shape(config), reads.environment_names, reads.read_run_id]
 
 
 def _native_build(case: ConfigBuildCase) -> object:
@@ -574,13 +621,13 @@ def _native_build(case: ConfigBuildCase) -> object:
     with COMPILE_INPUT_READS.recording() as reads:
         try:
             matched: str | None = native_path_default(session=session, model_file=case.model_file)
-        except Exception:  # noqa: BLE001 - path conflicts are reported by Python
-            return _RAISES
-        config: CompileModelConfig | None = build_native_model_config(
-            session=session, model_file=case.model_file, matched_path_default=matched
-        )
+            config: CompileModelConfig | None = build_native_model_config(
+                session=session, model_file=case.model_file, matched_path_default=matched
+            )
+        except Exception as error:  # noqa: BLE001 - the exact native outcome, whatever it is
+            return raised_error_shape(error)
     shapes: list[object] = [
-        (_config_shape(built), reads.environment_names, reads.read_run_id)
+        [_config_shape(built), reads.environment_names, reads.read_run_id]
         for built in cast(list[CompileModelConfig], list(compress([config], [config is not None])))
     ]
     return (*shapes, _DEFERRED)[0]
diff --git a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py
index 2d141ae4e5..e215ef7660 100644
--- a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py
+++ b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py
@@ -9,7 +9,7 @@
 from tests.integration.src.sqlbuild.compiler.compile.native_model_config._test_types import (
     ModelConfigBuildParityTestCase,
     ModelValidationParityTestCase,
-    NativeRejectionParityTestCase,
+    NativeErrorParityTestCase,
 )
 from tests.integration.src.sqlbuild.compiler.compile.native_model_config.helpers import (
     BUILD_ENVIRONMENT,
@@ -17,11 +17,20 @@
     ModelValidationParity,
     generated_config_builds,
     generated_validation_requests,
+    header_help,
     model_config_build_parity,
     model_validation_parity,
     validation_outcomes,
 )
 
+_INCREMENTAL: dict[str, object] = {
+    "materialized": "incremental",
+    "incremental_strategy": "append",
+    "cursor": "updated_at",
+    "cursor_type": "timestamp",
+    "cursor_grain": "day",
+}
+
 
 @pytest.mark.parametrize(
     "test_case",
@@ -30,14 +39,15 @@
             description="seeded profiles with invalid and unusual values",
             seed=20261008,
             count=6000,
-            expected_minimum_native_accepted=1500,
+            expected_minimum_native_accepted=1000,
             expected_minimum_python_rejected=1500,
             expected_minimum_acceptance_percent=90,
+            expected_minimum_error_percent=85,
         )
     ],
     ids=lambda case: case.description,
 )
-def test_given_generated_configs_when_validating_then_native_accepts_only_what_python_accepts(
+def test_given_generated_configs_when_validating_then_native_matches_python_or_defers(
     test_case: ModelValidationParityTestCase,
 ) -> None:
     parity: ModelValidationParity = model_validation_parity(
@@ -47,13 +57,16 @@ def test_given_generated_configs_when_validating_then_native_accepts_only_what_p
     )
 
     assert (
-        parity.mismatches,
+        parity.mismatches[:3],
         parity.native_accepted >= test_case.expected_minimum_native_accepted,
         parity.python_rejected >= test_case.expected_minimum_python_rejected,
         parity.native_accepted * 100
         >= parity.python_accepted * test_case.expected_minimum_acceptance_percent,
-    ) == ([], True, True, True), (
+        parity.native_errors * 100
+        >= parity.python_rejected * test_case.expected_minimum_error_percent,
+    ) == ([], True, True, True, True), (
         parity.native_accepted,
+        parity.native_errors,
         parity.python_accepted,
         parity.python_rejected,
     )
@@ -69,6 +82,7 @@ def test_given_generated_configs_when_validating_then_native_accepts_only_what_p
             expected_minimum_built=2000,
             expected_minimum_python_raised=500,
             expected_minimum_build_percent=90,
+            expected_minimum_error_percent=80,
         )
     ],
     ids=lambda case: case.description,
@@ -89,47 +103,100 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
         parity.python_raised >= test_case.expected_minimum_python_raised,
         parity.built * 100
         >= (test_case.count - parity.python_raised) * test_case.expected_minimum_build_percent,
-    ) == ([], True, True, True), (parity.built, parity.deferred, parity.python_raised)
+        parity.native_errors * 100
+        >= parity.python_raised * test_case.expected_minimum_error_percent,
+    ) == ([], True, True, True, True), (
+        parity.built,
+        parity.native_errors,
+        parity.deferred,
+        parity.python_raised,
+    )
 
 
 @pytest.mark.parametrize(
     "test_case",
     [
-        NativeRejectionParityTestCase(
+        NativeErrorParityTestCase(
             description="a start bound shifted before year 1 in UTC",
             values={
-                "materialized": "incremental",
-                "incremental_strategy": "append",
-                "cursor": "updated_at",
-                "cursor_type": "timestamp",
-                "cursor_grain": "day",
+                **_INCREMENTAL,
                 "cursor_start": "0001-01-01T00:00:00+01:00",
                 "cursor_end": "2024-01-01",
             },
-            expected_native_accepted=False,
-            expected_python_error=(
-                "CompileInputError: model 'orders_daily': cursor_start value "
-                "'0001-01-01T00:00:00+01:00' falls outside years 1-9999 once converted to UTC"
+            expected_native_outcome=(
+                "CompileInputError",
+                "model 'orders_daily': cursor_start value '0001-01-01T00:00:00+01:00' falls "
+                "outside years 1-9999 once converted to UTC",
+                "P001",
+                header_help(
+                    purpose="keep cursor_start within years 1-9999 in UTC",
+                    entry="cursor_start '0001-01-01T00:00:00+00:00'",
+                ),
+                True,
             ),
+            expected_python_outcome="native outcome",
         ),
-        NativeRejectionParityTestCase(
+        NativeErrorParityTestCase(
             description="an end bound shifted past year 9999 in UTC",
             values={
-                "materialized": "incremental",
-                "incremental_strategy": "append",
-                "cursor": "updated_at",
-                "cursor_type": "timestamp",
-                "cursor_grain": "day",
+                **_INCREMENTAL,
                 "cursor_start": "2024-01-01",
-                "cursor_end": "9999-12-31T23:59:00-01:00",
+                "cursor_end": "9999-12-31T23:59:30.5-01:00",
             },
-            expected_native_accepted=False,
-            expected_python_error=(
-                "CompileInputError: model 'orders_daily': cursor_end value "
-                "'9999-12-31T23:59:00-01:00' falls outside years 1-9999 once converted to UTC"
+            expected_native_outcome="native defers",
+            expected_python_outcome=(
+                "CompileInputError",
+                "model 'orders_daily': cursor_end value '9999-12-31T23:59:30.5-01:00' falls "
+                "outside years 1-9999 once converted to UTC",
+                "P001",
+                header_help(
+                    purpose="keep cursor_end within years 1-9999 in UTC",
+                    entry="cursor_end '9999-12-31T23:59:30.500000+00:00'",
+                ),
+                True,
+            ),
+        ),
+        NativeErrorParityTestCase(
+            description="an invalid replay policy with its header help",
+            values={**_INCREMENTAL, "replay_on_change": "bounded-soon"},
+            expected_native_outcome=(
+                "CompileInputError",
+                "model 'orders_daily': replay_on_change 'bounded-soon' has an invalid duration "
+                "'soon'; use a positive duration such as 14d, 12h or 1mo",
+                "P001",
+                header_help(
+                    purpose="use a valid replay_on_change", entry="replay_on_change bounded-14d"
+                ),
+                True,
+            ),
+            expected_python_outcome="native outcome",
+        ),
+        NativeErrorParityTestCase(
+            description="a non-string materialization",
+            values={"materialized": 5},
+            expected_native_outcome=(
+                "ConfigValueTypeError",
+                "config key 'materialized' expected a string, got int",
+                None,
+                None,
+                None,
             ),
+            expected_python_outcome="native outcome",
         ),
-        NativeRejectionParityTestCase(
+        NativeErrorParityTestCase(
+            description="an old-name view that is not a duration",
+            values={"materialized": "table", "old_name_view": "soon"},
+            expected_native_outcome=(
+                "CompileInputError",
+                "model 'orders_daily': old_name_view must be a positive duration such as 7d, or "
+                "false; got 'soon'",
+                "P001",
+                "write for example old_name_view 7d, or old_name_view false",
+                True,
+            ),
+            expected_python_outcome="native outcome",
+        ),
+        NativeErrorParityTestCase(
             description="an unreadable unique key under an enforced contract",
             values={
                 "materialized": "incremental",
@@ -138,39 +205,29 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
                 "contract": "enforced",
                 "columns": {"order_id": None},
             },
-            expected_native_accepted=False,
-            expected_python_error=(
-                "CompileInputError: model 'orders_daily': unique_key references column "
-                "'\udcff' not declared in enforced contract"
-            ),
-        ),
-        NativeRejectionParityTestCase(
-            description="an unreadable snapshot check column under an enforced contract",
-            values={
-                "materialized": "snapshot",
-                "unique_key": "order_id",
-                "snapshot_strategy": "check",
-                "check_columns": ["\udcff"],
-                "contract": "enforced",
-                "columns": {"order_id": None},
-            },
-            expected_native_accepted=False,
-            expected_python_error=(
-                "CompileInputError: model 'orders_daily': check_columns references column "
-                "'\udcff' not declared in enforced contract"
+            expected_native_outcome="native defers",
+            expected_python_outcome=(
+                "CompileInputError",
+                "model 'orders_daily': unique_key references column '\udcff' not declared in "
+                "enforced contract",
+                "P001",
+                None,
+                True,
             ),
         ),
     ],
     ids=lambda case: case.description,
 )
-def test_given_python_rejected_edge_configs_when_validating_then_native_defers_to_python(
-    test_case: NativeRejectionParityTestCase,
+def test_given_invalid_configs_when_validating_then_native_raises_python_error_or_defers(
+    test_case: NativeErrorParityTestCase,
 ) -> None:
-    accepted, python_error = validation_outcomes(values=test_case.values)
+    native, python = validation_outcomes(values=test_case.values)
 
-    assert (accepted, python_error) == (
-        test_case.expected_native_accepted,
-        test_case.expected_python_error,
+    assert (native, python) == (
+        test_case.expected_native_outcome,
+        {"native outcome": test_case.expected_native_outcome}.get(
+            str(test_case.expected_python_outcome), test_case.expected_python_outcome
+        ),
     )
 
 
diff --git a/tests/integration/src/sqlbuild/compiler/model_config/_test_types.py b/tests/integration/src/sqlbuild/compiler/model_config/_test_types.py
index 0c76e9dc78..4841e40750 100644
--- a/tests/integration/src/sqlbuild/compiler/model_config/_test_types.py
+++ b/tests/integration/src/sqlbuild/compiler/model_config/_test_types.py
@@ -50,12 +50,3 @@ class ConfigTemplateParityTestCase:
     expected_minimum_expanded: int
     expected_minimum_rejected: int
     expected_minimum_unsupported: int
-
-
-@dataclass(frozen=True)
-class NativeRejectionTestCase:
-    """A native entry that rejects valid config, which the Python re-run must expose."""
-
-    description: str
-    native_entry: str
-    expected_message: str
diff --git a/tests/integration/src/sqlbuild/compiler/model_config/helpers.py b/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
index 55a2a49cdc..6b2d53ffa2 100644
--- a/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
+++ b/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
@@ -28,14 +28,14 @@
 from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
 from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs, DiscoveredSqlModelFile
 from sqlbuild.compiler.frontier.constants import COMPILER_ENGINE_ENV_VAR
-from sqlbuild.compiler.frontier.exceptions import NativeStageMismatchError
-from sqlbuild.compiler.model_config.constants import INVALID_OUTCOME, UNSUPPORTED_OUTCOME
+from sqlbuild.compiler.model_config.constants import UNSUPPORTED_OUTCOME
 from sqlbuild.compiler.model_config.main._native_config_contains_macro_call import (
     native_config_contains_macro_call,
 )
 from sqlbuild.compiler.model_config.main._native_config_contains_template import (
     native_config_contains_template,
 )
+from sqlbuild.compiler.model_config.main._native_config_error import native_config_error
 from sqlbuild.compiler.model_config.main._parse_native_header_metadata import (
     parse_native_header_metadata,
 )
@@ -100,7 +100,6 @@
 )
 
 
-_RAISES: str = "Python raises"
 NATIVE_MODEL_CONFIG_ENTRIES: tuple[str, ...] = (
     "parse_model_header_metadata",
     "expand_config_templates",
@@ -218,35 +217,16 @@ def model_config_engine_outcome(
     )
 
 
-def native_rejection_error(
-    *, project_dir: Path, native_entry: str, monkeypatch: pytest.MonkeyPatch
-) -> str:
-    """Build model inputs in preview while `native_entry` rejects everything; return the error."""
+def error_shape(error: Exception) -> tuple[object, ...]:
+    """Return what a user sees of an error: its type, message, code and help."""
 
-    monkeypatch.setattr(_native, native_entry, _REJECTIONS[native_entry])
-    try:
-        _ = model_config_engine_outcome(
-            project_dir=project_dir, engine="native-preview", monkeypatch=monkeypatch
-        )
-    except NativeStageMismatchError as error:
-        return str(error)
-    return "no error"
-
-
-def _reject_header_metadata(requests: list[object], classes: object) -> list[str]:
-    del classes
-    return [INVALID_OUTCOME for _ in requests]
-
-
-def _reject_templates(*args: object) -> str:
-    del args
-    return INVALID_OUTCOME
-
-
-_REJECTIONS: dict[str, Callable[..., object]] = {
-    "parse_model_header_metadata": _reject_header_metadata,
-    "expand_config_templates": _reject_templates,
-}
+    return (
+        type(error).__name__,
+        str(error),
+        getattr(error, "code", None),
+        getattr(error, "help", None),
+        getattr(error, "bridge_independent", None),
+    )
 
 
 def _counted(*, calls: dict[str, int], name: str) -> Callable[..., object]:
@@ -287,8 +267,8 @@ def config_template_parity(*, values: list[object], flags: TemplateFlags) -> Con
             expected=[expected for _, expected, _ in outcomes],
             actual=[actual for _, _, actual in outcomes],
         ),
-        expanded=sum(actual != _RAISES for _, _, actual in outcomes),
-        rejected=sum(actual == _RAISES for _, _, actual in outcomes),
+        expanded=sum(not _is_error(actual) for _, _, actual in outcomes),
+        rejected=sum(_is_error(actual) for _, _, actual in outcomes),
         unsupported=len(values) - len(outcomes),
     )
 
@@ -305,16 +285,29 @@ def _python_expansion(*, value: object, flags: TemplateFlags) -> object:
                 preserve_context_tokens=flags.preserve_context_tokens,
                 preserve_unknown_context=flags.preserve_unknown_context,
             )
-        except CompileInputError:
-            return _RAISES
+        except CompileInputError as error:
+            return _python_error_shape(error)
     return (_expansion_shape(result), reads.environment_names, reads.read_run_id)
 
 
+def _python_error_shape(error: Exception) -> tuple[object, ...]:
+    return (*error_shape(error)[:4], True)
+
+
+def _is_error(outcome: object) -> bool:
+    return isinstance(outcome, tuple) and len(outcome) == len(error_shape(ValueError()))
+
+
 def _native_classification(*, value: object, flags: TemplateFlags) -> object:
     return _native.expand_config_templates(
         value,
         (TEMPLATE_VARIABLES, os.environ, TEMPLATE_CONTEXT),
-        (flags.allow_context, flags.preserve_context_tokens, flags.preserve_unknown_context, None),
+        (
+            flags.allow_context,
+            flags.preserve_context_tokens,
+            flags.preserve_unknown_context,
+            "model config",
+        ),
     )
 
 
@@ -331,10 +324,8 @@ def _native_expansion(value: object, flags: TemplateFlags) -> object:
                 preserve_unknown_context=flags.preserve_unknown_context,
                 native=True,
             )
-        except CompileInputError:
-            return _RAISES
-        except NativeStageMismatchError as error:
-            return str(error)
+        except CompileInputError as error:
+            return error_shape(error)
     return (_expansion_shape(result), reads.environment_names, reads.read_run_id)
 
 
@@ -391,8 +382,8 @@ def header_metadata_parity(*, headers: list[tuple[object, object]]) -> HeaderMet
             expected=[_shape(value) for _, value, _ in compared],
             actual=[_native_shape(metadata) for _, _, metadata in compared],
         ),
-        parsed=sum(not metadata.invalid for metadata in native.values()),
-        rejected=sum(metadata.invalid for metadata in native.values()),
+        parsed=sum(_native_error(metadata) is None for metadata in native.values()),
+        rejected=sum(_native_error(metadata) is not None for metadata in native.values()),
         unsupported=len(model_files) - len(compared),
     )
 
@@ -472,17 +463,16 @@ def _python_metadata(*, model_file: DiscoveredSqlModelFile) -> object:
                 null_as_empty=True,
             ),
         )
-    except Exception as error:
-        return f"{type(error).__name__}: {error}"
+    except Exception as error:  # noqa: BLE001 - the exact Python outcome, whatever it is
+        return list(error_shape(error)[:4])
 
 
 def _shape(value: object) -> object:
-    return _SHAPES.get(type(value), _raises)(value)
+    return _SHAPES.get(type(value), _unchanged)(value)
 
 
-def _raises(value: object) -> object:
-    del value
-    return _RAISES
+def _unchanged(value: object) -> object:
+    return value
 
 
 def _metadata_shape(value: object) -> object:
@@ -491,22 +481,16 @@ def _metadata_shape(value: object) -> object:
 
 def _native_shape(metadata: NativeHeaderMetadata | None) -> object:
     parsed: NativeHeaderMetadata = cast(NativeHeaderMetadata, metadata)
-    return _NATIVE_SHAPES[parsed.invalid](parsed)
-
-
-def _parsed_shape(metadata: NativeHeaderMetadata) -> object:
-    return _shape((metadata.columns, metadata.audits))
-
-
-def _rejected_shape(metadata: NativeHeaderMetadata) -> object:
-    del metadata
-    return _RAISES
+    error: _native.NativeConfigError | None = _native_error(parsed)
+    shapes: list[object] = [
+        list(error_shape(native_config_error(error=cast(_native.NativeConfigError, error)))[:4])
+        for _ in range(error is not None)
+    ]
+    return (*shapes, _shape((parsed.columns, parsed.audits)))[0]
 
 
-_NATIVE_SHAPES: dict[bool, Callable[[NativeHeaderMetadata], object]] = {
-    False: _parsed_shape,
-    True: _rejected_shape,
-}
+def _native_error(metadata: NativeHeaderMetadata) -> _native.NativeConfigError | None:
+    return metadata.columns_error or metadata.audits_error
 
 
 _SHAPES: dict[type, Callable[[object], object]] = {tuple: _metadata_shape}
diff --git a/tests/integration/src/sqlbuild/compiler/model_config/test_native_model_config.py b/tests/integration/src/sqlbuild/compiler/model_config/test_native_model_config.py
index a778c0f5a7..654831c5f7 100644
--- a/tests/integration/src/sqlbuild/compiler/model_config/test_native_model_config.py
+++ b/tests/integration/src/sqlbuild/compiler/model_config/test_native_model_config.py
@@ -12,7 +12,6 @@
     ConfigTemplateParityTestCase,
     HeaderMetadataParityTestCase,
     ModelConfigTierTestCase,
-    NativeRejectionTestCase,
 )
 from tests.integration.src.sqlbuild.compiler.model_config.helpers import (
     TEMPLATE_ENVIRONMENT,
@@ -27,7 +26,6 @@
     generated_template_values,
     header_metadata_parity,
     model_config_engine_outcome,
-    native_rejection_error,
 )
 
 
@@ -201,37 +199,5 @@ def test_given_engine_tier_when_building_model_inputs_then_native_config_runs_on
     )
 
 
-@pytest.mark.parametrize(
-    "test_case",
-    [
-        NativeRejectionTestCase(
-            description="header metadata",
-            native_entry="parse_model_header_metadata",
-            expected_message="native model config rejected MODEL columns or audits",
-        ),
-        NativeRejectionTestCase(
-            description="templates",
-            native_entry="expand_config_templates",
-            expected_message="templates that Python expands",
-        ),
-    ],
-    ids=lambda case: case.description,
-)
-def test_given_native_rejects_valid_config_when_python_accepts_then_a_mismatch_is_raised(
-    test_case: NativeRejectionTestCase, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    message: str = native_rejection_error(
-        project_dir=tmp_path, native_entry=test_case.native_entry, monkeypatch=monkeypatch
-    )
-
-    assert (
-        test_case.expected_message in message,
-        "SQLBUILD_COMPILER_ENGINE=python" in message,
-    ) == (
-        True,
-        True,
-    ), message
-
-
 if __name__ == "__main__":
     pytest.main([__file__, "-vv"])

From bf0bfb5431141f4f428644d839351adf11bad117 Mon Sep 17 00:00:00 2001
From: Kevin Longe <273747162+kvlonge@users.noreply.github.com>
Date: Thu, 8 Oct 2026 20:37:30 +0100
Subject: [PATCH 2/2] fix(native): let the macro bridge decide native validator
 errors

---
 .../_helpers/attachment/model_config.py       | 18 +++--
 .../_helpers/render/context_templates.py      |  2 +-
 .../model_config/main/_native_config_error.py |  9 ++-
 .../cli/commands/main/compile/_test_types.py  | 13 +++-
 .../main/compile/test_native_config_errors.py | 66 ++++++++++++++++---
 .../compile/native_model_config/helpers.py    |  6 +-
 .../test_native_model_config_session.py       | 10 +--
 .../sqlbuild/compiler/model_config/helpers.py |  8 ++-
 8 files changed, 105 insertions(+), 27 deletions(-)

diff --git a/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py b/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py
index 9b2f477783..5f9c113de5 100644
--- a/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py
+++ b/src/sqlbuild/compiler/compile/_helpers/attachment/model_config.py
@@ -373,7 +373,7 @@ def build_model_header_schema_entry(
         else None
     )
     if native is not None and native.columns_error is not None:
-        raise native_config_error(error=native.columns_error)
+        raise native_config_error(error=native.columns_error, bridge_independent=True)
     local_columns: tuple[SchemaColumn, ...] = (
         native.columns
         if native is not None
@@ -396,7 +396,7 @@ def build_model_header_schema_entry(
         file_path=file_path,
     )
     if native is not None and native.audits_error is not None:
-        raise native_config_error(error=native.audits_error)
+        raise native_config_error(error=native.audits_error, bridge_independent=True)
     audits: tuple[SchemaAuditInstance, ...] = (
         native.audits
         if native is not None
@@ -915,7 +915,7 @@ def native_path_default(
         str(model_file.relative_path)
     )
     if isinstance(selected, _native.NativeConfigError):
-        raise native_config_error(error=selected)
+        raise native_config_error(error=selected, bridge_independent=True)
     return selected
 
 
@@ -933,7 +933,7 @@ def build_native_model_config(
     if built is None:
         return None
     if isinstance(built, _native.NativeConfigError):
-        raise native_config_error(error=built)
+        raise native_config_error(error=built, bridge_independent=True)
     values, header_keys, namespace, overrides, reads = built
     logical_schema, layer_schema_configured, logical_database = namespace
     retention_override, table_type_override = overrides
@@ -998,6 +998,14 @@ def native_model_validation(
     )
 
 
+def native_validation_error(
+    *, error: _native.NativeConfigError, values: dict[str, object]
+) -> Exception:
+    """Return a native validator error; validators read expanded SQL, so the bridge decides."""
+
+    return native_config_error(error=error, bridge_independent=False, values=values)
+
+
 def validate_model_config(
     *, context: ModelValidatorContext, request: ModelValidationRequest
 ) -> None:
@@ -1008,7 +1016,7 @@ def validate_model_config(
             session=context.native_config, request=request
         )
         if isinstance(outcome, _native.NativeConfigError):
-            raise native_config_error(error=outcome, values=request.config.values)
+            raise native_validation_error(error=outcome, values=request.config.values)
         if outcome:
             return
     run_python_model_validators(context=context, request=request)
diff --git a/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py b/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py
index 57c4f5c21e..1a544e1ad8 100644
--- a/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py
+++ b/src/sqlbuild/compiler/compile/_helpers/render/context_templates.py
@@ -283,7 +283,7 @@ def expand_config_templates(
         context_label
     ):
         record_template_reads(outcome.reads)
-        raise native_config_error(error=outcome.error)
+        raise native_config_error(error=outcome.error, bridge_independent=True)
     return expand_template_data(
         value=value,
         variables=variables,
diff --git a/src/sqlbuild/compiler/model_config/main/_native_config_error.py b/src/sqlbuild/compiler/model_config/main/_native_config_error.py
index f1b42f5d68..9b5ba695c2 100644
--- a/src/sqlbuild/compiler/model_config/main/_native_config_error.py
+++ b/src/sqlbuild/compiler/model_config/main/_native_config_error.py
@@ -18,9 +18,12 @@
 
 
 def native_config_error(
-    *, error: _native.NativeConfigError, values: Mapping[str, object] | None = None
+    *,
+    error: _native.NativeConfigError,
+    bridge_independent: bool,
+    values: Mapping[str, object] | None = None,
 ) -> Exception:
-    """Return the exception Python raises for `error`; `values` holds a mistyped config key."""
+    """Return Python's exception for `error`; mark it bridge-independent only if SQL is unread."""
 
     if error.class_name == CONFIG_VALUE_TYPE_ERROR and error.key is not None and values is not None:
         return ConfigValueTypeError(
@@ -31,5 +34,5 @@ def native_config_error(
     if error.class_name == DISCOVERY_CONFLICT_ERROR:
         return DiscoveryConflictError(error.message, help=error.help)
     return CompileInputError(
-        error.message, code=error.code, help=error.help, bridge_independent=True
+        error.message, code=error.code, help=error.help, bridge_independent=bridge_independent
     )
diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py
index b28cfaa5af..03f1d99aa1 100644
--- a/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py
+++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py
@@ -915,10 +915,21 @@ class NativeConfigErrorTestCase:
     description: str
     project_files: dict[str, str]
     expected_report_text: str
-    expected_macro_calls: int
+    expected_macro_calls: list[int]
     expected_python_fallbacks: list[str]
 
 
+@dataclass(frozen=True)
+class MacroExpandedValidatorErrorTestCase:
+    """A validator error from macro-expanded SQL that the preview bridge must re-run."""
+
+    description: str
+    project_files: dict[str, str]
+    engines: tuple[str, ...]
+    expected_report_text: str
+    expected_macro_calls: list[int]
+
+
 @dataclass(frozen=True)
 class DeclarationErrorLifecycleTestCase:
     """A failing project whose invocation lifecycle every engine must report the same way."""
diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py
index 279eb8aa27..f1214edebd 100644
--- a/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py
+++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_native_config_errors.py
@@ -1,4 +1,4 @@
-"""The preview engine reports model config, template and header errors as Python does, once."""
+"""The preview engine reports model config, template and header errors as Python does."""
 
 from __future__ import annotations
 
@@ -12,6 +12,7 @@
 import sqlbuild.compiler.compile._helpers.render.context_templates as context_templates
 from scripts.compiler_differential.constants import FAILURE_BASE_MART
 from tests.e2e.src.sqlbuild.cli.commands.main.compile._test_types import (
+    MacroExpandedValidatorErrorTestCase,
     NativeConfigErrorTestCase,
 )
 from tests.e2e.src.sqlbuild.cli.commands.main.compile.helpers import (
@@ -37,6 +38,9 @@
     "    return expression\n"
 )
 _COUNTED_MART: str = FAILURE_BASE_MART.replace("SUM(amount)", "SUM(@counted('amount'))")
+_UPSTREAM_MACRO: str = _COUNTED_MACRO.replace(
+    "def counted(expression: str) -> str:", "def upstream() -> str:"
+).replace("    return expression\n", "    return '__ref(\"ghost\")'\n")
 _STAGING_PATH: str = "models/staging/stg_orders.sql"
 _STAGING_BODY: str = (
     '\n);\n\nSELECT order_id, customer_id, amount, status\nFROM __source("raw_orders")\n'
@@ -69,7 +73,7 @@
                 + _STAGING_BODY
             },
             expected_report_text="unknown incremental_strategy 'upsert'",
-            expected_macro_calls=1,
+            expected_macro_calls=[1, 2],
             expected_python_fallbacks=[],
         ),
         NativeConfigErrorTestCase(
@@ -81,7 +85,7 @@
                 + _STAGING_BODY
             },
             expected_report_text="cursor_start must be before exclusive cursor_end",
-            expected_macro_calls=1,
+            expected_macro_calls=[1, 2],
             expected_python_fallbacks=[],
         ),
         NativeConfigErrorTestCase(
@@ -90,7 +94,7 @@
                 _STAGING_PATH: 'MODEL (\n  schema "${missing_region}_core",' + _STAGING_BODY
             },
             expected_report_text="model config references unknown variable 'missing_region'",
-            expected_macro_calls=1,
+            expected_macro_calls=[1, 1],
             expected_python_fallbacks=[],
         ),
         NativeConfigErrorTestCase(
@@ -100,7 +104,7 @@
                 + _STAGING_BODY
             },
             expected_report_text="column 'order_id' has unknown metadata keys: format",
-            expected_macro_calls=1,
+            expected_macro_calls=[1, 1],
             expected_python_fallbacks=[],
         ),
         NativeConfigErrorTestCase(
@@ -110,14 +114,14 @@
                 "severity fatal)]," + _STAGING_BODY
             },
             expected_report_text="'severity' must be one of: warn, error",
-            expected_macro_calls=1,
+            expected_macro_calls=[1, 1],
             expected_python_fallbacks=[],
         ),
         NativeConfigErrorTestCase(
             description="config_build_error_after_a_macro_ran",
             project_files={_STAGING_PATH: 'MODEL (\n  tags "orders",' + _STAGING_BODY},
             expected_report_text="tags must be a list",
-            expected_macro_calls=1,
+            expected_macro_calls=[1, 1],
             expected_python_fallbacks=[],
         ),
     ],
@@ -169,12 +173,58 @@ def test_given_config_error_when_compiling_with_preview_then_error_matches_pytho
         True,
         True,
         True,
-        [test_case.expected_macro_calls] * 2,
+        test_case.expected_macro_calls,
         python_run.returncode,
         report_without_engine(python_run).replace("preview", "python"),
         test_case.expected_python_fallbacks,
     ), (runs[0].report, runs[1].report, runs[1].stderr)
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        MacroExpandedValidatorErrorTestCase(
+            description="unknown_model_reference_from_a_macro",
+            project_files={
+                "macros/upstream.py": _UPSTREAM_MACRO,
+                "models/marts/customer_totals.sql": (
+                    'MODEL (\n  description "Order totals per customer",\n);\n\n'
+                    "SELECT * FROM @upstream()\n"
+                ),
+                _CALL_LOG: "",
+            },
+            engines=("python", "native-preview", "native"),
+            expected_report_text="references unknown model 'ghost'",
+            expected_macro_calls=[1, 2, 1],
+        )
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_validator_error_from_macro_sql_when_compiling_then_preview_bridge_reruns_it(
+    test_case: MacroExpandedValidatorErrorTestCase, tmp_path: Path
+) -> None:
+    project_dir: Path = tmp_path / "orders"
+    runs: list[CompileReuseRun] = []
+    macro_calls: list[int] = []
+    for engine in test_case.engines:
+        write_counted_error_project(project_dir=project_dir, files=test_case.project_files)
+        runs.append(
+            run_reuse_compile(project_dir=project_dir, global_args=("--compiler-engine", engine))
+        )
+        macro_calls.append(len((project_dir / _CALL_LOG).read_text(encoding="utf-8").splitlines()))
+
+    assert (
+        [run.returncode for run in runs],
+        [test_case.expected_report_text in run.report + run.stderr for run in runs],
+        {report_without_engine(run) for run in runs} == {report_without_engine(runs[0])},
+        macro_calls,
+    ) == (
+        [1] * len(test_case.engines),
+        [True] * len(test_case.engines),
+        True,
+        test_case.expected_macro_calls,
+    ), [run.report + run.stderr for run in runs]
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-vv"])
diff --git a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py
index 0b2308f429..d7a7d0106d 100644
--- a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py
+++ b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/helpers.py
@@ -18,6 +18,7 @@
     native_model_config_session,
     native_model_validation,
     native_path_default,
+    native_validation_error,
     run_python_model_validators,
 )
 from sqlbuild.compiler.compile.constants import COMPILE_INPUT_READS
@@ -37,7 +38,6 @@
     PythonHookEntry,
     SqlHookEntry,
 )
-from sqlbuild.compiler.model_config.main._native_config_error import native_config_error
 from sqlbuild.spec.contracts.models import (
     AuthoredTimeTravelRetention,
     DefaultsConfig,
@@ -411,7 +411,7 @@ def _python_validation(request: ModelValidationRequest) -> object:
     try:
         run_python_model_validators(context=_VALIDATOR_CONTEXT, request=request)
     except Exception as error:  # noqa: BLE001 - the exact Python outcome, whatever it is
-        return _python_error_shape(error)
+        return raised_error_shape(error)
     return _ACCEPTED
 
 
@@ -423,7 +423,7 @@ def _native_validation(
     )
     errors: list[object] = [
         raised_error_shape(
-            native_config_error(
+            native_validation_error(
                 error=cast(_native.NativeConfigError, error), values=request.config.values
             )
         )
diff --git a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py
index e215ef7660..a8c19e353f 100644
--- a/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py
+++ b/tests/integration/src/sqlbuild/compiler/compile/native_model_config/test_native_model_config_session.py
@@ -132,7 +132,7 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
                     purpose="keep cursor_start within years 1-9999 in UTC",
                     entry="cursor_start '0001-01-01T00:00:00+00:00'",
                 ),
-                True,
+                False,
             ),
             expected_python_outcome="native outcome",
         ),
@@ -153,7 +153,7 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
                     purpose="keep cursor_end within years 1-9999 in UTC",
                     entry="cursor_end '9999-12-31T23:59:30.500000+00:00'",
                 ),
-                True,
+                False,
             ),
         ),
         NativeErrorParityTestCase(
@@ -167,7 +167,7 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
                 header_help(
                     purpose="use a valid replay_on_change", entry="replay_on_change bounded-14d"
                 ),
-                True,
+                False,
             ),
             expected_python_outcome="native outcome",
         ),
@@ -192,7 +192,7 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
                 "false; got 'soon'",
                 "P001",
                 "write for example old_name_view 7d, or old_name_view false",
-                True,
+                False,
             ),
             expected_python_outcome="native outcome",
         ),
@@ -212,7 +212,7 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
                 "enforced contract",
                 "P001",
                 None,
-                True,
+                False,
             ),
         ),
     ],
diff --git a/tests/integration/src/sqlbuild/compiler/model_config/helpers.py b/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
index 6b2d53ffa2..0bcab3f19b 100644
--- a/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
+++ b/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
@@ -483,7 +483,13 @@ def _native_shape(metadata: NativeHeaderMetadata | None) -> object:
     parsed: NativeHeaderMetadata = cast(NativeHeaderMetadata, metadata)
     error: _native.NativeConfigError | None = _native_error(parsed)
     shapes: list[object] = [
-        list(error_shape(native_config_error(error=cast(_native.NativeConfigError, error)))[:4])
+        list(
+            error_shape(
+                native_config_error(
+                    error=cast(_native.NativeConfigError, error), bridge_independent=True
+                )
+            )[:4]
+        )
         for _ in range(error is not None)
     ]
     return (*shapes, _shape((parsed.columns, parsed.audits)))[0]