@@ -889,6 +889,15 @@ class RejectedReferenceCallTestCase:
     expected_diagnostics: tuple[tuple[str, str, str, int, int, str], ...]
 
 
+@dataclass(frozen=True)
+class MacroReferenceCallStoreTestCase:
+    """Repeated compiles of models sharing a macro that returns a rejected reference call."""
+
+    description: str
+    engine: str
+    expected_logged_calls: tuple[int, ...]
+
+
 @dataclass(frozen=True)
 class MacroCallStoreEditStep:
     """One edit compiled with the macro call store, and the executions it expects."""
 
@@ -4274,6 +4274,96 @@ def prepare_reference_call_project(*, tmp_path: Path, staging_from: str, mart_fr
     return project_dir
 
 
+_MACRO_REFERENCE_CALL_MODELS: tuple[str, ...] = ("customer_orders", "customer_returns")
+_DIAGNOSTIC_FIELDS: tuple[str, ...] = (
+    "code",
+    "message",
+    "resource_name",
+    "path",
+    "line",
+    "column",
+    "help",
+)
+
+
+class MacroReferenceCallRuns(NamedTuple):
+    """Repeated compiles: exit codes, macro executions, and the diagnostics of each run."""
+
+    returncodes: tuple[int, ...]
+    logged_calls: tuple[int, ...]
+    diagnostics: tuple[tuple[tuple[object, ...], ...], ...]
+
+
+def prepare_macro_reference_call_project(*, tmp_path: Path) -> Path:
+    """Write a project whose models share a macro returning a reference call compile rejects."""
+
+    return prepare_inline_project(
+        tmp_path=tmp_path,
+        project_name="orders",
+        repo_files={
+            "sqlbuild_project.toml": _REFERENCE_CALL_PROJECT_TOML,
+            "sources/raw.yml": _REFERENCE_CALL_SOURCES_YML,
+            "models/staging/customers.sql": (
+                'MODEL (description "Customers.", materialized view);\n\n'
+                'SELECT order_id AS customer_id FROM __source("raw_orders")\n'
+            ),
+            "models/marts/_sqlbuild/_macros/customer_relation.py": (
+                '"""A macro that returns an unquoted reference call."""\n\n'
+                "import os\n\n\n"
+                "def customer_relation() -> str:\n"
+                '    """Return the customers relation, logging each execution."""\n'
+                f'    path = os.environ.get("{MACRO_CALL_LOG_ENV_VAR}")\n'
+                "    if path:\n"
+                '        with open(path, "a", encoding="utf-8") as log:\n'
+                '            log.write("customer_relation\\n")\n'
+                '    return "__ref(customers)"\n'
+            ),
+            **{
+                f"models/marts/{name}.sql": (
+                    f'MODEL (description "{name}.", materialized view);\n\n'
+                    "SELECT customer_id FROM @customer_relation()\n"
+                )
+                for name in _MACRO_REFERENCE_CALL_MODELS
+            },
+        },
+    )
+
+
+def _diagnostic_fields(item: dict[str, object]) -> tuple[object, ...]:
+    return tuple(item.get(field) for field in _DIAGNOSTIC_FIELDS)
+
+
+def macro_reference_call_runs(
+    *, project_dir: Path, log_path: Path, engine: str, runs: int
+) -> MacroReferenceCallRuns:
+    """Compile `runs` times in fresh processes, keeping the macro call store between runs."""
+
+    env: dict[str, str] = {
+        COMPILER_ENGINE_ENV_VAR: engine,
+        REUSE_DISABLE_ENV_VAR: "1",
+        MACRO_CALL_LOG_ENV_VAR: str(log_path),
+    }
+    returncodes: list[int] = []
+    logged_calls: list[int] = []
+    diagnostics: list[tuple[tuple[object, ...], ...]] = []
+    for _ in range(runs):
+        _ = log_path.write_text("", encoding="utf-8")
+        compiled: subprocess.CompletedProcess[str] = run_installed_sqb(
+            project_dir=project_dir, args=("compile", "--json"), env=env
+        )
+        returncodes.append(compiled.returncode)
+        logged_calls.append(len(log_path.read_text(encoding="utf-8").splitlines()))
+        items: list[dict[str, object]] = cast(
+            list[dict[str, object]], json.loads(compiled.stdout)["diagnostics"]
+        )
+        diagnostics.append(tuple(_diagnostic_fields(item) for item in items))
+    return MacroReferenceCallRuns(
+        returncodes=tuple(returncodes),
+        logged_calls=tuple(logged_calls),
+        diagnostics=tuple(diagnostics),
+    )
+
+
 MACRO_CALL_STORE_ENGINE: str = "native-preview"
 STORE_ENVIRONMENT_REGION_VAR: str = "SQB_STORE_TEST_REGION"
 STORE_ARGUMENT_ENV_VAR: str = "STORE_TEST_ARGUMENT"
 
@@ -12,6 +12,7 @@
     EngineMacroCallGateTestCase,
     MacroCallStoreEditSequenceTestCase,
     MacroCallStoreEditStep,
+    MacroReferenceCallStoreTestCase,
     SecondCompileStoreTestCase,
     StaleMacroModuleStoreTestCase,
     StaleStoreArrangement,
@@ -23,6 +24,7 @@
     CompileReuseRun,
     EngineMacroCallRuns,
     MacroCallStoreRun,
+    MacroReferenceCallRuns,
     backdate_flavor_between_processes,
     block_proc_reads,
     compile_as_new_process_here,
@@ -36,8 +38,10 @@
     in_process_reuse_run,
     logged_in_process_compile,
     macro_call_store_compile,
+    macro_reference_call_runs,
     move_flavor_while_saving,
     prepare_macro_call_store_project,
+    prepare_macro_reference_call_project,
     pretend_fresh_process,
     recompile_in_process_after_edit,
     replace_project_text,
@@ -50,6 +54,11 @@
 )
 from tests.integration.src.sqlbuild.compiler.compile.helpers import MACRO_CALL_LOG_ENV_VAR
 
+_MACRO_REFERENCE_CALL_RUNS: int = 2
+_MACRO_REFERENCE_CALL_MESSAGE: str = (
+    "__ref(customers) is not a valid __ref() call, returned by macro customer_relation()"
+)
+_MACRO_REFERENCE_CALL_PATH: str = "models/marts/_sqlbuild/_macros/customer_relation.py"
 _EDIT_STEPS: tuple[MacroCallStoreEditStep, ...] = (
     MacroCallStoreEditStep(
         description="no_change",
@@ -305,6 +314,48 @@ def test_given_engine_when_compiling_repeatedly_then_only_preview_batches_and_st
     assert runs.store_files == test_case.expected_store_files
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        MacroReferenceCallStoreTestCase(
+            description="python",
+            engine="python",
+            expected_logged_calls=(2, 2),
+        ),
+        MacroReferenceCallStoreTestCase(
+            description="native_preview_memo_then_store",
+            engine="native-preview",
+            expected_logged_calls=(1, 0),
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_macro_returning_rejected_reference_call_when_replaying_then_reports_match_python(
+    tmp_path: Path, test_case: MacroReferenceCallStoreTestCase
+) -> None:
+    oracle: MacroReferenceCallRuns = macro_reference_call_runs(
+        project_dir=prepare_macro_reference_call_project(tmp_path=tmp_path / "python"),
+        log_path=tmp_path / "python.log",
+        engine="python",
+        runs=1,
+    )
+
+    runs: MacroReferenceCallRuns = macro_reference_call_runs(
+        project_dir=prepare_macro_reference_call_project(tmp_path=tmp_path / "engine"),
+        log_path=tmp_path / "engine.log",
+        engine=test_case.engine,
+        runs=_MACRO_REFERENCE_CALL_RUNS,
+    )
+
+    assert [diagnostic[:4] for diagnostic in oracle.diagnostics[0]] == [
+        ("P012", _MACRO_REFERENCE_CALL_MESSAGE, name, _MACRO_REFERENCE_CALL_PATH)
+        for name in ("customer_orders", "customer_returns")
+    ]
+    assert runs.returncodes == (1,) * _MACRO_REFERENCE_CALL_RUNS
+    assert runs.logged_calls == test_case.expected_logged_calls
+    assert runs.diagnostics == oracle.diagnostics * _MACRO_REFERENCE_CALL_RUNS
+
+
 @pytest.mark.parametrize(
     "test_case",
     [