From bea32df1a62f92782c0e001d04609012581cc79e Mon Sep 17 00:00:00 2001
From: Christopher Bays <cmbays91@gmail.com>
Date: Sun, 31 May 2026 13:17:40 -0400
Subject: [PATCH 1/5] feat: inline SQL diff for changed models in PR-review
 report
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Apply the #96 line-diff substrate to a changed model's raw SQL
(raw_code), rendered in the Model SQL section with a Raw↔Diff toggle.
report-mode, diff-sourced (--pr-diff), no base manifest.

- domain/pr_diff: rename YamlBlockDiff -> BlockDiff (content-agnostic;
  JSON field `yaml_diff` kept so #96 wire/JS/snapshots don't move).
  Widen block_aligns_with_hunks + reconstruct_one to (raw, start, end).
  Add reconstruct_model_sql_diffs over manifest raw_code (whole-file
  span; strip exactly one trailing \n for git's line frame — handles
  the dbt-core vs dbt-fusion trailing-newline divergence). N7b drift
  guard reused; stale/untouched/whitespace-only -> plain SQL view.
- Whitespace ignored as standard, per line-pair (ws_equal,
  git --ignore-all-space semantics) across both the YAML (#96) and SQL
  (#111) diffs. N7b stays whitespace-exact.
- render: ModelPayload.sql_diff (skip_serializing_if, mirrors
  TestPayload.yaml_diff); threaded through build_payload/render_report.
  PrDiff-arm-gated in cli; Baseline => empty map (digest snapshot
  unmoved).
- template: renderYamlDiff -> renderBlockDiff(diff, highlightFn) with
  highlightSql/highlightYaml; highlight-bypass preserved. Model SQL
  Raw↔Diff toggle (default Diff when sql_diff present).
- BDD: 4 scenarios appended to pr_diff_scoping.feature (count stays
  10); headless SQL-diff toggle tests; book docs (raw_code source,
  whitespace standard + caveat, engine trailing-newline note).

Closes #111

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 book/src/how-it-works.md                      |  41 +
 book/src/recipes/github-actions-pr-review.md  |  11 +-
 examples/jaffle-shop-report.html              |  79 +-
 examples/playground-report.html               |  79 +-
 features/pr_diff_scoping.feature              |  54 ++
 src/adapters/render.rs                        | 133 ++-
 src/cli/mod.rs                                |  27 +-
 src/domain/mod.rs                             |   4 +-
 src/domain/pr_diff.rs                         | 891 +++++++++++++++---
 templates/report.html                         |  79 +-
 tests/golden_report.rs                        |   1 +
 tests/headless_toggle.rs                      | 229 ++++-
 tests/render_integration.rs                   |   1 +
 ...egration__rendered_chrome_jaffle_shop.snap |  79 +-
 tests/steps/builders.rs                       |  33 +
 tests/steps/pr_diff_scoping.rs                | 182 +++-
 tests/steps/world.rs                          |  34 +
 17 files changed, 1760 insertions(+), 197 deletions(-)

diff --git a/book/src/how-it-works.md b/book/src/how-it-works.md
index f627b2a0..28de3a35 100644
--- a/book/src/how-it-works.md
+++ b/book/src/how-it-works.md
@@ -213,6 +213,47 @@ page lays out as:
    The inline diff is **`--pr-diff`-only**: baseline mode computes
    `changed` from a structural manifest diff with no hunks, so it has no
    inline YAML diff and the drawer always shows the authored YAML.
+6. **Model SQL section** — the model's **raw Jinja source** (`raw_code`
+   from the manifest — the diffable layer; compiled SQL is generated and
+   un-diffable). When the PR diff changed the model's `.sql`, this section
+   adds a **Raw ↔ Diff** toggle and opens on the **Diff** view, showing
+   the inline diff of the model's SQL (cute-dbt#111). The diff reuses the
+   exact line-diff substrate the Authoring YAML drawer uses — same
+   change-pair rendering, same intra-line emphasis, same N7b drift guard.
+   `raw_code` is read straight from the manifest (no `--project-root`
+   filesystem read needed, unlike the YAML drawer), so the SQL diff fires
+   on any changed model `.sql`. When there's no SQL diff — baseline mode,
+   the model is in scope only via a changed *test*, the diff is stale, or
+   the change was whitespace-only — the section shows the plain raw SQL
+   exactly as before. dbt engines differ in one detail cute-dbt
+   normalizes away: dbt-core ships `raw_code` with the file's trailing
+   newline stripped, dbt-fusion ships it byte-identical but keeping the
+   trailing newline; cute-dbt strips a single trailing newline so the SQL
+   diff renders identically regardless of which engine compiled the
+   manifest.
+
+### Whitespace-only changes are ignored (standard)
+
+Both inline diffs (the YAML drawer and the Model SQL diff) **ignore
+whitespace-only differences** as standard behavior — no flag, no opt-in.
+A re-indentation, a trailing-whitespace edit, or a blank-line churn that
+leaves the substantive content unchanged renders as **context**, not as a
+change (`git --ignore-all-space` semantics, compared per line-pair). If
+*every* change in a block is whitespace-only, cute-dbt emits **no inline
+diff** and shows the plain view. The drift guard upstream stays
+whitespace-exact (a whitespace divergence between the diff and the
+working tree is genuine revision drift, not a no-op), so whitespace
+insensitivity applies only to the change/no-change decision, never to the
+staleness check.
+
+This is a best-effort filter over git's pre-computed `--unified=0` hunks,
+not a re-diff: cute-dbt cannot re-pair lines git already split. The
+dominant cases (re-indentation, trailing whitespace, blank-line churn)
+are handled; for a multi-line replacement that mixes a re-indent with a
+real edit, the removed line may render at the hunk's top rather than
+paired to its own offset — the change-set stays correct, only the line
+placement is approximate. For YAML, an indentation change that alters
+*structure* still surfaces via the accompanying value changes.
 
 The description banner started life at the top of the test-selection
 section. It moved to between the CTE DAG and the inspect/expected
diff --git a/book/src/recipes/github-actions-pr-review.md b/book/src/recipes/github-actions-pr-review.md
index b6e06968..e24dfbe4 100644
--- a/book/src/recipes/github-actions-pr-review.md
+++ b/book/src/recipes/github-actions-pr-review.md
@@ -93,9 +93,14 @@ cute-dbt \
 "read from this file"). cute-dbt parses the diff's `+++ b/<path>` headers
 to pick the in-scope set and its `@@ … @@` hunks to flag which tests the
 PR actually edited (block-precise updated detection + the inline YAML diff
-drawer key off the hunk spans). `--project-root dbt_project` rewrites the
-repo-relative diff paths so they match the manifest's project-relative
-`original_file_path`s (drop it if your dbt project is at the repo root).
+drawer key off the hunk spans). When a hunk changes a model's `.sql`, the
+Model SQL section also shows an inline **SQL diff** of the model's raw
+Jinja with a Raw ↔ Diff toggle — same diff engine, keyed off the same
+hunks. Both inline diffs ignore whitespace-only edits as standard (a pure
+re-indent shows the plain view, not a noisy diff). `--project-root
+dbt_project` rewrites the repo-relative diff paths so they match the
+manifest's project-relative `original_file_path`s (drop it if your dbt
+project is at the repo root).
 cute-dbt parses the diff you hand it — it never shells out to `git` or
 reads `GITHUB_EVENT_PATH`, so the workflow stays in control of *how* the
 diff is produced.
diff --git a/examples/jaffle-shop-report.html b/examples/jaffle-shop-report.html
index af20ee1c..0bd115bd 100644
--- a/examples/jaffle-shop-report.html
+++ b/examples/jaffle-shop-report.html
@@ -4369,11 +4369,17 @@ <h2>Expected</h2>
     }
   }
 
-  // cute-dbt#47 — populate (or hide) the per-model Model SQL section.
-  // The askama template emits one static <section class="model-sql">; JS
-  // rebinds its <code> body and Copy handler each time the user selects a
+  // cute-dbt#47 / cute-dbt#111 — populate (or hide) the per-model Model SQL
+  // section. The askama template emits one static <section class="model-sql">;
+  // JS rebinds its body and Copy handler each time the user selects a
   // different model. When `raw_sql` is missing, hide the whole section
   // (defensive — dbt 1.8+ populates raw_code on every node).
+  //
+  // cute-dbt#111: when the selected model carries an inline SQL diff
+  // (m.sql_diff — PR-diff mode, the model's .sql changed), the section shows
+  // a Raw↔Diff toggle defaulting to Diff (rendered via renderBlockDiff with
+  // the SQL highlighter on context lines only). Absent a diff it renders the
+  // plain raw SQL exactly as cute-dbt#47 did. Copy always copies the raw SQL.
   function renderModelSql(m) {
     var $section = $(".model-sql");
     var raw = m && m.raw_sql;
@@ -4382,13 +4388,47 @@ <h2>Expected</h2>
       return;
     }
     $section.show();
-    $section.find(".model-sql-code").html(highlightSql(raw));
-    var $copy = $section.find(".model-sql-copy");
-    $copy.off("click.cuteDbtModelSql").on("click.cuteDbtModelSql", function (e) {
+    var hasDiff = m.sql_diff && m.sql_diff.lines && m.sql_diff.lines.length;
+    $section.find(".model-sql-summary-hint").text(hasDiff ? "diff" : "raw, with Jinja");
+    var $wrap = $section.find(".model-sql-wrap");
+    // Rebuild the wrap body each model switch so a prior model's toggle/diff
+    // never leaks; the Copy button is re-created here too.
+    $wrap.empty();
+    var $copy = $("<button>").attr("type", "button")
+      .addClass("sql-copy model-sql-copy").text("Copy");
+    $copy.on("click.cuteDbtModelSql", function (e) {
       e.preventDefault();
       e.stopPropagation();
       copySql(raw, $(this));
     });
+    $wrap.append($copy);
+    if (hasDiff) {
+      var $diffPre = $("<pre>").addClass("sql-block model-sql-block sql-diff-view").append(
+        $("<code>").addClass("model-sql-code").html(renderBlockDiff(m.sql_diff, highlightSql))
+      );
+      var $rawPre = $("<pre>").addClass("sql-block model-sql-block sql-raw-view").prop("hidden", true).append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      var $toggle = $("<div>").addClass("yaml-diff-toggle model-sql-toggle");
+      var $diffBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn active").attr("data-view", "diff").text("Diff");
+      var $rawBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn").attr("data-view", "raw").text("Raw");
+      $toggle.append($diffBtn).append($rawBtn);
+      $toggle.on("click", ".yaml-view-btn", function () {
+        var view = $(this).attr("data-view");
+        $toggle.find(".yaml-view-btn").removeClass("active");
+        $(this).addClass("active");
+        $diffPre.prop("hidden", view !== "diff");
+        $rawPre.prop("hidden", view !== "raw");
+      });
+      $wrap.append($toggle).append($diffPre).append($rawPre);
+    } else {
+      var $pre = $("<pre>").addClass("sql-block model-sql-block").append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      $wrap.append($pre);
+    }
   }
 
   function renderDagLegend() {
@@ -4964,17 +5004,20 @@ <h2>Expected</h2>
   // `__cuteParseCsv` seam introduced in cute-dbt#66).
   window.__cuteHighlightYaml = highlightYaml;
 
-  // cute-dbt#96 concern 2 — render a reconstructed inline YAML block diff
-  // (domain::pr_diff::YamlBlockDiff) as HTML for a <pre><code>. Each line is
-  // a block-level `.diff-line` span (so a full-width add/remove row tint fills
+  // cute-dbt#96 concern 2 / cute-dbt#111 — render a reconstructed inline
+  // block diff (domain::pr_diff::BlockDiff) as HTML for a <pre><code>.
+  // Content-agnostic: `highlightFn` highlights CONTEXT lines only (YAML
+  // for the test drawer, SQL for the Model SQL section). Each line is a
+  // block-level `.diff-line` span (so a full-width add/remove row tint fills
   // the line) — block layout provides the breaks, so the spans are joined with
   // "" (a literal "\n" would render as a blank row between blocks in a <pre>);
   // each is prefixed by a +/-/space sigil.
-  // Context lines reuse the YAML highlighter; changed lines render escaped
-  // text with the intra-line `emphasis` range wrapped in <strong>. The
-  // emphasis offsets are CODEPOINT indices (Rust `chars()`), so the slice
-  // goes through `Array.from` — UTF-16 `.slice` would drift on astral chars.
-  function renderYamlDiff(diff) {
+  // Changed lines BYPASS `highlightFn` (the cute-dbt#96 lesson): they render
+  // escaped text with the intra-line `emphasis` range wrapped in <strong>, so
+  // the emphasis offsets land on the RAW text. The offsets are CODEPOINT
+  // indices (Rust `chars()`), so the slice goes through `Array.from` — UTF-16
+  // `.slice` would drift on astral chars.
+  function renderBlockDiff(diff, highlightFn) {
     return diff.lines.map(function (ln) {
       var cls = ln.kind === "added" ? "diff-added"
               : ln.kind === "removed" ? "diff-removed"
@@ -4982,7 +5025,7 @@ <h2>Expected</h2>
       var sigil = ln.kind === "added" ? "+" : ln.kind === "removed" ? "-" : " ";
       var body;
       if (ln.kind === "context") {
-        body = highlightYaml(ln.text);
+        body = highlightFn(ln.text);
       } else if (ln.emphasis) {
         var cps = Array.from(ln.text);
         var a = ln.emphasis[0], b = ln.emphasis[1];
@@ -4997,7 +5040,11 @@ <h2>Expected</h2>
            + '</span>';
     }).join("");
   }
-  // Expose for headless JS unit tests (parallels __cuteHighlightYaml).
+  // Expose for headless JS unit tests (parallels __cuteHighlightYaml). The
+  // #96 name is kept as a thin alias so existing headless assertions and the
+  // YAML call site stay byte-stable; new SQL callers pass `highlightSql`.
+  function renderYamlDiff(diff) { return renderBlockDiff(diff, highlightYaml); }
+  window.__cuteRenderBlockDiff = renderBlockDiff;
   window.__cuteRenderYamlDiff = renderYamlDiff;
 
   function copySql(text, $btn) {
diff --git a/examples/playground-report.html b/examples/playground-report.html
index 70f6f95f..f4e9473e 100644
--- a/examples/playground-report.html
+++ b/examples/playground-report.html
@@ -4369,11 +4369,17 @@ <h2>Expected</h2>
     }
   }
 
-  // cute-dbt#47 — populate (or hide) the per-model Model SQL section.
-  // The askama template emits one static <section class="model-sql">; JS
-  // rebinds its <code> body and Copy handler each time the user selects a
+  // cute-dbt#47 / cute-dbt#111 — populate (or hide) the per-model Model SQL
+  // section. The askama template emits one static <section class="model-sql">;
+  // JS rebinds its body and Copy handler each time the user selects a
   // different model. When `raw_sql` is missing, hide the whole section
   // (defensive — dbt 1.8+ populates raw_code on every node).
+  //
+  // cute-dbt#111: when the selected model carries an inline SQL diff
+  // (m.sql_diff — PR-diff mode, the model's .sql changed), the section shows
+  // a Raw↔Diff toggle defaulting to Diff (rendered via renderBlockDiff with
+  // the SQL highlighter on context lines only). Absent a diff it renders the
+  // plain raw SQL exactly as cute-dbt#47 did. Copy always copies the raw SQL.
   function renderModelSql(m) {
     var $section = $(".model-sql");
     var raw = m && m.raw_sql;
@@ -4382,13 +4388,47 @@ <h2>Expected</h2>
       return;
     }
     $section.show();
-    $section.find(".model-sql-code").html(highlightSql(raw));
-    var $copy = $section.find(".model-sql-copy");
-    $copy.off("click.cuteDbtModelSql").on("click.cuteDbtModelSql", function (e) {
+    var hasDiff = m.sql_diff && m.sql_diff.lines && m.sql_diff.lines.length;
+    $section.find(".model-sql-summary-hint").text(hasDiff ? "diff" : "raw, with Jinja");
+    var $wrap = $section.find(".model-sql-wrap");
+    // Rebuild the wrap body each model switch so a prior model's toggle/diff
+    // never leaks; the Copy button is re-created here too.
+    $wrap.empty();
+    var $copy = $("<button>").attr("type", "button")
+      .addClass("sql-copy model-sql-copy").text("Copy");
+    $copy.on("click.cuteDbtModelSql", function (e) {
       e.preventDefault();
       e.stopPropagation();
       copySql(raw, $(this));
     });
+    $wrap.append($copy);
+    if (hasDiff) {
+      var $diffPre = $("<pre>").addClass("sql-block model-sql-block sql-diff-view").append(
+        $("<code>").addClass("model-sql-code").html(renderBlockDiff(m.sql_diff, highlightSql))
+      );
+      var $rawPre = $("<pre>").addClass("sql-block model-sql-block sql-raw-view").prop("hidden", true).append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      var $toggle = $("<div>").addClass("yaml-diff-toggle model-sql-toggle");
+      var $diffBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn active").attr("data-view", "diff").text("Diff");
+      var $rawBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn").attr("data-view", "raw").text("Raw");
+      $toggle.append($diffBtn).append($rawBtn);
+      $toggle.on("click", ".yaml-view-btn", function () {
+        var view = $(this).attr("data-view");
+        $toggle.find(".yaml-view-btn").removeClass("active");
+        $(this).addClass("active");
+        $diffPre.prop("hidden", view !== "diff");
+        $rawPre.prop("hidden", view !== "raw");
+      });
+      $wrap.append($toggle).append($diffPre).append($rawPre);
+    } else {
+      var $pre = $("<pre>").addClass("sql-block model-sql-block").append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      $wrap.append($pre);
+    }
   }
 
   function renderDagLegend() {
@@ -4964,17 +5004,20 @@ <h2>Expected</h2>
   // `__cuteParseCsv` seam introduced in cute-dbt#66).
   window.__cuteHighlightYaml = highlightYaml;
 
-  // cute-dbt#96 concern 2 — render a reconstructed inline YAML block diff
-  // (domain::pr_diff::YamlBlockDiff) as HTML for a <pre><code>. Each line is
-  // a block-level `.diff-line` span (so a full-width add/remove row tint fills
+  // cute-dbt#96 concern 2 / cute-dbt#111 — render a reconstructed inline
+  // block diff (domain::pr_diff::BlockDiff) as HTML for a <pre><code>.
+  // Content-agnostic: `highlightFn` highlights CONTEXT lines only (YAML
+  // for the test drawer, SQL for the Model SQL section). Each line is a
+  // block-level `.diff-line` span (so a full-width add/remove row tint fills
   // the line) — block layout provides the breaks, so the spans are joined with
   // "" (a literal "\n" would render as a blank row between blocks in a <pre>);
   // each is prefixed by a +/-/space sigil.
-  // Context lines reuse the YAML highlighter; changed lines render escaped
-  // text with the intra-line `emphasis` range wrapped in <strong>. The
-  // emphasis offsets are CODEPOINT indices (Rust `chars()`), so the slice
-  // goes through `Array.from` — UTF-16 `.slice` would drift on astral chars.
-  function renderYamlDiff(diff) {
+  // Changed lines BYPASS `highlightFn` (the cute-dbt#96 lesson): they render
+  // escaped text with the intra-line `emphasis` range wrapped in <strong>, so
+  // the emphasis offsets land on the RAW text. The offsets are CODEPOINT
+  // indices (Rust `chars()`), so the slice goes through `Array.from` — UTF-16
+  // `.slice` would drift on astral chars.
+  function renderBlockDiff(diff, highlightFn) {
     return diff.lines.map(function (ln) {
       var cls = ln.kind === "added" ? "diff-added"
               : ln.kind === "removed" ? "diff-removed"
@@ -4982,7 +5025,7 @@ <h2>Expected</h2>
       var sigil = ln.kind === "added" ? "+" : ln.kind === "removed" ? "-" : " ";
       var body;
       if (ln.kind === "context") {
-        body = highlightYaml(ln.text);
+        body = highlightFn(ln.text);
       } else if (ln.emphasis) {
         var cps = Array.from(ln.text);
         var a = ln.emphasis[0], b = ln.emphasis[1];
@@ -4997,7 +5040,11 @@ <h2>Expected</h2>
            + '</span>';
     }).join("");
   }
-  // Expose for headless JS unit tests (parallels __cuteHighlightYaml).
+  // Expose for headless JS unit tests (parallels __cuteHighlightYaml). The
+  // #96 name is kept as a thin alias so existing headless assertions and the
+  // YAML call site stay byte-stable; new SQL callers pass `highlightSql`.
+  function renderYamlDiff(diff) { return renderBlockDiff(diff, highlightYaml); }
+  window.__cuteRenderBlockDiff = renderBlockDiff;
   window.__cuteRenderYamlDiff = renderYamlDiff;
 
   function copySql(text, $btn) {
diff --git a/features/pr_diff_scoping.feature b/features/pr_diff_scoping.feature
index 1153bed2..7e5d65ec 100644
--- a/features/pr_diff_scoping.feature
+++ b/features/pr_diff_scoping.feature
@@ -355,3 +355,57 @@ Feature: Diff-scope unit tests and models via PR file diff (CI path)
     Then the exit code is 0
     And the test "test_a" carries an inline YAML diff with a removed and an added line
     And the test "test_b" carries no inline YAML diff
+
+  # --- cute-dbt#111: inline SQL diff for a changed model's raw_code ---
+  #
+  # The same line-diff substrate (#96) applied to a model's RAW SQL
+  # (`raw_code`), rendered in the Model SQL section with a Raw↔Diff toggle.
+  # `raw_code` is read from the MANIFEST (not the filesystem), so the SQL
+  # diff fires on a changed `.sql` without a `--project-root` source read.
+  # Reconstruction reuses the N7b drift guard + the whitespace-as-standard
+  # rule, so a stale diff or a pure re-indent shows the plain SQL view.
+  # The interior reconstruction arithmetic is mutation-killed by the
+  # `reconstruct_model_sql_diffs` / `reconstruct_one` boundary tables in
+  # src/domain/pr_diff.rs; these scenarios pin the user-visible outcome.
+
+  Scenario: A changed model's SQL carries an inline diff in the Model SQL section
+    Given a PR diff that changes the SQL of "models/marts/core/dim_payers.sql"
+    And the manifest contains a model with raw SQL at "models/marts/core/dim_payers.sql"
+    And the model "dim_payers" has a unit test "test_dim_payers_injects_unknown_sentinel"
+    When I run cute-dbt with --manifest current.json --pr-diff @diff.patch --project-root . --out report.html
+    Then the exit code is 0
+    And the rendered report's models-in-scope listing contains "dim_payers"
+    And the model "dim_payers" carries an inline SQL diff with a removed and an added line
+
+  Scenario: A model in scope only via a changed test shows the plain SQL view (no diff)
+    # dim_payers.sql is NOT changed; the model is in scope only because its
+    # test's YAML changed. Its raw_code is untouched ⇒ no SQL hunk ⇒ no diff.
+    Given a PR diff that changes "models/marts/core/_core__models.yml"
+    And the manifest contains a model with raw SQL at "models/marts/core/dim_payers.sql"
+    And the model "dim_payers" has a unit test "test_a" declared in "models/marts/core/_core__models.yml"
+    When I run cute-dbt with --manifest current.json --pr-diff @diff.patch --project-root . --out report.html
+    Then the exit code is 0
+    And the rendered report's models-in-scope listing contains "dim_payers"
+    And the model "dim_payers" carries no inline SQL diff
+
+  Scenario: A stale SQL diff degrades to the plain SQL view
+    # Revision drift: the hunk's `+` lines don't match the model's raw_code,
+    # so N7b fails and cute-dbt shows the plain SQL rather than a wrong diff.
+    Given a PR diff whose SQL hunks no longer line up with "models/marts/core/dim_payers.sql"
+    And the manifest contains a model with raw SQL at "models/marts/core/dim_payers.sql"
+    And the model "dim_payers" has a unit test "test_dim_payers_injects_unknown_sentinel"
+    When I run cute-dbt with --manifest current.json --pr-diff @diff.patch --project-root . --out report.html
+    Then the exit code is 0
+    And the rendered report's models-in-scope listing contains "dim_payers"
+    And the model "dim_payers" carries no inline SQL diff
+
+  Scenario: A whitespace-only SQL change shows the plain SQL view (no diff)
+    # Re-indenting the model SQL with no substantive change: whitespace is
+    # ignored as standard, so the change-pair is suppressed ⇒ no SQL diff.
+    Given a PR diff that re-indents the SQL of "models/marts/core/dim_payers.sql" (whitespace only)
+    And the manifest contains a model with raw SQL at "models/marts/core/dim_payers.sql"
+    And the model "dim_payers" has a unit test "test_dim_payers_injects_unknown_sentinel"
+    When I run cute-dbt with --manifest current.json --pr-diff @diff.patch --project-root . --out report.html
+    Then the exit code is 0
+    And the rendered report's models-in-scope listing contains "dim_payers"
+    And the model "dim_payers" carries no inline SQL diff
diff --git a/src/adapters/render.rs b/src/adapters/render.rs
index 79e3aad0..9c8f2c54 100644
--- a/src/adapters/render.rs
+++ b/src/adapters/render.rs
@@ -66,8 +66,8 @@ use crate::adapters::asset_embed::{
 };
 use crate::adapters::cte_engine::{TERMINAL_NODE_NAME, parse_cte_graph};
 use crate::domain::{
-    BANNER_EMPTY_SCOPE, CteGraph, EdgeType, InScopeSet, Manifest, ModelInScopeSet, Node, NodeId,
-    UnitTest, UnitTestGiven, UnitTestYamlBlock, YamlBlockDiff, resolve_target_model,
+    BANNER_EMPTY_SCOPE, BlockDiff, CteGraph, EdgeType, InScopeSet, Manifest, ModelInScopeSet, Node,
+    NodeId, UnitTest, UnitTestGiven, UnitTestYamlBlock, resolve_target_model,
 };
 
 /// Snake-case wire key for an [`EdgeType`] — the exact JSON-serde string
@@ -204,6 +204,15 @@ pub struct ModelPayload {
     /// stay stable.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_sql: Option<String>,
+    /// Inline diff of this model's RAW SQL (`raw_code`) when the PR diff
+    /// changed the model's `.sql` (cute-dbt#111) — present only in PR-diff
+    /// mode, block aligned + touched + a substantive (non-whitespace)
+    /// change. `None` (key omitted) for baseline mode, models in scope
+    /// only via a changed test, stale diffs, and whitespace-only edits, so
+    /// the template's Model SQL section falls back to the plain raw view.
+    /// Mirrors [`TestPayload::yaml_diff`]'s threading exactly.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sql_diff: Option<BlockDiff>,
     /// Unit tests targeting this model that are in scope. Empty
     /// `[]` triggers the "0 unit tests wired" empty state.
     pub tests: Vec<TestPayload>,
@@ -324,7 +333,7 @@ pub struct TestPayload {
     /// fall outside the block, so the drawer falls back to the plain
     /// authored-YAML view. Mirrors `authoring_yaml`'s threading exactly.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub yaml_diff: Option<YamlBlockDiff>,
+    pub yaml_diff: Option<BlockDiff>,
     /// Ordered list of fixture inputs for the test (`given[…]`).
     pub given: Vec<GivenPayload>,
     /// Expected result block (`expect`).
@@ -498,7 +507,8 @@ pub fn build_payload(
     changed: &InScopeSet,
     models_in_scope: &ModelInScopeSet,
     authoring_yaml: &HashMap<String, UnitTestYamlBlock>,
-    yaml_diffs: &HashMap<String, YamlBlockDiff>,
+    yaml_diffs: &HashMap<String, BlockDiff>,
+    sql_diffs: &HashMap<String, BlockDiff>,
     baseline_label: &str,
 ) -> ReportPayload {
     let model_tests = index_tests_for_models(current, models_in_scope);
@@ -515,6 +525,7 @@ pub fn build_payload(
             changed,
             authoring_yaml,
             yaml_diffs,
+            sql_diffs,
         ));
     }
     ReportPayload {
@@ -551,7 +562,8 @@ pub fn render_report(
     models_in_scope: &ModelInScopeSet,
     changed: &InScopeSet,
     authoring_yaml: &HashMap<String, UnitTestYamlBlock>,
-    yaml_diffs: &HashMap<String, YamlBlockDiff>,
+    yaml_diffs: &HashMap<String, BlockDiff>,
+    sql_diffs: &HashMap<String, BlockDiff>,
     baseline_label: &str,
     scope_source: ScopeSource,
     report_title: &str,
@@ -563,6 +575,7 @@ pub fn render_report(
         models_in_scope,
         authoring_yaml,
         yaml_diffs,
+        sql_diffs,
         baseline_label,
     );
     // The empty-scope banner contract reads the TRUE in-scope set, not the
@@ -596,7 +609,8 @@ fn build_model_payload(
     tests: &[(&str, &UnitTest)],
     changed: &InScopeSet,
     authoring_yaml: &HashMap<String, UnitTestYamlBlock>,
-    yaml_diffs: &HashMap<String, YamlBlockDiff>,
+    yaml_diffs: &HashMap<String, BlockDiff>,
+    sql_diffs: &HashMap<String, BlockDiff>,
 ) -> ModelPayload {
     let bare_name = leaf_segment(model.id().as_str()).to_owned();
     let compiled_code = model.compiled_code().unwrap_or_default();
@@ -609,6 +623,9 @@ fn build_model_payload(
         .raw_code()
         .filter(|s| !s.is_empty())
         .map(str::to_owned);
+    // SQL diff is keyed by the model's FULL node id (the
+    // `reconstruct_model_sql_diffs` key), not the bare name.
+    let sql_diff = sql_diffs.get(model.id().as_str()).cloned();
     let test_payloads = tests
         .iter()
         .map(|(id, ut)| {
@@ -627,6 +644,7 @@ fn build_model_payload(
         dag: DagPayload { nodes, edges },
         compiled_sql,
         raw_sql,
+        sql_diff,
         tests: test_payloads,
         is_recursive,
     }
@@ -720,7 +738,7 @@ fn build_test_payload(
     graph: &CteGraph,
     changed: &InScopeSet,
     authoring_yaml: Option<&UnitTestYamlBlock>,
-    yaml_diff: Option<&YamlBlockDiff>,
+    yaml_diff: Option<&BlockDiff>,
 ) -> TestPayload {
     let given = unit_test
         .given()
@@ -883,8 +901,9 @@ fn leaf_segment(id: &str) -> &str {
 mod tests {
     use super::*;
     use crate::domain::{
-        Checksum, CteEdge, CteNode, DEFAULT_REPORT_TITLE, DependsOn, EdgeType, Manifest,
-        ManifestMetadata, NodeConfig, NodeId, UnitTest, UnitTestExpect, UnitTestGiven,
+        Checksum, CteEdge, CteNode, DEFAULT_REPORT_TITLE, DependsOn, DiffLine, DiffLineKind,
+        EdgeType, Manifest, ManifestMetadata, NodeConfig, NodeId, UnitTest, UnitTestExpect,
+        UnitTestGiven,
     };
     use serde_json::json;
     use std::collections::{BTreeMap, HashMap};
@@ -1211,6 +1230,7 @@ mod tests {
             &ModelInScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "main@a1f3c7e",
         );
         assert_eq!(payload.baseline, "main@a1f3c7e");
@@ -1232,6 +1252,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
         );
         assert_eq!(payload.models.len(), 1);
@@ -1261,12 +1282,77 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
         );
         assert_eq!(payload.models.len(), 1);
         assert_eq!(payload.models[0].raw_sql.as_deref(), Some(raw));
     }
 
+    #[test]
+    fn build_payload_carries_sql_diff_keyed_by_full_model_id() {
+        // cute-dbt#111 — a model whose full node id is in the `sql_diffs`
+        // map surfaces `ModelPayload.sql_diff`. Keyed by the FULL id (the
+        // `reconstruct_model_sql_diffs` key), not the bare name.
+        let node = model_node("model.shop.dim_x", "body", Some("select 1"));
+        let manifest = manifest_for(vec![node], vec![]);
+        let models = ModelInScopeSet::from_iter([NodeId::new("model.shop.dim_x")]);
+        let mut sql_diffs = HashMap::new();
+        sql_diffs.insert(
+            "model.shop.dim_x".to_owned(),
+            BlockDiff {
+                lines: vec![DiffLine {
+                    kind: DiffLineKind::Added,
+                    text: "select 1".to_owned(),
+                    emphasis: None,
+                }],
+            },
+        );
+        let payload = build_payload(
+            &manifest,
+            &InScopeSet::new(),
+            &models,
+            &HashMap::new(),
+            &HashMap::new(),
+            &sql_diffs,
+            "baseline.json",
+        );
+        assert_eq!(payload.models.len(), 1);
+        let sd = payload.models[0]
+            .sql_diff
+            .as_ref()
+            .expect("sql_diff present for the keyed model");
+        assert_eq!(sd.lines.len(), 1);
+        assert_eq!(sd.lines[0].kind, DiffLineKind::Added);
+    }
+
+    #[test]
+    fn build_payload_sql_diff_is_none_when_model_not_in_diff_map() {
+        // No entry for this model → sql_diff omitted (skip_serializing_if).
+        // The baseline path passes an empty map, so baseline reports never
+        // carry a sql_diff key — the manifest-digest snapshot is unmoved.
+        let node = model_node("model.shop.dim_y", "body", Some("select 1"));
+        let manifest = manifest_for(vec![node], vec![]);
+        let models = ModelInScopeSet::from_iter([NodeId::new("model.shop.dim_y")]);
+        let payload = build_payload(
+            &manifest,
+            &InScopeSet::new(),
+            &models,
+            &HashMap::new(),
+            &HashMap::new(),
+            &HashMap::new(),
+            "baseline.json",
+        );
+        assert_eq!(payload.models.len(), 1);
+        assert!(payload.models[0].sql_diff.is_none());
+        // And it is omitted from the JSON wire (not `"sql_diff":null`).
+        let json = serde_json::to_string(&payload.models[0]).expect("serialize");
+        assert!(
+            !json.contains("sql_diff"),
+            "absent sql_diff must be omitted from the wire; got {json}",
+        );
+    }
+
     #[test]
     fn build_payload_raw_sql_is_none_when_node_has_no_raw_code() {
         // Defensive — older manifests / hand-crafted fixtures lacking
@@ -1281,6 +1367,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
         );
         assert_eq!(payload.models.len(), 1);
@@ -1301,6 +1388,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
         );
         assert_eq!(payload.models.len(), 1);
@@ -1320,6 +1408,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
         );
         assert_eq!(payload.models.len(), 1);
@@ -1336,6 +1425,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         assert!(payload.models.is_empty());
@@ -1370,6 +1460,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         assert_eq!(payload.models.len(), 1);
@@ -1419,6 +1510,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         // No models in scope → no payload entries; the indexer's None
@@ -1438,6 +1530,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let model = &payload.models[0];
@@ -1462,6 +1555,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let model = &payload.models[0];
@@ -1491,6 +1585,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         assert_eq!(
@@ -1513,6 +1608,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         assert_eq!(payload.models.len(), 1);
@@ -1539,6 +1635,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1573,6 +1670,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1613,6 +1711,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1660,6 +1759,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1713,6 +1813,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1757,6 +1858,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1792,6 +1894,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         let test = &payload.models[0].tests[0];
@@ -1814,6 +1917,7 @@ mod tests {
             &models,
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
         );
         assert!(payload.models[0].is_recursive);
@@ -1902,6 +2006,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
@@ -1941,6 +2046,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             "Q3 unit test review",
@@ -1980,6 +2086,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
@@ -2009,6 +2116,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             "Q3 review",
@@ -2044,6 +2152,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             "<script>alert(1)</script>",
@@ -2102,6 +2211,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
@@ -2137,6 +2247,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "",
             ScopeSource::PrDiff,
             DEFAULT_REPORT_TITLE,
@@ -2173,6 +2284,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "baseline.json",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
@@ -2209,6 +2321,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "lab1@aaaaaaa",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
@@ -2254,6 +2367,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
@@ -2320,6 +2434,7 @@ mod tests {
             &InScopeSet::new(),
             &HashMap::new(),
             &HashMap::new(),
+            &HashMap::new(),
             "b",
             ScopeSource::Baseline,
             DEFAULT_REPORT_TITLE,
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
index ac8ad402..551e48f7 100644
--- a/src/cli/mod.rs
+++ b/src/cli/mod.rs
@@ -40,10 +40,10 @@ use crate::adapters::manifest::{FileManifestSource, load_baseline};
 use crate::adapters::render::{ScopeSource, index_tests_for_models, render_report};
 use crate::adapters::source_yaml::FsSourceYamlReader;
 use crate::domain::{
-    DEFAULT_REPORT_TITLE, InScopeSet, Manifest, ModelInScopeSet, NormalizedDiffIndex,
-    PreflightError, ScopeInput, ScopeSelection, UnitTestYamlBlock, YamlBlockDiff,
-    extract_unit_test_block, preflight_compiled, reconstruct_block_diffs, refine_changed_by_hunks,
-    select_in_scope,
+    BlockDiff, DEFAULT_REPORT_TITLE, InScopeSet, Manifest, ModelInScopeSet, NormalizedDiffIndex,
+    PreflightError, ScopeInput, ScopeSelection, UnitTestYamlBlock, extract_unit_test_block,
+    preflight_compiled, reconstruct_block_diffs, reconstruct_model_sql_diffs,
+    refine_changed_by_hunks, select_in_scope,
 };
 use crate::ports::{ManifestSource, SourceYamlReader};
 
@@ -164,12 +164,24 @@ fn execute(cli: &Cli) -> Result<(), RunError> {
     // PrDiff arm only — baseline mode has no hunks to reconstruct from, so
     // the drawer shows the plain authored YAML. Threaded into render
     // exactly like `authoring_yaml` (the slice spans are already in hand).
-    let yaml_diffs: HashMap<String, YamlBlockDiff> = match &scope_input {
+    let yaml_diffs: HashMap<String, BlockDiff> = match &scope_input {
         ScopeInput::PrDiff { index } => {
             reconstruct_block_diffs(&current, &changed, &authoring_yaml, index)
         }
         ScopeInput::Baseline { .. } => HashMap::new(),
     };
+    // Inline model SQL diffs (cute-dbt#111): reconstruct an in-place diff
+    // of each in-scope model's RAW `raw_code` whose `.sql` the PR diff
+    // changed. PrDiff arm only — baseline mode has no hunks, so the Model
+    // SQL section shows the plain raw view. `raw_code` comes from the
+    // manifest (no filesystem read needed, unlike the YAML drawer), so this
+    // reads `models_in_scope` directly; ADR-3 scope selection is untouched.
+    let sql_diffs: HashMap<String, BlockDiff> = match &scope_input {
+        ScopeInput::PrDiff { index } => {
+            reconstruct_model_sql_diffs(&current, &models_in_scope, index)
+        }
+        ScopeInput::Baseline { .. } => HashMap::new(),
+    };
     let (report_title, report_subtitle) = resolve_report_strings(cli);
     let (baseline_label, scope_source) = scope_banner(cli, &scope_input);
     render(
@@ -180,6 +192,7 @@ fn execute(cli: &Cli) -> Result<(), RunError> {
         &changed,
         &authoring_yaml,
         &yaml_diffs,
+        &sql_diffs,
         &baseline_label,
         scope_source,
         &report_title,
@@ -376,7 +389,8 @@ fn render(
     models_in_scope: &ModelInScopeSet,
     changed: &InScopeSet,
     authoring_yaml: &HashMap<String, UnitTestYamlBlock>,
-    yaml_diffs: &HashMap<String, YamlBlockDiff>,
+    yaml_diffs: &HashMap<String, BlockDiff>,
+    sql_diffs: &HashMap<String, BlockDiff>,
     baseline_label: &str,
     scope_source: ScopeSource,
     report_title: &str,
@@ -390,6 +404,7 @@ fn render(
         changed,
         authoring_yaml,
         yaml_diffs,
+        sql_diffs,
         baseline_label,
         scope_source,
         report_title,
diff --git a/src/domain/mod.rs b/src/domain/mod.rs
index 6b1fd4c9..6d120dab 100644
--- a/src/domain/mod.rs
+++ b/src/domain/mod.rs
@@ -51,8 +51,8 @@ pub use cte::{CteEdge, CteGraph, CteNode, EdgeType, Span};
 pub use manifest::{Checksum, DependsOn, Manifest, ManifestMetadata, Node, NodeConfig, NodeId};
 pub use path::{match_changed_path, normalize_path};
 pub use pr_diff::{
-    DiffLine, DiffLineKind, FileHunks, Hunk, NormalizedDiffIndex, PrDiff, YamlBlockDiff,
-    reconstruct_block_diffs, refine_changed_by_hunks,
+    BlockDiff, DiffLine, DiffLineKind, FileHunks, Hunk, NormalizedDiffIndex, PrDiff,
+    reconstruct_block_diffs, reconstruct_model_sql_diffs, refine_changed_by_hunks, ws_equal,
 };
 pub use preflight::{PreflightError, preflight_compiled};
 pub use scope::{ScopeInput, ScopeSelection, select_in_scope};
diff --git a/src/domain/pr_diff.rs b/src/domain/pr_diff.rs
index 188ec265..00b20a65 100644
--- a/src/domain/pr_diff.rs
+++ b/src/domain/pr_diff.rs
@@ -35,9 +35,9 @@ use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 
-use crate::domain::manifest::Manifest;
+use crate::domain::manifest::{Manifest, Node};
 use crate::domain::path::normalize_path;
-use crate::domain::state::InScopeSet;
+use crate::domain::state::{InScopeSet, ModelInScopeSet};
 use crate::domain::unit_test::UnitTest;
 use crate::domain::unit_test_yaml::UnitTestYamlBlock;
 
@@ -209,16 +209,34 @@ pub fn hunk_touches_block(block_start: usize, block_end: usize, hunk: &Hunk) ->
 /// Added lines whose new-side position falls outside the block are ignored
 /// (a hunk may straddle the block edge); a hunk with no `+` lines (a pure
 /// deletion) is vacuously aligned.
+///
+/// The block is addressed by `(raw, block_start, block_end)` — the
+/// content-agnostic shape (cute-dbt#111) [`hunk_touches_block`] already
+/// uses, so the same drift guard serves the `unit_test` YAML block (#96)
+/// and a model's SQL `raw_code` (#111). YAML callers pass
+/// `(&block.raw, block.block_start, block.block_end)`.
+///
+/// **Whitespace-EXACT by design.** This is the N7b revision-staleness
+/// check (does the diff's new side still describe the working tree?), so a
+/// whitespace divergence here is *genuine* drift and must NOT be
+/// normalized. Whitespace-insensitivity ([`ws_equal`]) applies only
+/// downstream of N7b, to the removed-vs-added change test in
+/// `reconstruct_one`.
 #[must_use]
-pub fn block_aligns_with_hunks(block: &UnitTestYamlBlock, hunks: &[Hunk]) -> bool {
-    let block_lines: Vec<&str> = block.raw.split('\n').collect();
+pub fn block_aligns_with_hunks(
+    raw: &str,
+    block_start: usize,
+    block_end: usize,
+    hunks: &[Hunk],
+) -> bool {
+    let block_lines: Vec<&str> = raw.split('\n').collect();
     for hunk in hunks {
         for (k, added) in hunk.added_lines.iter().enumerate() {
             let file_line = hunk.new_start + k; // 1-based new-side line
-            if file_line < block.block_start || file_line > block.block_end {
+            if file_line < block_start || file_line > block_end {
                 continue; // outside this block — not this block's concern
             }
-            let offset = file_line - block.block_start; // 0-based into raw
+            let offset = file_line - block_start; // 0-based into raw
             let Some(actual) = block_lines.get(offset) else {
                 return false; // claims a line the block doesn't have
             };
@@ -230,6 +248,22 @@ pub fn block_aligns_with_hunks(block: &UnitTestYamlBlock, hunks: &[Hunk]) -> boo
     true
 }
 
+/// Whether two lines carry identical non-whitespace content — the
+/// `git --ignore-all-space` change test (cute-dbt#111).
+///
+/// `true` when the two lines tokenize to the same sequence of
+/// whitespace-separated runs, so a re-indentation, a trailing-whitespace
+/// edit, or a blank-line churn that leaves the substantive content
+/// untouched is NOT treated as a change. Applied ONLY to the
+/// removed-vs-added comparison inside `reconstruct_one` (downstream of
+/// the whitespace-EXACT N7b guard, [`block_aligns_with_hunks`]), so a
+/// removed/added pair that is `ws_equal` renders as Context — no removed
+/// splice, no intra-line emphasis. std-only.
+#[must_use]
+pub fn ws_equal(a: &str, b: &str) -> bool {
+    a.split_whitespace().eq(b.split_whitespace())
+}
+
 /// The pure per-test decision: should a `changed` test STAY changed after
 /// block-precise narrowing?
 ///
@@ -255,7 +289,7 @@ pub fn block_changed_by_hunks(block: Option<&UnitTestYamlBlock>, hunks: &[Hunk])
     let Some(block) = block else {
         return true; // absent block → conservative keep
     };
-    if !block_aligns_with_hunks(block, hunks) {
+    if !block_aligns_with_hunks(&block.raw, block.block_start, block.block_end, hunks) {
         return true; // stale diff (N7b mismatch) → conservative keep
     }
     hunks
@@ -342,18 +376,42 @@ pub struct DiffLine {
     pub emphasis: Option<(usize, usize)>,
 }
 
-/// A reconstructed inline diff of one `unit_test`'s authored YAML block.
+/// A reconstructed inline diff of one contiguous source block.
+///
+/// Content-agnostic by construction — the lines are plain `&str`
+/// [`DiffLine`]s, so the same POD serves both the `unit_test` authored
+/// YAML block (cute-dbt#96) and a changed model's SQL `raw_code`
+/// (cute-dbt#111). The JSON field that carries it on a `unit_test` is
+/// still named `yaml_diff` (the #96 wire contract is unchanged); a model
+/// carries it under `sql_diff`. Renamed from `YamlBlockDiff` at
+/// cute-dbt#111 — the rename is internal (the lib is internal-only in
+/// v0.x) and the wire shape is identical.
 ///
 /// Additive POD (ADR-5). The full block is rendered as ordered
 /// [`DiffLine`]s (context + added from the working-tree block, removed
-/// spliced in from the diff hunks), so the drawer can show the edit in
+/// spliced in from the diff hunks), so the view can show the edit in
 /// place rather than just the post-edit text.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct YamlBlockDiff {
+pub struct BlockDiff {
     /// The block's diff lines, top to bottom.
     pub lines: Vec<DiffLine>,
 }
 
+impl BlockDiff {
+    /// Whether this diff carries at least one substantive (non-context)
+    /// line — an Added or Removed [`DiffLine`].
+    ///
+    /// A reconstruction whose touching hunks were all whitespace-only
+    /// (cute-dbt#111) leaves an all-Context diff: the callers
+    /// ([`reconstruct_block_diffs`] / [`reconstruct_model_sql_diffs`]) test
+    /// this and emit no `BlockDiff` for it, so the view falls back to plain
+    /// text rather than showing an identical-looking "diff".
+    #[must_use]
+    pub fn has_real_change(&self) -> bool {
+        self.lines.iter().any(|l| l.kind != DiffLineKind::Context)
+    }
+}
+
 /// The codepoint `[start, end)` span of `line` that differs from `other`,
 /// found by trimming the common prefix and common suffix.
 ///
@@ -394,7 +452,7 @@ pub fn intra_line_span(line: &str, other: &str) -> Option<(usize, usize)> {
 ///
 /// For every id in `changed`, resolve its sliced block (`blocks`) and the
 /// hunks touching its declaring file ([`NormalizedDiffIndex::hunks_for`]).
-/// Emit a [`YamlBlockDiff`] **only** when the block is present, the hunks
+/// Emit a [`BlockDiff`] **only** when the block is present, the hunks
 /// still align with it ([`block_aligns_with_hunks`]), and at least one hunk
 /// touches it ([`hunk_touches_block`]) — i.e. this test's own definition was
 /// edited in the diff. Absent / stale / untouched ids get no entry, so the
@@ -412,7 +470,7 @@ pub fn reconstruct_block_diffs(
     changed: &InScopeSet,
     blocks: &HashMap<String, UnitTestYamlBlock>,
     index: &NormalizedDiffIndex,
-) -> HashMap<String, YamlBlockDiff> {
+) -> HashMap<String, BlockDiff> {
     let mut out = HashMap::new();
     for id in changed.iter() {
         let Some(block) = blocks.get(id) else {
@@ -422,7 +480,7 @@ pub fn reconstruct_block_diffs(
             .unit_test(id)
             .and_then(UnitTest::original_file_path)
             .map_or(&[][..], |ofp| index.hunks_for(ofp));
-        if !block_aligns_with_hunks(block, hunks) {
+        if !block_aligns_with_hunks(&block.raw, block.block_start, block.block_end, hunks) {
             continue; // stale diff → plain drawer
         }
         let touching: Vec<&Hunk> = hunks
@@ -432,100 +490,270 @@ pub fn reconstruct_block_diffs(
         if touching.is_empty() {
             continue; // change is elsewhere in the file → plain drawer
         }
-        out.insert(id.to_owned(), reconstruct_one(block, &touching));
+        let diff = reconstruct_one(&block.raw, block.block_start, block.block_end, &touching);
+        // A purely-whitespace edit (every touching hunk dropped by
+        // `reconstruct_one`) leaves an all-Context diff → no drawer diff
+        // (cute-dbt#111). The change-pair still kept the test `updated` via
+        // `refine_changed_by_hunks` (N7b is whitespace-EXACT); only the
+        // inline highlight is suppressed.
+        if diff.has_real_change() {
+            out.insert(id.to_owned(), diff);
+        }
     }
     out
 }
 
-/// Reconstruct one block's diff from its working-tree slice + the hunks
-/// already filtered to those touching it. See [`reconstruct_block_diffs`].
-fn reconstruct_one(block: &UnitTestYamlBlock, touching: &[&Hunk]) -> YamlBlockDiff {
-    fn trim_cr(s: &str) -> String {
-        s.trim_end_matches('\r').to_owned()
+/// Reconstruct an inline SQL diff of each in-scope model whose `.sql`
+/// changed in the PR diff (cute-dbt#111).
+///
+/// The sibling of [`reconstruct_block_diffs`] for a model's RAW Jinja
+/// `raw_code` (the diffable source — compiled SQL is generated and
+/// un-diffable). For each model in `models_in_scope` that carries
+/// `raw_code` + `original_file_path`:
+///
+/// 1. Normalize `raw_code` to git's line frame — strip **exactly one**
+///    trailing `\n` ([`str::strip_suffix`], not `trim_end_matches`). dbt
+///    engines diverge here (verified 2026-05-31): dbt-core ships
+///    `raw_code` already stripped, dbt-fusion ships it byte-identical but
+///    retaining the file's trailing `\n`. Stripping one terminator
+///    normalizes both to the same content frame, so `raw.split('\n')`
+///    lines up with the diff's new-side numbering and the reconstruction
+///    is engine-independent. A real blank line at EOF (`"a\n\n"`) survives
+///    — only the single terminator is removed.
+/// 2. Take the whole-file span `(raw, 1, raw.split('\n').count())` and the
+///    hunks touching the model's declaring file
+///    ([`NormalizedDiffIndex::hunks_for`]).
+/// 3. Emit a [`BlockDiff`] (keyed by the model's full node id) **only**
+///    when the diff still aligns ([`block_aligns_with_hunks`]), at least
+///    one hunk touches the file ([`hunk_touches_block`]), and the
+///    reconstruction carries a substantive change
+///    ([`BlockDiff::has_real_change`] — a whitespace-only edit emits
+///    nothing, cute-dbt#111). A model in scope only via a changed *test*
+///    (its own `.sql` untouched) resolves to no hunks → no entry → the
+///    template shows the plain SQL view.
+///
+/// Runs only on the [`crate::domain::scope::ScopeInput::PrDiff`] arm —
+/// baseline mode has no hunks to reconstruct from (the cli threads
+/// `HashMap::new()` there). ADR-3 scope selection is untouched: this only
+/// *reads* `models_in_scope` and adds a render-payload field.
+///
+/// The run loop passes the default-hasher render set, so generalizing over
+/// the hasher (`clippy::implicit_hasher`) buys nothing — same rationale as
+/// [`reconstruct_block_diffs`].
+#[must_use]
+pub fn reconstruct_model_sql_diffs(
+    current: &Manifest,
+    models_in_scope: &ModelInScopeSet,
+    index: &NormalizedDiffIndex,
+) -> HashMap<String, BlockDiff> {
+    let mut out = HashMap::new();
+    for model_id in models_in_scope.iter() {
+        if let Some(diff) = current
+            .node(model_id)
+            .and_then(|model| model_sql_diff(model, index))
+        {
+            out.insert(model_id.as_str().to_owned(), diff);
+        }
     }
-    let block_lines: Vec<String> = block.raw.split('\n').map(trim_cr).collect();
-    let (bs, be) = (block.block_start, block.block_end);
+    out
+}
 
-    // Removed-line groups to splice immediately before a given new-side
-    // line. Anchored before `new_start` for a replacement (new_len >= 1) and
-    // after it for a pure deletion (new_len == 0), then clamped into the
-    // block so leading/trailing edits render at the block's top/bottom.
-    // Per-line intra-line emphasis for the single added line of a clean 1:1
-    // replacement (one removed + one added line).
-    let mut splice_before: HashMap<usize, Vec<DiffLine>> = HashMap::new();
-    let mut added_emphasis: HashMap<usize, (usize, usize)> = HashMap::new();
-    for h in touching {
-        // A clean 1:1 line replacement carries exactly one removed AND one
-        // added body. The `added_lines.len() == 1` guard is load-bearing,
-        // not just `new_len == 1`: a malformed diff can declare `new_len: 1`
-        // with an empty `+` body, and the emphasis branch indexes
-        // `added_lines[0]` — without it, `reconstruct_one` would panic on
-        // that input (cute-dbt#110 review). cute-dbt never panics on a bad diff.
-        let clean_1to1 = h.new_len == 1 && h.removed_lines.len() == 1 && h.added_lines.len() == 1;
-        let anchor = if h.new_len == 0 {
-            h.new_start + 1
-        } else {
-            h.new_start
+/// The inline SQL diff for one model, or `None` when there is nothing to
+/// show (no `raw_code`, no declaring path, the `.sql` not in the diff, a
+/// stale diff, or a whitespace-only change). See [`reconstruct_model_sql_diffs`].
+fn model_sql_diff(model: &Node, index: &NormalizedDiffIndex) -> Option<BlockDiff> {
+    // Empty `raw_code` (some node types ship `raw_code: ""`) is treated as
+    // absent — matches `build_model_payload`'s `raw_sql` filter, so we never
+    // compute a diff the template would not show.
+    let raw_code = model.raw_code().filter(|s| !s.is_empty())?;
+    let ofp = model.original_file_path()?;
+    // Strip git's single trailing terminator (engine-divergent — see the
+    // module-level fn doc). A real blank line at EOF survives.
+    let raw = raw_code.strip_suffix('\n').unwrap_or(raw_code);
+    let (block_start, block_end) = (1, raw.split('\n').count());
+
+    let hunks = index.hunks_for(ofp);
+    if !block_aligns_with_hunks(raw, block_start, block_end, hunks) {
+        return None; // stale diff (N7b) → plain SQL view
+    }
+    let touching: Vec<&Hunk> = hunks
+        .iter()
+        .filter(|h| hunk_touches_block(block_start, block_end, h))
+        .collect();
+    if touching.is_empty() {
+        return None; // .sql not touched (model in scope via a changed test)
+    }
+    let diff = reconstruct_one(raw, block_start, block_end, &touching);
+    // Whitespace-only model edit → all-Context → no diff (plain SQL).
+    diff.has_real_change().then_some(diff)
+}
+
+/// Trim a trailing `\r` (CRLF tolerance — see [`block_aligns_with_hunks`]).
+fn trim_cr(s: &str) -> String {
+    s.trim_end_matches('\r').to_owned()
+}
+
+/// Within an aligned 1:1 replacement hunk (`removed.len() == added.len()`),
+/// the new-side line offset `i` (0-based) is whitespace-only when
+/// `removed[i]` is [`ws_equal`] to `added[i]` (cute-dbt#111).
+///
+/// Whitespace-insensitivity is **per line-pair**, not per-hunk: under
+/// `git --unified=0` a re-indent and a real edit on *adjacent* lines arrive
+/// as ONE hunk, so dropping the whole hunk would either leak the re-indent
+/// as a change or hide the real edit. Pairing line-for-line, a re-indent /
+/// trailing-whitespace / blank-churn pair renders as Context (no removed
+/// splice, no emphasis) while a substantive pair in the same hunk still
+/// diffs. Only meaningful for equal-count hunks; a genuine insertion /
+/// deletion (unequal counts) has no pairing and is always a real change.
+fn pair_is_ws_only(h: &Hunk, i: usize) -> bool {
+    h.removed_lines.len() == h.added_lines.len()
+        && ws_equal(
+            h.removed_lines[i].trim_end_matches('\r'),
+            h.added_lines[i].trim_end_matches('\r'),
+        )
+}
+
+/// The new-side edits a set of touching hunks impose on a block: which
+/// removed-line groups to splice before each 1-based new-side line, which
+/// new-side lines are genuine (non-whitespace) additions, and the
+/// intra-line emphasis span for a clean 1:1 replacement's added line.
+#[derive(Default)]
+struct HunkEdits {
+    splice_before: HashMap<usize, Vec<DiffLine>>,
+    added_real: std::collections::HashSet<usize>,
+    added_emphasis: HashMap<usize, (usize, usize)>,
+}
+
+/// Whether a hunk is a clean 1:1 line replacement (exactly one removed AND
+/// one added body). The `added_lines.len() == 1` guard is load-bearing,
+/// not just `new_len == 1`: a malformed diff can declare `new_len: 1` with
+/// an empty `+` body, and the emphasis branch indexes `added_lines[0]` —
+/// without this guard reconstruction would panic on that input
+/// (cute-dbt#110 review). cute-dbt never panics on a bad diff.
+fn is_clean_1to1(h: &Hunk) -> bool {
+    h.new_len == 1 && h.removed_lines.len() == 1 && h.added_lines.len() == 1
+}
+
+/// The removed [`DiffLine`]s a hunk contributes, with ws-only pairs
+/// dropped (cute-dbt#111) and a clean 1:1 replacement's single removed
+/// line carrying intra-line emphasis.
+fn removed_diff_lines(h: &Hunk) -> Vec<DiffLine> {
+    let clean = is_clean_1to1(h);
+    h.removed_lines
+        .iter()
+        .enumerate()
+        .filter(|(i, _)| !pair_is_ws_only(h, *i))
+        .map(|(i, r)| DiffLine {
+            kind: DiffLineKind::Removed,
+            text: trim_cr(r),
+            emphasis: if clean && i == 0 {
+                intra_line_span(&trim_cr(r), &trim_cr(&h.added_lines[0]))
+            } else {
+                None
+            },
+        })
+        .collect()
+}
+
+/// Fold one hunk's edits into `edits`. The removed bodies splice before the
+/// hunk's anchor (clamped into the block); each covered new-side line is a
+/// real addition unless it is the new side of a ws-only pair (cute-dbt#111,
+/// then it stays Context); a clean 1:1 replacement records the added line's
+/// intra-line emphasis.
+fn fold_hunk_edits(edits: &mut HunkEdits, h: &Hunk, bs: usize, be: usize) {
+    let anchor = if h.new_len == 0 {
+        h.new_start + 1
+    } else {
+        h.new_start
+    }
+    .clamp(bs, be + 1);
+    let removed = removed_diff_lines(h);
+    if !removed.is_empty() {
+        edits
+            .splice_before
+            .entry(anchor)
+            .or_default()
+            .extend(removed);
+    }
+    for k in 0..h.new_len {
+        if !pair_is_ws_only(h, k) {
+            edits.added_real.insert(h.new_start + k);
         }
-        .clamp(bs, be + 1);
-        let removed: Vec<DiffLine> = h
-            .removed_lines
-            .iter()
-            .enumerate()
-            .map(|(i, r)| DiffLine {
-                kind: DiffLineKind::Removed,
-                text: trim_cr(r),
-                emphasis: if clean_1to1 && i == 0 {
-                    intra_line_span(&trim_cr(r), &trim_cr(&h.added_lines[0]))
-                } else {
-                    None
-                },
-            })
-            .collect();
-        splice_before.entry(anchor).or_default().extend(removed);
-        if clean_1to1 && (bs..=be).contains(&h.new_start) {
-            if let Some(e) =
-                intra_line_span(&trim_cr(&h.added_lines[0]), &trim_cr(&h.removed_lines[0]))
-            {
-                added_emphasis.insert(h.new_start, e);
-            }
+    }
+    if is_clean_1to1(h) && !pair_is_ws_only(h, 0) && (bs..=be).contains(&h.new_start) {
+        if let Some(e) = intra_line_span(&trim_cr(&h.added_lines[0]), &trim_cr(&h.removed_lines[0]))
+        {
+            edits.added_emphasis.insert(h.new_start, e);
         }
     }
+}
 
-    // A new-side line is Added when some replacement/insertion hunk covers
-    // it; otherwise it is Context.
-    let is_added = |l: usize| {
-        touching
-            .iter()
-            .any(|h| h.new_len >= 1 && h.new_start <= l && l < h.new_start + h.new_len)
-    };
+/// Classify one new-side block line into its rendered [`DiffLine`].
+fn block_line_diff(edits: &HunkEdits, line_no: usize, text: String) -> DiffLine {
+    if edits.added_real.contains(&line_no) {
+        DiffLine {
+            kind: DiffLineKind::Added,
+            text,
+            emphasis: edits.added_emphasis.get(&line_no).copied(),
+        }
+    } else {
+        DiffLine {
+            kind: DiffLineKind::Context,
+            text,
+            emphasis: None,
+        }
+    }
+}
+
+/// Reconstruct one block's inline diff from its source slice + the hunks
+/// touching it (cute-dbt#96, generalized to any source block at
+/// cute-dbt#111).
+///
+/// The block is addressed by `(raw, block_start, block_end)` — the
+/// content-agnostic shape, so the same reconstruction serves the
+/// `unit_test` YAML block (#96, `(&block.raw, block.block_start,
+/// block.block_end)`) and a model's SQL `raw_code` (#111, the whole-file
+/// span). Callers pass `raw` already trailing-`\n`-normalized to git's
+/// line frame so `raw.split('\n')` lines up with the hunks' new-side
+/// numbering.
+///
+/// **Whitespace-only line-pairs render as Context** ([`pair_is_ws_only`]):
+/// a re-indentation / trailing-whitespace / blank-churn edit is not a
+/// change (cute-dbt#111, `git --ignore-all-space` semantics) — no removed
+/// splice, no emphasis. When every change in the block is whitespace-only
+/// the result is all-Context; the caller tests [`BlockDiff::has_real_change`]
+/// and emits no [`BlockDiff`] so the view falls back to plain text.
+fn reconstruct_one(
+    raw: &str,
+    block_start: usize,
+    block_end: usize,
+    touching: &[&Hunk],
+) -> BlockDiff {
+    let block_lines: Vec<String> = raw.split('\n').map(trim_cr).collect();
+    let (bs, be) = (block_start, block_end);
+
+    // Removed-line groups to splice immediately before a given new-side
+    // line; `added_real` marks genuine (non-whitespace) additions;
+    // `added_emphasis` carries the clean-1:1 intra-line span (cute-dbt#111).
+    let mut edits = HunkEdits::default();
+    for h in touching {
+        fold_hunk_edits(&mut edits, h, bs, be);
+    }
 
     let mut lines: Vec<DiffLine> = Vec::new();
     for (i, text) in block_lines.into_iter().enumerate() {
         let l = bs + i; // 1-based new-side line number
-        if let Some(group) = splice_before.remove(&l) {
+        if let Some(group) = edits.splice_before.remove(&l) {
             lines.extend(group);
         }
-        lines.push(if is_added(l) {
-            DiffLine {
-                kind: DiffLineKind::Added,
-                text,
-                emphasis: added_emphasis.get(&l).copied(),
-            }
-        } else {
-            DiffLine {
-                kind: DiffLineKind::Context,
-                text,
-                emphasis: None,
-            }
-        });
+        lines.push(block_line_diff(&edits, l, text));
     }
     // Trailing deletions clamped to just past the block's last line.
-    if let Some(group) = splice_before.remove(&(be + 1)) {
+    if let Some(group) = edits.splice_before.remove(&(be + 1)) {
         lines.extend(group);
     }
 
-    YamlBlockDiff { lines }
+    BlockDiff { lines }
 }
 
 #[cfg(test)]
@@ -776,7 +1004,9 @@ mod tests {
         let block = block_at(ALIGN_RAW, 2); // [2, 4]
         // Replace line 3 with the line that is actually there → aligned.
         assert!(block_aligns_with_hunks(
-            &block,
+            &block.raw,
+            block.block_start,
+            block.block_end,
             &[repl(3, &["    model: m"])]
         ));
     }
@@ -789,7 +1019,9 @@ mod tests {
         // 1`, not `new_start - 1` — pins the per-line index arithmetic
         // (`file_line = new_start + k`) so a `+`→`-` slip on `k` is caught.
         assert!(block_aligns_with_hunks(
-            &block,
+            &block.raw,
+            block.block_start,
+            block.block_end,
             &[repl(3, &["    model: m", "    given: []"])]
         ));
     }
@@ -799,7 +1031,9 @@ mod tests {
         let block = block_at(ALIGN_RAW, 2); // [2, 4]
         // Claims "    model: m" at line 2, but line 2 is "  - name: t".
         assert!(!block_aligns_with_hunks(
-            &block,
+            &block.raw,
+            block.block_start,
+            block.block_end,
             &[repl(2, &["    model: m"])]
         ));
     }
@@ -808,7 +1042,9 @@ mod tests {
     fn block_misaligns_when_added_line_content_is_corrupted() {
         let block = block_at(ALIGN_RAW, 2); // [2, 4]
         assert!(!block_aligns_with_hunks(
-            &block,
+            &block.raw,
+            block.block_start,
+            block.block_end,
             &[repl(3, &["    model: CORRUPTED"])]
         ));
     }
@@ -817,14 +1053,24 @@ mod tests {
     fn block_aligns_ignores_added_lines_outside_the_block() {
         let block = block_at("  - name: t\n    model: m", 8); // [8, 9]
         // A hunk in the file header — entirely above the block → ignored.
-        assert!(block_aligns_with_hunks(&block, &[repl(1, &["version: 3"])]));
+        assert!(block_aligns_with_hunks(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &[repl(1, &["version: 3"])]
+        ));
     }
 
     #[test]
     fn block_aligns_vacuously_for_pure_deletion_hunks() {
         let block = block_at("  - name: t\n    model: m", 2);
         // A deletion carries no `+` lines → nothing to verify → aligned.
-        assert!(block_aligns_with_hunks(&block, &[del(2)]));
+        assert!(block_aligns_with_hunks(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &[del(2)]
+        ));
     }
 
     #[test]
@@ -833,7 +1079,9 @@ mod tests {
         // (str::lines). A CRLF working tree must not read as stale.
         let block = block_at("  - name: t\r\n    model: m\r", 2); // ["  - name: t\r", "    model: m\r"]
         assert!(block_aligns_with_hunks(
-            &block,
+            &block.raw,
+            block.block_start,
+            block.block_end,
             &[repl(3, &["    model: m"])]
         ));
     }
@@ -1139,7 +1387,12 @@ mod tests {
             raw: "  - name: test_orders\n    model: orders\n    given: []".to_owned(),
             ..block
         };
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1168,7 +1421,12 @@ mod tests {
             &["    model: payments"],
             &["    model: orders"],
         )];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1186,7 +1444,12 @@ mod tests {
         let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
         // Deletion gap after new-side line 11 → removed renders between 11 and 12.
         let hunks = [delete(11, &["      # note"])];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1203,7 +1466,12 @@ mod tests {
         // new_start = block_start - 1 → anchor clamps to the top.
         let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
         let hunks = [delete(9, &["  # leading"])];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1220,7 +1488,12 @@ mod tests {
         // new_start = block_end → anchor clamps just past the last line.
         let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
         let hunks = [delete(12, &["  # trailing"])];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1238,7 +1511,12 @@ mod tests {
         // the removed pair clamps to the block top.
         let block = block_at("    model: m2\n    given: []\n      rows: []", 10); // [10,12]
         let hunks = [replace(9, &["old8", "old9"], &["new9", "    model: m2"])];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1259,7 +1537,12 @@ mod tests {
             replace(11, &["oldA"], &["newA"]),
             replace(13, &["oldB"], &["newB"]),
         ];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1279,7 +1562,12 @@ mod tests {
         // new_len = 2 (not a clean 1:1) → line-level +/- only, no <strong>.
         let block = block_at("  - name: t\nnewA\nnewB\n    given: []", 10); // [10,13]
         let hunks = [replace(11, &["oldA", "oldB"], &["newA", "newB"])];
-        let got = reconstruct_one(&block, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &block.raw,
+            block.block_start,
+            block.block_end,
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1306,7 +1594,7 @@ mod tests {
             removed_lines: vec!["    model: was".to_owned()],
             added_lines: Vec::new(),
         };
-        let got = reconstruct_one(&block, &[&hunk]);
+        let got = reconstruct_one(&block.raw, block.block_start, block.block_end, &[&hunk]);
         assert_eq!(
             got.lines,
             vec![
@@ -1423,11 +1711,11 @@ mod tests {
         );
     }
 
-    // ----- YamlBlockDiff serde: the exact JS wire shape -----
+    // ----- BlockDiff serde: the exact JS wire shape -----
 
     #[test]
     fn yaml_block_diff_serializes_to_the_exact_renderyamldiff_contract() {
-        let diff = YamlBlockDiff {
+        let diff = BlockDiff {
             lines: vec![
                 ctx("  - name: t"),
                 rem_e("    model: payments", (11, 18)),
@@ -1440,7 +1728,400 @@ mod tests {
             r#"{"lines":[{"kind":"context","text":"  - name: t","emphasis":null},{"kind":"removed","text":"    model: payments","emphasis":[11,18]},{"kind":"added","text":"    model: orders","emphasis":[11,16]}]}"#,
         );
         // wire-shape round-trips back to the same POD.
-        let back: YamlBlockDiff = serde_json::from_str(&json).unwrap();
+        let back: BlockDiff = serde_json::from_str(&json).unwrap();
         assert_eq!(back, diff);
     }
+
+    // =================================================================
+    // Whitespace-insensitivity (cute-dbt#111): ws_equal +
+    // hunk_is_whitespace_only + BlockDiff::has_real_change
+    // =================================================================
+
+    #[test]
+    fn ws_equal_ignores_leading_trailing_and_interior_whitespace() {
+        // Re-indentation, trailing whitespace, collapsed interior runs:
+        // identical non-whitespace content ⇒ equal.
+        assert!(ws_equal("    select id", "        select id"));
+        assert!(ws_equal("select id ", "select id"));
+        assert!(ws_equal("select  id", "select id"));
+        assert!(ws_equal("", "   "));
+        assert!(ws_equal("\tselect\tid\t", "select id"));
+    }
+
+    #[test]
+    fn ws_equal_distinguishes_substantive_content() {
+        assert!(!ws_equal("select id", "select uid"));
+        assert!(!ws_equal("select id", "select id, name"));
+        // Re-ordered tokens are a real change (token SEQUENCE, not set).
+        assert!(!ws_equal("a b", "b a"));
+    }
+
+    #[test]
+    fn pair_is_ws_only_true_per_aligned_pair() {
+        // 1:1 re-indentation: each `+` is ws_equal to its paired `-`.
+        let h = replace(
+            5,
+            &["select id", "  from t"],
+            &["    select id", "        from t"],
+        );
+        assert!(pair_is_ws_only(&h, 0));
+        assert!(pair_is_ws_only(&h, 1));
+    }
+
+    #[test]
+    fn pair_is_ws_only_false_for_a_substantive_pair() {
+        let h = replace(
+            5,
+            &["select id", "from t"],
+            &["    select id", "from u"], // pair 1: t → u (real)
+        );
+        assert!(pair_is_ws_only(&h, 0)); // re-indent
+        assert!(!pair_is_ws_only(&h, 1)); // value change
+    }
+
+    #[test]
+    fn pair_is_ws_only_false_for_unequal_side_counts() {
+        // A genuine insertion / deletion (unequal counts) has no pairing —
+        // adding/removing a line is a real change even when blank. The
+        // count guard short-circuits BEFORE indexing, so no panic.
+        assert!(!pair_is_ws_only(&replace(5, &[], &["   "]), 0));
+        assert!(!pair_is_ws_only(&delete(5, &["   "]), 0));
+        assert!(!pair_is_ws_only(&replace(5, &["a"], &["   a   ", "b"]), 0));
+    }
+
+    #[test]
+    fn reconstruct_one_mixed_adjacent_hunk_keeps_real_drops_ws_pair() {
+        // The single-hunk adjacent case `git --unified=0` produces (advisor
+        // 2026-05-31): line 1 is a pure re-indent (ws-only pair → Context),
+        // line 2 a real value change (kept) — ALL IN ONE HUNK. A whole-hunk
+        // filter would wrongly keep or drop both; per-pair handles it.
+        let raw = "  select a\nfrom u"; // [1,2]
+        let hunks = [replace(
+            1,
+            &["select a", "from t"],
+            &["  select a", "from u"],
+        )];
+        let got = reconstruct_one(raw, 1, 2, &hunks.iter().collect::<Vec<_>>());
+        // The whitespace goal is met: line 1 ("  select a") renders as
+        // CONTEXT (not Added) and only the substantive "from t"→"from u"
+        // pair diffs. The removed line splices at the hunk anchor (its
+        // `new_start`, here clamped to the block top) — the pre-existing
+        // #96 multi-line-replacement placement, not paired to its own
+        // offset. Cosmetic ordering only; the change-set is correct.
+        assert_eq!(
+            got.lines,
+            vec![
+                rem("from t"),     // removed splices at the hunk anchor (line 1)
+                ctx("  select a"), // re-indented line: Context, NOT a change
+                add("from u"),     // the real new-side change
+            ],
+            "the re-indent stays Context; only the substantive pair diffs",
+        );
+        // Critically: the re-indented line is NOT marked Added/Removed.
+        assert!(
+            got.lines
+                .iter()
+                .all(|l| !(l.text == "  select a" && l.kind != DiffLineKind::Context)),
+            "the whitespace-only line must never render as a change",
+        );
+        assert!(got.has_real_change());
+    }
+
+    #[test]
+    fn block_diff_has_real_change_only_with_added_or_removed() {
+        let all_ctx = BlockDiff {
+            lines: vec![ctx("a"), ctx("b")],
+        };
+        assert!(!all_ctx.has_real_change());
+        assert!(
+            BlockDiff {
+                lines: vec![ctx("a"), add("b")]
+            }
+            .has_real_change()
+        );
+        assert!(
+            BlockDiff {
+                lines: vec![rem("a"), ctx("b")]
+            }
+            .has_real_change()
+        );
+    }
+
+    #[test]
+    fn reconstruct_one_renders_whitespace_only_change_as_context() {
+        // A re-indentation of line 2 (working tree == `    model: m`, old
+        // side `model: m`): ws_equal ⇒ no Removed splice, no emphasis, the
+        // new-side line is Context. Frame: 3 context lines, no real change.
+        let raw = "  - name: t\n    model: m\n    given: []"; // [10,12]
+        let hunks = [replace(11, &["model: m"], &["    model: m"])];
+        let got = reconstruct_one(raw, 10, 12, &hunks.iter().collect::<Vec<_>>());
+        assert_eq!(
+            got.lines,
+            vec![
+                ctx("  - name: t"),
+                ctx("    model: m"),
+                ctx("    given: []")
+            ],
+        );
+        assert!(
+            !got.has_real_change(),
+            "ws-only change carries no real diff"
+        );
+    }
+
+    #[test]
+    fn reconstruct_one_keeps_real_change_adjacent_to_a_whitespace_only_change() {
+        // git --unified=0 splits these into two hunks: line 11 is a pure
+        // re-indent (dropped), line 12 is a real value change (kept).
+        let raw = "  - name: t\n    model: m\n    given: [1]"; // [10,12]
+        let hunks = [
+            replace(11, &["model: m"], &["    model: m"]), // ws-only → dropped
+            replace(12, &["    given: []"], &["    given: [1]"]), // real → kept
+        ];
+        let got = reconstruct_one(raw, 10, 12, &hunks.iter().collect::<Vec<_>>());
+        // Common prefix "    given: [" (12); removed "]" has no own changed
+        // span (it is the shorter side's shared suffix → None); added "1]"
+        // contributes "1" at codepoint 12.
+        assert_eq!(
+            got.lines,
+            vec![
+                ctx("  - name: t"),
+                ctx("    model: m"), // the re-indented line, as plain Context
+                rem("    given: []"),
+                add_e("    given: [1]", (12, 13)), // "1"
+            ],
+        );
+        assert!(got.has_real_change());
+    }
+
+    // =================================================================
+    // Model SQL reconstruction (cute-dbt#111):
+    // reconstruct_model_sql_diffs + the trailing-newline frame
+    // =================================================================
+
+    use crate::domain::manifest::{Checksum, NodeConfig};
+
+    /// A `model` node carrying `raw_code` + `original_file_path` — the two
+    /// fields `reconstruct_model_sql_diffs` reads. `compiled` is irrelevant
+    /// to SQL-diff reconstruction (the diff is over RAW Jinja).
+    fn model_with_raw(full_id: &str, raw_code: &str, ofp: &str) -> Node {
+        Node::new(
+            NodeId::new(full_id),
+            "model",
+            Checksum::new("sha256", "ck"),
+            Some("select 1".to_owned()),
+            Some(raw_code.to_owned()),
+            DependsOn::default(),
+            Some(ofp.to_owned()),
+            NodeConfig::default(),
+            None,
+            std::collections::BTreeMap::new(),
+        )
+    }
+
+    fn manifest_with_models(models: Vec<Node>) -> Manifest {
+        Manifest::new(
+            ManifestMetadata::new("v12"),
+            models.into_iter().map(|m| (m.id().clone(), m)).collect(),
+            HashMap::new(),
+            HashMap::new(),
+        )
+    }
+
+    /// The whole-file span of a `raw_code`, as `reconstruct_model_sql_diffs`
+    /// computes it — trailing-`\n` stripped (git's line frame), then
+    /// `(raw, 1, line_count)`. Pins the off-by-one trap.
+    #[test]
+    fn model_sql_frame_strips_exactly_one_trailing_newline() {
+        // dbt-CORE shape: raw_code already trailing-newline-stripped.
+        let core = "select 1\nfrom t"; // 2 content lines, no trailing \n
+        // dbt-FUSION shape: byte-identical PLUS the trailing \n (verified
+        // 2026-05-31 against a fusion-compiled playground manifest).
+        let fusion = "select 1\nfrom t\n";
+
+        let core_norm = core.strip_suffix('\n').unwrap_or(core);
+        let fusion_norm = fusion.strip_suffix('\n').unwrap_or(fusion);
+        assert_eq!(
+            core_norm, fusion_norm,
+            "both engines normalize to the same frame"
+        );
+        assert_eq!(
+            core_norm.split('\n').count(),
+            2,
+            "git line frame = 2 content lines"
+        );
+
+        // A real blank line at EOF (`"a\n\n"`, git frame = 2) must be KEPT —
+        // strip_suffix removes only the single terminator, not the blank.
+        let blank_eof = "a\n\n";
+        assert_eq!(
+            blank_eof.strip_suffix('\n').unwrap_or(blank_eof),
+            "a\n",
+            "strip exactly one \\n; the real blank line survives",
+        );
+    }
+
+    #[test]
+    fn reconstruct_model_sql_diffs_identical_frame_across_engine_trailing_newline() {
+        // The cross-engine guard: a core-shaped and a fusion-shaped
+        // raw_code of the SAME model produce an IDENTICAL DiffLine frame
+        // (AGENTS.md: reports look identical regardless of compiling
+        // engine). Edit line 2 ("from t" → "from u"); whole-file hunk.
+        let ofp = "models/m.sql";
+        let core_raw = "select id\nfrom u"; // working tree (no trailing \n)
+        let fusion_raw = "select id\nfrom u\n"; // same + trailing \n
+
+        // The diff's `+` lines must match the (stripped) working tree at
+        // their new-side positions for N7b to hold.
+        let diff = PrDiff {
+            files: vec![FileHunks {
+                path: ofp.to_owned(),
+                hunks: vec![replace(2, &["from t"], &["from u"])],
+            }],
+        };
+        let index = NormalizedDiffIndex::new(&diff, None);
+
+        let core_mf = manifest_with_models(vec![model_with_raw("model.s.m", core_raw, ofp)]);
+        let fusion_mf = manifest_with_models(vec![model_with_raw("model.s.m", fusion_raw, ofp)]);
+        let scope = ModelInScopeSet::from_iter([NodeId::new("model.s.m")]);
+
+        let core_diffs = reconstruct_model_sql_diffs(&core_mf, &scope, &index);
+        let fusion_diffs = reconstruct_model_sql_diffs(&fusion_mf, &scope, &index);
+
+        let expected = vec![
+            ctx("select id"),
+            rem_e("from t", (5, 6)), // "t"
+            add_e("from u", (5, 6)), // "u"
+        ];
+        assert_eq!(core_diffs["model.s.m"].lines, expected, "core frame");
+        assert_eq!(
+            fusion_diffs["model.s.m"].lines, expected,
+            "fusion frame must be byte-identical to core (no phantom trailing line)",
+        );
+    }
+
+    #[test]
+    fn reconstruct_model_sql_diffs_emits_only_for_touched_aligned_models() {
+        let ofp_edit = "models/edit.sql";
+        let ofp_untouched = "models/untouched.sql";
+        let ofp_stale = "models/stale.sql";
+        let ofp_nodiff = "models/nodiff.sql"; // in scope but its file not in the diff
+
+        let edit = model_with_raw("model.s.edit", "select a\nfrom edited", ofp_edit);
+        let untouched = model_with_raw("model.s.untouched", "select a\nfrom u", ofp_untouched);
+        let stale = model_with_raw("model.s.stale", "select a\nfrom s", ofp_stale);
+        let nodiff = model_with_raw("model.s.nodiff", "select a\nfrom n", ofp_nodiff);
+        let current = manifest_with_models(vec![edit, untouched, stale, nodiff]);
+
+        let diff = PrDiff {
+            files: vec![
+                // edit.sql: line 2 replaced, `+` matches working tree → aligned + touched.
+                FileHunks {
+                    path: ofp_edit.to_owned(),
+                    hunks: vec![replace(2, &["from was"], &["from edited"])],
+                },
+                // untouched.sql: change at line 1 only? No — make it a hunk that
+                // does not overlap the file at all by pointing past EOF.
+                FileHunks {
+                    path: ofp_untouched.to_owned(),
+                    hunks: vec![repl(9, &["zzz"])], // line 9 > 2-line file → no touch
+                },
+                // stale.sql: `+` body does not match the working tree → N7b fail.
+                FileHunks {
+                    path: ofp_stale.to_owned(),
+                    hunks: vec![replace(2, &["from was"], &["from DRIFTED"])],
+                },
+                // nodiff.sql intentionally NOT in the diff.
+            ],
+        };
+        let index = NormalizedDiffIndex::new(&diff, None);
+        let scope = ModelInScopeSet::from_iter([
+            NodeId::new("model.s.edit"),
+            NodeId::new("model.s.untouched"),
+            NodeId::new("model.s.stale"),
+            NodeId::new("model.s.nodiff"),
+        ]);
+
+        let diffs = reconstruct_model_sql_diffs(&current, &scope, &index);
+
+        assert!(
+            diffs.contains_key("model.s.edit"),
+            "edited model → SQL diff"
+        );
+        assert!(
+            !diffs.contains_key("model.s.untouched"),
+            "hunk outside the file frame → no diff (plain SQL)",
+        );
+        assert!(
+            !diffs.contains_key("model.s.stale"),
+            "stale (N7b-misaligned) diff → no diff",
+        );
+        assert!(
+            !diffs.contains_key("model.s.nodiff"),
+            "model whose .sql is not in the diff → no diff (in scope via a changed test)",
+        );
+
+        assert_eq!(
+            diffs["model.s.edit"].lines,
+            vec![
+                ctx("select a"),
+                rem_e("from was", (5, 8)),     // "was"
+                add_e("from edited", (5, 11)), // "edited"
+            ],
+        );
+    }
+
+    #[test]
+    fn reconstruct_model_sql_diffs_skips_a_whitespace_only_model_change() {
+        // A re-indented model SQL: the whole-file hunk's `+` lines match the
+        // working tree (N7b passes) and touch the block, but every pair is
+        // ws_equal → has_real_change() is false → no BlockDiff (plain SQL).
+        let ofp = "models/reindent.sql";
+        let raw = "select id\n    from t"; // working tree: line 2 indented
+        let m = model_with_raw("model.s.reindent", raw, ofp);
+        let current = manifest_with_models(vec![m]);
+
+        let diff = PrDiff {
+            files: vec![FileHunks {
+                path: ofp.to_owned(),
+                hunks: vec![replace(2, &["from t"], &["    from t"])],
+            }],
+        };
+        let index = NormalizedDiffIndex::new(&diff, None);
+        let scope = ModelInScopeSet::from_iter([NodeId::new("model.s.reindent")]);
+
+        let diffs = reconstruct_model_sql_diffs(&current, &scope, &index);
+        assert!(
+            !diffs.contains_key("model.s.reindent"),
+            "whitespace-only model SQL change → no diff (plain view)",
+        );
+    }
+
+    #[test]
+    fn reconstruct_model_sql_diffs_skips_a_model_without_raw_code() {
+        // Defensive: a model lacking raw_code (None) can carry no SQL diff.
+        let ofp = "models/noraw.sql";
+        let m = Node::new(
+            NodeId::new("model.s.noraw"),
+            "model",
+            Checksum::new("sha256", "ck"),
+            Some("select 1".to_owned()),
+            None, // no raw_code
+            DependsOn::default(),
+            Some(ofp.to_owned()),
+            NodeConfig::default(),
+            None,
+            std::collections::BTreeMap::new(),
+        );
+        let current = manifest_with_models(vec![m]);
+        let diff = PrDiff {
+            files: vec![FileHunks {
+                path: ofp.to_owned(),
+                hunks: vec![replace(1, &["old"], &["new"])],
+            }],
+        };
+        let index = NormalizedDiffIndex::new(&diff, None);
+        let scope = ModelInScopeSet::from_iter([NodeId::new("model.s.noraw")]);
+        assert!(reconstruct_model_sql_diffs(&current, &scope, &index).is_empty());
+    }
 }
diff --git a/templates/report.html b/templates/report.html
index 33784fd5..31e9f0c9 100644
--- a/templates/report.html
+++ b/templates/report.html
@@ -742,11 +742,17 @@ <h2>Expected</h2>
     }
   }
 
-  // cute-dbt#47 — populate (or hide) the per-model Model SQL section.
-  // The askama template emits one static <section class="model-sql">; JS
-  // rebinds its <code> body and Copy handler each time the user selects a
+  // cute-dbt#47 / cute-dbt#111 — populate (or hide) the per-model Model SQL
+  // section. The askama template emits one static <section class="model-sql">;
+  // JS rebinds its body and Copy handler each time the user selects a
   // different model. When `raw_sql` is missing, hide the whole section
   // (defensive — dbt 1.8+ populates raw_code on every node).
+  //
+  // cute-dbt#111: when the selected model carries an inline SQL diff
+  // (m.sql_diff — PR-diff mode, the model's .sql changed), the section shows
+  // a Raw↔Diff toggle defaulting to Diff (rendered via renderBlockDiff with
+  // the SQL highlighter on context lines only). Absent a diff it renders the
+  // plain raw SQL exactly as cute-dbt#47 did. Copy always copies the raw SQL.
   function renderModelSql(m) {
     var $section = $(".model-sql");
     var raw = m && m.raw_sql;
@@ -755,13 +761,47 @@ <h2>Expected</h2>
       return;
     }
     $section.show();
-    $section.find(".model-sql-code").html(highlightSql(raw));
-    var $copy = $section.find(".model-sql-copy");
-    $copy.off("click.cuteDbtModelSql").on("click.cuteDbtModelSql", function (e) {
+    var hasDiff = m.sql_diff && m.sql_diff.lines && m.sql_diff.lines.length;
+    $section.find(".model-sql-summary-hint").text(hasDiff ? "diff" : "raw, with Jinja");
+    var $wrap = $section.find(".model-sql-wrap");
+    // Rebuild the wrap body each model switch so a prior model's toggle/diff
+    // never leaks; the Copy button is re-created here too.
+    $wrap.empty();
+    var $copy = $("<button>").attr("type", "button")
+      .addClass("sql-copy model-sql-copy").text("Copy");
+    $copy.on("click.cuteDbtModelSql", function (e) {
       e.preventDefault();
       e.stopPropagation();
       copySql(raw, $(this));
     });
+    $wrap.append($copy);
+    if (hasDiff) {
+      var $diffPre = $("<pre>").addClass("sql-block model-sql-block sql-diff-view").append(
+        $("<code>").addClass("model-sql-code").html(renderBlockDiff(m.sql_diff, highlightSql))
+      );
+      var $rawPre = $("<pre>").addClass("sql-block model-sql-block sql-raw-view").prop("hidden", true).append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      var $toggle = $("<div>").addClass("yaml-diff-toggle model-sql-toggle");
+      var $diffBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn active").attr("data-view", "diff").text("Diff");
+      var $rawBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn").attr("data-view", "raw").text("Raw");
+      $toggle.append($diffBtn).append($rawBtn);
+      $toggle.on("click", ".yaml-view-btn", function () {
+        var view = $(this).attr("data-view");
+        $toggle.find(".yaml-view-btn").removeClass("active");
+        $(this).addClass("active");
+        $diffPre.prop("hidden", view !== "diff");
+        $rawPre.prop("hidden", view !== "raw");
+      });
+      $wrap.append($toggle).append($diffPre).append($rawPre);
+    } else {
+      var $pre = $("<pre>").addClass("sql-block model-sql-block").append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      $wrap.append($pre);
+    }
   }
 
   function renderDagLegend() {
@@ -1337,17 +1377,20 @@ <h2>Expected</h2>
   // `__cuteParseCsv` seam introduced in cute-dbt#66).
   window.__cuteHighlightYaml = highlightYaml;
 
-  // cute-dbt#96 concern 2 — render a reconstructed inline YAML block diff
-  // (domain::pr_diff::YamlBlockDiff) as HTML for a <pre><code>. Each line is
-  // a block-level `.diff-line` span (so a full-width add/remove row tint fills
+  // cute-dbt#96 concern 2 / cute-dbt#111 — render a reconstructed inline
+  // block diff (domain::pr_diff::BlockDiff) as HTML for a <pre><code>.
+  // Content-agnostic: `highlightFn` highlights CONTEXT lines only (YAML
+  // for the test drawer, SQL for the Model SQL section). Each line is a
+  // block-level `.diff-line` span (so a full-width add/remove row tint fills
   // the line) — block layout provides the breaks, so the spans are joined with
   // "" (a literal "\n" would render as a blank row between blocks in a <pre>);
   // each is prefixed by a +/-/space sigil.
-  // Context lines reuse the YAML highlighter; changed lines render escaped
-  // text with the intra-line `emphasis` range wrapped in <strong>. The
-  // emphasis offsets are CODEPOINT indices (Rust `chars()`), so the slice
-  // goes through `Array.from` — UTF-16 `.slice` would drift on astral chars.
-  function renderYamlDiff(diff) {
+  // Changed lines BYPASS `highlightFn` (the cute-dbt#96 lesson): they render
+  // escaped text with the intra-line `emphasis` range wrapped in <strong>, so
+  // the emphasis offsets land on the RAW text. The offsets are CODEPOINT
+  // indices (Rust `chars()`), so the slice goes through `Array.from` — UTF-16
+  // `.slice` would drift on astral chars.
+  function renderBlockDiff(diff, highlightFn) {
     return diff.lines.map(function (ln) {
       var cls = ln.kind === "added" ? "diff-added"
               : ln.kind === "removed" ? "diff-removed"
@@ -1355,7 +1398,7 @@ <h2>Expected</h2>
       var sigil = ln.kind === "added" ? "+" : ln.kind === "removed" ? "-" : " ";
       var body;
       if (ln.kind === "context") {
-        body = highlightYaml(ln.text);
+        body = highlightFn(ln.text);
       } else if (ln.emphasis) {
         var cps = Array.from(ln.text);
         var a = ln.emphasis[0], b = ln.emphasis[1];
@@ -1370,7 +1413,11 @@ <h2>Expected</h2>
            + '</span>';
     }).join("");
   }
-  // Expose for headless JS unit tests (parallels __cuteHighlightYaml).
+  // Expose for headless JS unit tests (parallels __cuteHighlightYaml). The
+  // #96 name is kept as a thin alias so existing headless assertions and the
+  // YAML call site stay byte-stable; new SQL callers pass `highlightSql`.
+  function renderYamlDiff(diff) { return renderBlockDiff(diff, highlightYaml); }
+  window.__cuteRenderBlockDiff = renderBlockDiff;
   window.__cuteRenderYamlDiff = renderYamlDiff;
 
   function copySql(text, $btn) {
diff --git a/tests/golden_report.rs b/tests/golden_report.rs
index 87c5159a..9ccfe25b 100644
--- a/tests/golden_report.rs
+++ b/tests/golden_report.rs
@@ -101,6 +101,7 @@ fn rendered_report_skeleton() {
         &changed,
         &HashMap::new(),
         &HashMap::new(),
+        &HashMap::new(),
         "jaffle-shop-baseline.json",
         ScopeSource::Baseline,
         DEFAULT_REPORT_TITLE,
diff --git a/tests/headless_toggle.rs b/tests/headless_toggle.rs
index 79e41fe7..f545e73e 100644
--- a/tests/headless_toggle.rs
+++ b/tests/headless_toggle.rs
@@ -44,9 +44,9 @@ use headless_chrome::{Browser, LaunchOptionsBuilder, Tab};
 
 use cute_dbt::adapters::render::{ScopeSource, render_report};
 use cute_dbt::domain::{
-    Checksum, DEFAULT_REPORT_TITLE, DependsOn, DiffLine, DiffLineKind, InScopeSet, Manifest,
-    ManifestMetadata, ModelInScopeSet, Node, NodeConfig, NodeId, UnitTest, UnitTestExpect,
-    UnitTestYamlBlock, YamlBlockDiff,
+    BlockDiff, Checksum, DEFAULT_REPORT_TITLE, DependsOn, DiffLine, DiffLineKind, InScopeSet,
+    Manifest, ManifestMetadata, ModelInScopeSet, Node, NodeConfig, NodeId, UnitTest,
+    UnitTestExpect, UnitTestYamlBlock,
 };
 
 // --- synthetic manifest builders ------------------------------------
@@ -66,6 +66,23 @@ fn model_node(full_id: &str) -> Node {
     )
 }
 
+/// A `model` node carrying `raw_code` (so the Model SQL section renders)
+/// — cute-dbt#111.
+fn model_node_with_raw(full_id: &str, raw_code: &str) -> Node {
+    Node::new(
+        NodeId::new(full_id),
+        "model",
+        Checksum::new("sha256", "ck"),
+        Some("select 1".to_owned()),
+        Some(raw_code.to_owned()),
+        DependsOn::default(),
+        None,
+        NodeConfig::default(),
+        None,
+        BTreeMap::new(),
+    )
+}
+
 fn unit_test(name: &str, model_bare: &str) -> UnitTest {
     UnitTest::new(
         name.to_owned(),
@@ -119,6 +136,7 @@ fn render_with_scope(
         &changed,
         &HashMap::new(),
         &HashMap::new(),
+        &HashMap::new(),
         baseline_label,
         scope,
         DEFAULT_REPORT_TITLE,
@@ -513,7 +531,7 @@ fn pr_diff_zero_updated_affirms_block_precision() {
 
 /// PR-diff render that injects an authoring-YAML map and an inline-diff map
 /// so the Authored↔Diff drawer renders. `authoring` is `(test_id, raw)`;
-/// `diffs` is `(test_id, YamlBlockDiff)`. The block span is irrelevant to
+/// `diffs` is `(test_id, BlockDiff)`. The block span is irrelevant to
 /// the JS drawer (only `raw` + the diff lines are surfaced), so it is pinned
 /// to `[1, line_count]`.
 fn render_pr_diff_with_diffs(
@@ -523,7 +541,7 @@ fn render_pr_diff_with_diffs(
     model_ids: &[&str],
     changed_ids: &[&str],
     authoring: Vec<(&str, &str)>,
-    diffs: Vec<(&str, YamlBlockDiff)>,
+    diffs: Vec<(&str, BlockDiff)>,
 ) -> String {
     let all_ids: Vec<String> = tests.iter().map(|(id, _)| (*id).to_owned()).collect();
     let m = manifest(nodes, tests);
@@ -540,7 +558,7 @@ fn render_pr_diff_with_diffs(
             )
         })
         .collect();
-    let yaml_diffs: HashMap<String, YamlBlockDiff> = diffs
+    let yaml_diffs: HashMap<String, BlockDiff> = diffs
         .into_iter()
         .map(|(id, d)| (id.to_owned(), d))
         .collect();
@@ -554,6 +572,7 @@ fn render_pr_diff_with_diffs(
         &changed,
         &authoring_yaml,
         &yaml_diffs,
+        &HashMap::new(),
         "",
         ScopeSource::PrDiff,
         DEFAULT_REPORT_TITLE,
@@ -578,7 +597,7 @@ fn yaml_diff_drawer_defaults_to_diff_and_toggles_to_authored() {
     // dim_a's `upd` test was edited (model: payments → orders); the run loop
     // attaches an inline diff. PR-diff mode auto-selects the updated test, so
     // its drawer is built on load.
-    let diff = YamlBlockDiff {
+    let diff = BlockDiff {
         lines: vec![
             dl(DiffLineKind::Context, "  - name: upd", None),
             dl(DiffLineKind::Removed, "    model: payments", Some((11, 18))),
@@ -710,3 +729,199 @@ fn render_yaml_diff_js_emits_classes_sigils_and_codepoint_emphasis() {
 
     let _ = tab.close(true);
 }
+
+// --- cute-dbt#111: inline model SQL diff (Raw↔Diff toggle) ----------
+
+/// PR-diff render that injects a model-SQL-diff map so the Model SQL
+/// section's Raw↔Diff toggle renders. `sql_diffs` is `(model_id,
+/// BlockDiff)`. Every model carries `raw_code` so the section is shown.
+fn render_pr_diff_with_sql_diffs(
+    filename: &str,
+    nodes: Vec<Node>,
+    tests: Vec<(&str, UnitTest)>,
+    model_ids: &[&str],
+    sql_diffs: Vec<(&str, BlockDiff)>,
+) -> String {
+    let all_ids: Vec<String> = tests.iter().map(|(id, _)| (*id).to_owned()).collect();
+    let m = manifest(nodes, tests);
+    let in_scope: InScopeSet = all_ids.into_iter().collect();
+    let models: ModelInScopeSet = model_ids.iter().map(|id| NodeId::new(*id)).collect();
+    let sql_diff_map: HashMap<String, BlockDiff> = sql_diffs
+        .into_iter()
+        .map(|(id, d)| (id.to_owned(), d))
+        .collect();
+    let out = tmp(filename);
+    let _ = std::fs::remove_file(&out);
+    render_report(
+        &out,
+        &m,
+        &in_scope,
+        &models,
+        &InScopeSet::new(),
+        &HashMap::new(),
+        &HashMap::new(),
+        &sql_diff_map,
+        "",
+        ScopeSource::PrDiff,
+        DEFAULT_REPORT_TITLE,
+        None,
+    )
+    .expect("render writes the report");
+    let p = out.to_str().expect("report path is valid UTF-8");
+    format!("file://{p}")
+}
+
+#[test]
+#[ignore = "requires Chrome; runs explicitly in the headless-zero-egress CI job via `-- --ignored`"]
+fn model_sql_section_defaults_to_diff_and_toggles_to_raw() {
+    // dim_a's .sql changed (from t → from u); the run loop attaches an
+    // inline SQL diff. The Model SQL section defaults to the Diff view and
+    // flips to Raw on the toggle.
+    let diff = BlockDiff {
+        lines: vec![
+            dl(DiffLineKind::Context, "select id", None),
+            dl(DiffLineKind::Removed, "from t", Some((5, 6))),
+            dl(DiffLineKind::Added, "from u", Some((5, 6))),
+        ],
+    };
+    let url = render_pr_diff_with_sql_diffs(
+        "headless_sql_diff.html",
+        vec![model_node_with_raw("model.shop.dim_a", "select id\nfrom u")],
+        vec![("unit_test.shop.dim_a.t", unit_test("t", "dim_a"))],
+        &["model.shop.dim_a"],
+        vec![("model.shop.dim_a", diff)],
+    );
+
+    let browser = launch_browser();
+    let tab = browser.new_tab().expect("new tab");
+    tab.navigate_to(&url).expect("navigate");
+    tab.wait_until_navigated().expect("await navigation");
+
+    // The Model SQL section is shown with the Raw↔Diff toggle and the Diff
+    // view default; the summary hint reads "diff".
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql').style.display !== 'none'"
+        ),
+        "the Model SQL section is shown for a model with raw_code",
+    );
+    assert_eq!(
+        eval_string(
+            &tab,
+            "document.querySelector('.model-sql-summary-hint').textContent.trim()"
+        ),
+        "diff",
+        "the summary hint names the diff view",
+    );
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .model-sql-toggle') !== null"
+        ),
+        "the Raw↔Diff toggle is present in the Model SQL section",
+    );
+    assert!(
+        !eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .sql-diff-view').hidden"
+        ),
+        "the Diff view is the default (visible)",
+    );
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .sql-raw-view').hidden"
+        ),
+        "the Raw view starts hidden",
+    );
+    // The diff renders the change pair with intra-line emphasis.
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .sql-diff-view .diff-removed strong') !== null"
+        ),
+        "the removed SQL line carries intra-line emphasis <strong>",
+    );
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .sql-diff-view .diff-added') !== null"
+        ),
+        "the diff renders the added SQL line",
+    );
+
+    // Clicking "Raw" flips to the plain SQL view.
+    let _ = eval(
+        &tab,
+        "document.querySelector('.model-sql .yaml-view-btn[data-view=\"raw\"]').click()",
+    );
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .sql-diff-view').hidden"
+        ),
+        "the Diff view hides after switching to Raw",
+    );
+    assert!(
+        !eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .sql-raw-view').hidden"
+        ),
+        "the Raw view shows after the toggle",
+    );
+
+    let _ = tab.close(true);
+}
+
+#[test]
+#[ignore = "requires Chrome; runs explicitly in the headless-zero-egress CI job via `-- --ignored`"]
+fn model_sql_section_shows_plain_sql_when_no_diff() {
+    // No sql_diff for the model (in scope via a changed test, or baseline):
+    // the Model SQL section shows the plain raw SQL with no toggle.
+    let url = render_pr_diff_with_sql_diffs(
+        "headless_sql_no_diff.html",
+        vec![model_node_with_raw("model.shop.dim_b", "select id\nfrom t")],
+        vec![("unit_test.shop.dim_b.t", unit_test("t", "dim_b"))],
+        &["model.shop.dim_b"],
+        vec![], // no SQL diff
+    );
+
+    let browser = launch_browser();
+    let tab = browser.new_tab().expect("new tab");
+    tab.navigate_to(&url).expect("navigate");
+    tab.wait_until_navigated().expect("await navigation");
+
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql').style.display !== 'none'"
+        ),
+        "the Model SQL section is shown",
+    );
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .model-sql-toggle') === null"
+        ),
+        "no Raw↔Diff toggle when the model has no SQL diff",
+    );
+    assert_eq!(
+        eval_string(
+            &tab,
+            "document.querySelector('.model-sql-summary-hint').textContent.trim()"
+        ),
+        "raw, with Jinja",
+        "the summary hint reads the plain-raw label",
+    );
+    // The raw SQL is highlighted in the (only) <pre>.
+    assert!(
+        eval_bool(
+            &tab,
+            "document.querySelector('.model-sql .model-sql-code') !== null"
+        ),
+        "the plain Model SQL code block renders",
+    );
+
+    let _ = tab.close(true);
+}
diff --git a/tests/render_integration.rs b/tests/render_integration.rs
index 83057db9..2540379e 100644
--- a/tests/render_integration.rs
+++ b/tests/render_integration.rs
@@ -53,6 +53,7 @@ fn render_jaffle_shop(out: &Path) {
         &changed,
         &HashMap::new(),
         &HashMap::new(),
+        &HashMap::new(),
         "jaffle-shop-baseline.json",
         ScopeSource::Baseline,
         DEFAULT_REPORT_TITLE,
diff --git a/tests/snapshots/render_integration__rendered_chrome_jaffle_shop.snap b/tests/snapshots/render_integration__rendered_chrome_jaffle_shop.snap
index edad45bb..34636392 100644
--- a/tests/snapshots/render_integration__rendered_chrome_jaffle_shop.snap
+++ b/tests/snapshots/render_integration__rendered_chrome_jaffle_shop.snap
@@ -736,11 +736,17 @@ table.given-table td, table.expected-table td { white-space: nowrap; }
     }
   }
 
-  // cute-dbt#47 — populate (or hide) the per-model Model SQL section.
-  // The askama template emits one static <section class="model-sql">; JS
-  // rebinds its <code> body and Copy handler each time the user selects a
+  // cute-dbt#47 / cute-dbt#111 — populate (or hide) the per-model Model SQL
+  // section. The askama template emits one static <section class="model-sql">;
+  // JS rebinds its body and Copy handler each time the user selects a
   // different model. When `raw_sql` is missing, hide the whole section
   // (defensive — dbt 1.8+ populates raw_code on every node).
+  //
+  // cute-dbt#111: when the selected model carries an inline SQL diff
+  // (m.sql_diff — PR-diff mode, the model's .sql changed), the section shows
+  // a Raw↔Diff toggle defaulting to Diff (rendered via renderBlockDiff with
+  // the SQL highlighter on context lines only). Absent a diff it renders the
+  // plain raw SQL exactly as cute-dbt#47 did. Copy always copies the raw SQL.
   function renderModelSql(m) {
     var $section = $(".model-sql");
     var raw = m && m.raw_sql;
@@ -749,13 +755,47 @@ table.given-table td, table.expected-table td { white-space: nowrap; }
       return;
     }
     $section.show();
-    $section.find(".model-sql-code").html(highlightSql(raw));
-    var $copy = $section.find(".model-sql-copy");
-    $copy.off("click.cuteDbtModelSql").on("click.cuteDbtModelSql", function (e) {
+    var hasDiff = m.sql_diff && m.sql_diff.lines && m.sql_diff.lines.length;
+    $section.find(".model-sql-summary-hint").text(hasDiff ? "diff" : "raw, with Jinja");
+    var $wrap = $section.find(".model-sql-wrap");
+    // Rebuild the wrap body each model switch so a prior model's toggle/diff
+    // never leaks; the Copy button is re-created here too.
+    $wrap.empty();
+    var $copy = $("<button>").attr("type", "button")
+      .addClass("sql-copy model-sql-copy").text("Copy");
+    $copy.on("click.cuteDbtModelSql", function (e) {
       e.preventDefault();
       e.stopPropagation();
       copySql(raw, $(this));
     });
+    $wrap.append($copy);
+    if (hasDiff) {
+      var $diffPre = $("<pre>").addClass("sql-block model-sql-block sql-diff-view").append(
+        $("<code>").addClass("model-sql-code").html(renderBlockDiff(m.sql_diff, highlightSql))
+      );
+      var $rawPre = $("<pre>").addClass("sql-block model-sql-block sql-raw-view").prop("hidden", true).append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      var $toggle = $("<div>").addClass("yaml-diff-toggle model-sql-toggle");
+      var $diffBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn active").attr("data-view", "diff").text("Diff");
+      var $rawBtn = $("<button>").attr("type", "button")
+        .addClass("yaml-view-btn").attr("data-view", "raw").text("Raw");
+      $toggle.append($diffBtn).append($rawBtn);
+      $toggle.on("click", ".yaml-view-btn", function () {
+        var view = $(this).attr("data-view");
+        $toggle.find(".yaml-view-btn").removeClass("active");
+        $(this).addClass("active");
+        $diffPre.prop("hidden", view !== "diff");
+        $rawPre.prop("hidden", view !== "raw");
+      });
+      $wrap.append($toggle).append($diffPre).append($rawPre);
+    } else {
+      var $pre = $("<pre>").addClass("sql-block model-sql-block").append(
+        $("<code>").addClass("model-sql-code").html(highlightSql(raw))
+      );
+      $wrap.append($pre);
+    }
   }
 
   function renderDagLegend() {
@@ -1331,17 +1371,20 @@ table.given-table td, table.expected-table td { white-space: nowrap; }
   // `__cuteParseCsv` seam introduced in cute-dbt#66).
   window.__cuteHighlightYaml = highlightYaml;
 
-  // cute-dbt#96 concern 2 — render a reconstructed inline YAML block diff
-  // (domain::pr_diff::YamlBlockDiff) as HTML for a <pre><code>. Each line is
-  // a block-level `.diff-line` span (so a full-width add/remove row tint fills
+  // cute-dbt#96 concern 2 / cute-dbt#111 — render a reconstructed inline
+  // block diff (domain::pr_diff::BlockDiff) as HTML for a <pre><code>.
+  // Content-agnostic: `highlightFn` highlights CONTEXT lines only (YAML
+  // for the test drawer, SQL for the Model SQL section). Each line is a
+  // block-level `.diff-line` span (so a full-width add/remove row tint fills
   // the line) — block layout provides the breaks, so the spans are joined with
   // "" (a literal "\n" would render as a blank row between blocks in a <pre>);
   // each is prefixed by a +/-/space sigil.
-  // Context lines reuse the YAML highlighter; changed lines render escaped
-  // text with the intra-line `emphasis` range wrapped in <strong>. The
-  // emphasis offsets are CODEPOINT indices (Rust `chars()`), so the slice
-  // goes through `Array.from` — UTF-16 `.slice` would drift on astral chars.
-  function renderYamlDiff(diff) {
+  // Changed lines BYPASS `highlightFn` (the cute-dbt#96 lesson): they render
+  // escaped text with the intra-line `emphasis` range wrapped in <strong>, so
+  // the emphasis offsets land on the RAW text. The offsets are CODEPOINT
+  // indices (Rust `chars()`), so the slice goes through `Array.from` — UTF-16
+  // `.slice` would drift on astral chars.
+  function renderBlockDiff(diff, highlightFn) {
     return diff.lines.map(function (ln) {
       var cls = ln.kind === "added" ? "diff-added"
               : ln.kind === "removed" ? "diff-removed"
@@ -1349,7 +1392,7 @@ table.given-table td, table.expected-table td { white-space: nowrap; }
       var sigil = ln.kind === "added" ? "+" : ln.kind === "removed" ? "-" : " ";
       var body;
       if (ln.kind === "context") {
-        body = highlightYaml(ln.text);
+        body = highlightFn(ln.text);
       } else if (ln.emphasis) {
         var cps = Array.from(ln.text);
         var a = ln.emphasis[0], b = ln.emphasis[1];
@@ -1364,7 +1407,11 @@ table.given-table td, table.expected-table td { white-space: nowrap; }
            + '</span>';
     }).join("");
   }
-  // Expose for headless JS unit tests (parallels __cuteHighlightYaml).
+  // Expose for headless JS unit tests (parallels __cuteHighlightYaml). The
+  // #96 name is kept as a thin alias so existing headless assertions and the
+  // YAML call site stay byte-stable; new SQL callers pass `highlightSql`.
+  function renderYamlDiff(diff) { return renderBlockDiff(diff, highlightYaml); }
+  window.__cuteRenderBlockDiff = renderBlockDiff;
   window.__cuteRenderYamlDiff = renderYamlDiff;
 
   function copySql(text, $btn) {
diff --git a/tests/steps/builders.rs b/tests/steps/builders.rs
index 0b3ce592..ba2b9068 100644
--- a/tests/steps/builders.rs
+++ b/tests/steps/builders.rs
@@ -163,6 +163,39 @@ pub fn model_node_with_original_file_path(
     )
 }
 
+/// A deterministic multi-line `raw_code` (raw Jinja, dbt-core shape:
+/// trailing newline already stripped) for the model-SQL-diff scenarios
+/// (cute-dbt#111). Line 2 is the value a `ModelSqlTargetKind::Edit` /
+/// `Whitespace` hunk rewrites; the synthesizer matches its `+` line to
+/// this content so N7b aligns.
+pub const MODEL_SQL_RAW_CODE: &str =
+    "with src as (\n    select * from {{ ref('upstream') }}\n)\nselect * from src";
+
+/// Construct a model `Node` carrying both `raw_code` (so the Model SQL
+/// section + the cute-dbt#111 SQL diff can render) and an explicit
+/// `original_file_path`. `compiled` keeps the model past Stage-2 preflight.
+#[must_use]
+pub fn model_node_with_raw_code(
+    bare: &str,
+    checksum: &str,
+    compiled: Option<&str>,
+    original_file_path: &str,
+    raw_code: &str,
+) -> Node {
+    Node::new(
+        model_id(bare),
+        "model",
+        Checksum::new("sha256", checksum),
+        compiled.map(str::to_owned),
+        Some(raw_code.to_owned()),
+        DependsOn::default(),
+        Some(original_file_path.to_owned()),
+        NodeConfig::default(),
+        None,
+        BTreeMap::new(),
+    )
+}
+
 /// Construct a `UnitTest` targeting `target_bare` with an explicit
 /// `original_file_path` (the declaring `.yml` file the PR-diff path
 /// matches against). Given/expect blocks are empty — the PR-diff
diff --git a/tests/steps/pr_diff_scoping.rs b/tests/steps/pr_diff_scoping.rs
index 46e40299..581238ff 100644
--- a/tests/steps/pr_diff_scoping.rs
+++ b/tests/steps/pr_diff_scoping.rs
@@ -42,7 +42,7 @@ use super::builders::{
     empty_manifest, model_node_with_original_file_path, serialize_to_tmp, unit_test_for,
     unit_test_with_path, with_node, with_unit_test,
 };
-use super::world::{BlockTarget, BlockTargetKind};
+use super::world::{BlockTarget, BlockTargetKind, ModelSqlTarget, ModelSqlTargetKind};
 
 /// Synthetic compiled SQL with one import CTE, so a rendered model card
 /// carries a non-empty CTE DAG (the `contains a CTE diagram for …`
@@ -226,6 +226,70 @@ fn emit_targeted_hunks(
     }
 }
 
+/// Emit a hunk over a changed model's `.sql` whose `+` lines match the
+/// model's manifest `raw_code` (cute-dbt#111). The SQL diff reconstructs
+/// from `raw_code` (not disk), so for N7b to align the hunk's new side
+/// must equal the model's stripped `raw_code` frame.
+///
+/// All three kinds edit line 2 of `raw_code` (the
+/// `select * from {{ ref('upstream') }}` line):
+/// - `Edit` — a real value change: `-` differs substantively, `+` ==
+///   working `raw_code` line 2 ⇒ a real SQL diff.
+/// - `Whitespace` — a pure re-indent: `-` differs only in leading
+///   whitespace, `+` == working line 2 ⇒ no SQL diff (plain view).
+/// - `Stale` — the `+` drifts from `raw_code` ⇒ N7b fails ⇒ no SQL diff.
+fn emit_model_sql_hunk(
+    patch: &mut String,
+    manifest: &Manifest,
+    changed: &str,
+    project_root: &str,
+    kind: &ModelSqlTargetKind,
+) {
+    let changed_norm = normalize_path(changed, strip_of(project_root));
+    // The model node whose original_file_path matches the changed .sql.
+    let raw_code = manifest
+        .nodes()
+        .values()
+        .find(|n| {
+            n.original_file_path()
+                .is_some_and(|p| normalize_path(p, None) == changed_norm)
+        })
+        .and_then(cute_dbt::domain::Node::raw_code)
+        .expect("a model-SQL-diff scenario builds a model with raw_code at the changed .sql");
+    // git's line frame: raw_code with a single trailing newline stripped
+    // (dbt-core ships it already stripped; the production code strips one).
+    let raw = raw_code.strip_suffix('\n').unwrap_or(raw_code);
+    let lines: Vec<&str> = raw.split('\n').collect();
+    // Edit line 2 (1-based), the `select * from {{ ref(...) }}` line.
+    let new_start = 2;
+    let working = lines[new_start - 1].to_owned(); // current raw_code line 2
+    let (removed, added) = match kind {
+        ModelSqlTargetKind::Edit => {
+            // Real change: old line referenced a different ref; new == working.
+            (
+                vec![working.replace("upstream", "old_upstream")],
+                vec![working],
+            )
+        }
+        ModelSqlTargetKind::Whitespace => {
+            // Pure re-indent: old line had different leading whitespace; the
+            // non-whitespace content is identical to working ⇒ ws_equal.
+            (
+                vec![format!("        {}", working.trim_start())],
+                vec![working],
+            )
+        }
+        ModelSqlTargetKind::Stale => {
+            // The `+` line drifts from raw_code ⇒ N7b alignment fails.
+            (
+                vec![working.clone()],
+                vec![format!("{working}  -- DRIFTED")],
+            )
+        }
+    };
+    push_hunk(patch, new_start, new_start, &removed, &added);
+}
+
 /// Synthesize a `git diff --unified=0` patch from `world.changed_files`,
 /// writing it to a temp file and returning its path.
 ///
@@ -272,6 +336,15 @@ fn synthesize_pr_diff(
             } else {
                 emit_targeted_hunks(&mut patch, &content, &tests, &targets);
             }
+        } else if let Some(target) = world.model_sql_targets.iter().find(|t| {
+            normalize_path(&t.ofp, None) == normalize_path(changed, strip_of(project_root))
+        }) {
+            // cute-dbt#111: a changed model `.sql` whose model carries
+            // `raw_code`. The SQL diff reads `raw_code` from the MANIFEST
+            // (no working-tree file), so the synthesized hunk's `+` lines
+            // must match the model's stripped `raw_code` frame.
+            push_file_header(&mut patch, changed);
+            emit_model_sql_hunk(&mut patch, manifest, changed, project_root, &target.kind);
         } else {
             push_file_header(&mut patch, changed);
             push_hunk(&mut patch, 1, 1, &["old".to_owned()], &["new".to_owned()]);
@@ -368,6 +441,65 @@ fn pr_diff_stale(world: &mut World, yaml: String) {
     });
 }
 
+// --- Given: model-SQL-diff PR diffs (cute-dbt#111) ------------------
+//
+// These mark a model's `.sql` changed and record how the synthesized hunk
+// edits the model's manifest `raw_code`. The model is built with `raw_code`
+// (via `manifest_contains_model_with_sql`), and the synthesizer matches the
+// hunk's `+` lines to that `raw_code` so N7b aligns.
+
+/// Mark `sql` as a changed file (idempotent).
+fn push_changed_sql(world: &mut World, sql: &str) {
+    if !world.changed_files.iter().any(|f| f == sql) {
+        world.changed_files.push(sql.to_owned());
+    }
+}
+
+#[given(regex = r#"^a PR diff that changes the SQL of "([^"]+)"$"#)]
+fn pr_diff_changes_model_sql(world: &mut World, sql: String) {
+    push_changed_sql(world, &sql);
+    world.model_sql_targets.push(ModelSqlTarget {
+        ofp: sql,
+        kind: ModelSqlTargetKind::Edit,
+    });
+}
+
+#[given(regex = r#"^a PR diff that re-indents the SQL of "([^"]+)" \(whitespace only\)$"#)]
+fn pr_diff_reindents_model_sql(world: &mut World, sql: String) {
+    push_changed_sql(world, &sql);
+    world.model_sql_targets.push(ModelSqlTarget {
+        ofp: sql,
+        kind: ModelSqlTargetKind::Whitespace,
+    });
+}
+
+#[given(regex = r#"^a PR diff whose SQL hunks no longer line up with "([^"]+)"$"#)]
+fn pr_diff_stale_model_sql(world: &mut World, sql: String) {
+    push_changed_sql(world, &sql);
+    world.model_sql_targets.push(ModelSqlTarget {
+        ofp: sql,
+        kind: ModelSqlTargetKind::Stale,
+    });
+}
+
+#[given(regex = r#"^the manifest contains a model with raw SQL at "([^"]+)"$"#)]
+fn manifest_contains_model_with_sql(world: &mut World, ofp: String) {
+    let bare = bare_from_ofp(&ofp);
+    let manifest = take_current(world);
+    let manifest = with_node(
+        manifest,
+        super::builders::model_node_with_raw_code(
+            &bare,
+            "ck-sql",
+            Some(COMPILED_WITH_CTE),
+            &ofp,
+            super::builders::MODEL_SQL_RAW_CODE,
+        ),
+    );
+    world.current_manifest = Some(manifest);
+    world.last_named_model = Some(bare);
+}
+
 // --- Given: synthetic manifest construction -------------------------
 
 #[given(regex = r#"^the manifest contains a model with original_file_path "([^"]+)"$"#)]
@@ -801,6 +933,54 @@ fn test_carries_no_inline_diff(world: &mut World, name: String) {
     );
 }
 
+// --- cute-dbt#111: model SQL diff (payload-asserted) ----------------
+
+/// Find a model object by `name` in the rendered payload.
+fn find_model<'p>(payload: &'p Value, name: &str) -> Option<&'p Value> {
+    payload["models"]
+        .as_array()
+        .into_iter()
+        .flatten()
+        .find(|m| m["name"].as_str() == Some(name))
+}
+
+#[then(
+    regex = r#"^the model "([^"]+)" carries an inline SQL diff with a removed and an added line$"#
+)]
+fn model_carries_sql_diff(world: &mut World, name: String) {
+    require_exit_0(world);
+    let p = payload(world);
+    let model = find_model(&p, &name)
+        .unwrap_or_else(|| panic!("model {name:?} not in payload; got {:?}", model_names(&p)));
+    let lines = model["sql_diff"]["lines"].as_array().unwrap_or_else(|| {
+        panic!("model {name:?} should carry a sql_diff with lines; got {model:?}")
+    });
+    let kinds: Vec<&str> = lines.iter().filter_map(|l| l["kind"].as_str()).collect();
+    assert!(
+        kinds.contains(&"removed"),
+        "sql_diff for {name:?} should include a removed line; got kinds {kinds:?}",
+    );
+    assert!(
+        kinds.contains(&"added"),
+        "sql_diff for {name:?} should include an added line; got kinds {kinds:?}",
+    );
+}
+
+#[then(regex = r#"^the model "([^"]+)" carries no inline SQL diff$"#)]
+fn model_carries_no_sql_diff(world: &mut World, name: String) {
+    require_exit_0(world);
+    let p = payload(world);
+    let model = find_model(&p, &name)
+        .unwrap_or_else(|| panic!("model {name:?} not in payload; got {:?}", model_names(&p)));
+    // `skip_serializing_if` omits the key entirely when there is no diff
+    // (in-scope-via-test-only, stale, whitespace-only) → plain SQL view.
+    assert!(
+        model.get("sql_diff").is_none_or(Value::is_null),
+        "model {name:?} should carry no sql_diff; got {:?}",
+        model.get("sql_diff"),
+    );
+}
+
 #[then(regex = r#"^the model "([^"]+)" carries (\d+) unit tests$"#)]
 fn model_carries_n_tests(world: &mut World, name: String, n: usize) {
     require_exit_0(world);
diff --git a/tests/steps/world.rs b/tests/steps/world.rs
index ef785607..6a8e6cb1 100644
--- a/tests/steps/world.rs
+++ b/tests/steps/world.rs
@@ -96,6 +96,40 @@ pub struct World {
     /// out-of-block (`models:`) region, as a pure deletion, or as a stale
     /// whole-file hunk whose `+` lines drift from the working tree.
     pub block_targets: Vec<BlockTarget>,
+
+    /// cute-dbt#111: model-SQL-diff directives. When a model's `.sql` is a
+    /// changed file, the synthesizer emits a hunk over the model's
+    /// manifest `raw_code` (no working-tree file — the SQL diff reads
+    /// `raw_code` from the manifest, not disk). Keyed by the model's
+    /// `original_file_path`; `kind` says whether the hunk is a real edit,
+    /// a stale (drifted) edit, or a whitespace-only re-indent.
+    pub model_sql_targets: Vec<ModelSqlTarget>,
+}
+
+/// A model-SQL-diff hunk directive for the synthesized diff (cute-dbt#111).
+/// `ofp` is the model's `.sql` `original_file_path`; `kind` says how the
+/// hunk edits the model's `raw_code`.
+#[derive(Debug, Clone)]
+pub struct ModelSqlTarget {
+    /// The model's `.sql` `original_file_path` the hunk lands in.
+    pub ofp: String,
+    /// How the hunk edits the model's `raw_code`.
+    pub kind: ModelSqlTargetKind,
+}
+
+/// How a [`ModelSqlTarget`] edits a model's `raw_code`.
+#[derive(Debug, Clone)]
+pub enum ModelSqlTargetKind {
+    /// A real value change to one `raw_code` line — the `+` matches the
+    /// working `raw_code` (N7b-aligned, touches the file ⇒ a real SQL diff).
+    Edit,
+    /// A whitespace-only re-indent of one `raw_code` line — the `+` matches
+    /// the working `raw_code`, the `-` differs only in leading whitespace
+    /// ⇒ no SQL diff (plain view).
+    Whitespace,
+    /// A hunk whose `+` lines drift from the model's `raw_code` (revision
+    /// drift) ⇒ N7b fails ⇒ no SQL diff (plain view).
+    Stale,
 }
 
 /// A block-precise hunk-placement directive for the synthesized diff

From 5c55179265b1dfb752b4f6f57ab42607e9f18e23 Mon Sep 17 00:00:00 2001
From: Christopher Bays <cmbays91@gmail.com>
Date: Sun, 31 May 2026 13:30:37 -0400
Subject: [PATCH 2/5] test: harden intra_line_span + block_aligns coverage
 (focused mutation set)

Close the focused-set DoD on src/domain/pr_diff.rs:
- intra_line_span_suffix_stops_at_the_prefix_boundary: asymmetric
  shared-prefix+suffix cases that kill the 3 suffix-bound mutants
  (`< -> <=`, `a.len()-prefix -> +`, `b.len()-prefix -> +`). These
  were pre-existing #96 survivors (intra_line_span is byte-identical
  to #96); the function is the substrate #111 generalizes, so it's
  hardened in-PR. The remaining 2 `+= -> *=` survivors are infinite
  loops, classified equivalent inline.
- block_misaligns_when_hunk_claims_a_line_the_block_lacks: covers the
  out-of-range guard the (raw,start,end) widening exposed, restoring
  block_aligns_with_hunks to 100% line coverage (CRAP 15.02 -> 15.00,
  unambiguously within the strict-15 gate).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/domain/pr_diff.rs | 47 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/src/domain/pr_diff.rs b/src/domain/pr_diff.rs
index 00b20a65..7f47f5d0 100644
--- a/src/domain/pr_diff.rs
+++ b/src/domain/pr_diff.rs
@@ -426,6 +426,13 @@ impl BlockDiff {
 /// diff body): the block slicer keeps a trailing `\r` (`split('\n')`) while
 /// the diff parser strips it (`str::lines`), and an untrimmed `\r` on one
 /// side alone would shrink the common suffix and inflate the span by one.
+///
+/// Mutation note (classified-equivalent): replacing `prefix += 1` /
+/// `suffix += 1` with `*= ` makes the counter stick at 0, so the scan loop
+/// never terminates — an infinite loop, not a wrong answer. A hang is not a
+/// behavioral difference a test can assert, so these two `cargo mutants`
+/// survivors are equivalent by construction (the `+`/`<=` bound mutants ARE
+/// killed — see `intra_line_span_suffix_stops_at_the_prefix_boundary`).
 #[must_use]
 pub fn intra_line_span(line: &str, other: &str) -> Option<(usize, usize)> {
     if line == other {
@@ -1086,6 +1093,23 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn block_misaligns_when_hunk_claims_a_line_the_block_lacks() {
+        // The span claims more lines (`block_end` = 5) than `raw` actually
+        // has (2 lines, offsets 0..=1). A hunk whose added line lands at a
+        // new-side position inside [bs, be] but past `raw`'s last line —
+        // `block_lines.get(offset)` is None → stale (return false). Pins the
+        // `(raw, start, end)` widening's out-of-range guard; with `split('\n')`
+        // model `raw_code` spans this is the engine-mismatch safety net.
+        let raw = "select 1\nfrom t"; // 2 lines, offsets 0..=1
+        // block_end overstated to 5; the hunk claims line 4 (offset 3) which
+        // raw doesn't have.
+        assert!(
+            !block_aligns_with_hunks(raw, 1, 5, &[repl(4, &["phantom"])]),
+            "a hunk claiming a line beyond `raw` is stale, not aligned",
+        );
+    }
+
     // ----- block_changed_by_hunks: the four-branch decision -----
 
     const FOUR_BRANCH_RAW: &str = "  - name: t\n    model: m\n    given: []"; // [8, 10]
@@ -1368,6 +1392,29 @@ mod tests {
         assert_eq!(intra_line_span("café x", "café y"), Some((5, 6)));
     }
 
+    #[test]
+    fn intra_line_span_suffix_stops_at_the_prefix_boundary() {
+        // Shared prefix AND shared suffix with asymmetric middle lengths —
+        // stresses BOTH suffix bounds (`suffix < a.len()-prefix` and
+        // `suffix < b.len()-prefix`). The bounds keep the suffix scan from
+        // overlapping the already-matched prefix on the shorter side.
+        // Kills the suffix-bound mutants (`< → <=`, `a.len()-prefix →
+        // a.len()+prefix`, `b.len()-prefix → b.len()+prefix`): each would
+        // over-extend the suffix and shift the reported span.
+        // prefix "a" (1) + suffix "c" (1); middles "X" vs "YYY".
+        assert_eq!(intra_line_span("aXc", "aYYYc"), Some((1, 2))); // "X"
+        assert_eq!(intra_line_span("aYYYc", "aXc"), Some((1, 4))); // "YYY"
+        // The prefix-exhausts-the-short-side case: "ab" is entirely shared
+        // prefix of "abab"; the suffix bound on the short side is 0, so the
+        // suffix loop must NOT advance into the prefix (a `<=` or `+` mutant
+        // would). Short side → None; long side → the trailing "ab".
+        assert_eq!(intra_line_span("ab", "abab"), None);
+        assert_eq!(intra_line_span("abab", "ab"), Some((2, 4))); // trailing "ab"
+        // Suffix shares the WHOLE short side: "xy" is the suffix of "Axy".
+        assert_eq!(intra_line_span("xy", "Axy"), None);
+        assert_eq!(intra_line_span("Axy", "xy"), Some((0, 1))); // leading "A"
+    }
+
     // ----- reconstruct_one: the ordered DiffLine table -----
 
     #[test]

From 072e84ffbaba6ea2b7f1b6883dca6a5e1ef1b02f Mon Sep 17 00:00:00 2001
From: Christopher Bays <cmbays91@gmail.com>
Date: Sun, 31 May 2026 14:04:03 -0400
Subject: [PATCH 3/5] fix: degrade to plain view on non-unified=0
 (context-bearing) hunks; review follow-ups
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

BLOCKER (review 2026-05-31 — both reviewers reproduced an index-OOB
panic): `fold_hunk_edits` looped `0..h.new_len` and indexed
`added_lines[k]`/`removed_lines[k]` via `pair_is_ws_only`. `new_len`
(from the `@@` range) is independent of `added_lines.len()` (counted
`+` bodies), so a DEFAULT `git diff` (3 context lines, parser drops
them) yields `new_len > added_lines.len()` and panics — regressing the
shared #96 YAML drawer too (reconstruct_one is shared).

Fix (both requirements):
- No panic: `hunk_is_unified_zero(h)` = `new_len == added_lines.len()`
  (always true under --unified=0). `reconstruct_one` checks ALL
  touching hunks are unified-zero; if any isn't, it degrades the whole
  block to the plain view (all-Context -> has_real_change()==false ->
  caller shows plain text), consistent with the stale-diff degrade.
- No silent mislabel: degrade is whole-block, so uncovered new-side
  lines are never labeled Added.
- RED regression: a default-context git diff STRING end-to-end through
  parse_diff -> reconstruct_* (tests/changed_files_provider.rs) +
  domain-level context-bearing-hunk tests (SQL + YAML paths). The #96
  malformed-empty-body test now asserts the consistent degrade.

Review MINOR/NIT:
- BlockSpan<'a> { raw, start, end } borrowed arg helper threaded through
  block_aligns_with_hunks / reconstruct_one (kills the adjacent-usize
  swap hazard; not owned/serialized POD).
- BDD `model_carries_sql_diff` tightened: asserts removed-immediately-
  before-added ORDER + line text + surrounding Context.
- Renamed test -> block_diff_serializes_to_the_exact_renderblockdiff_contract.
- Added model_sql_diff empty-raw_code (`Some("")`) degrade test.
- Hardened is_clean_1to1 (`&&`-mutant kill) + intra_line_span
  suffix-bound mutants + block_aligns out-of-range coverage.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/domain/pr_diff.rs           | 356 +++++++++++++++++++++++---------
 tests/changed_files_provider.rs |  59 ++++++
 tests/steps/pr_diff_scoping.rs  |  33 ++-
 3 files changed, 347 insertions(+), 101 deletions(-)

diff --git a/src/domain/pr_diff.rs b/src/domain/pr_diff.rs
index 7f47f5d0..6a1666bc 100644
--- a/src/domain/pr_diff.rs
+++ b/src/domain/pr_diff.rs
@@ -190,6 +190,38 @@ pub fn hunk_touches_block(block_start: usize, block_end: usize, hunk: &Hunk) ->
     }
 }
 
+/// A contiguous source block addressed for diff reconstruction: the verbatim
+/// text plus its 1-based inclusive new-side line span.
+///
+/// A borrowed function-argument helper (NOT owned/serialized POD — it never
+/// enters the domain model or the wire payload, so it does not breach the
+/// POD-only-domain rule). Its purpose is purely to bind `raw`,
+/// `block_start`, and `block_end` into one value so the two widened
+/// reconstruction entry points ([`block_aligns_with_hunks`] /
+/// `reconstruct_one`) can't transpose the two adjacent `usize` bounds at a
+/// call site. The `unit_test` YAML block (#96) builds it from
+/// `(&block.raw, block.block_start, block.block_end)`; a model's SQL
+/// `raw_code` (#111) from the whole-file span. `hunk_touches_block` keeps
+/// its `(start, end, hunk)` arity (it takes no `raw`).
+#[derive(Debug, Clone, Copy)]
+pub struct BlockSpan<'a> {
+    /// The block's verbatim text (the slicer keeps `\r`; callers pass it as
+    /// authored, `split('\n')`-framed).
+    pub raw: &'a str,
+    /// 1-based inclusive first new-side line of the block.
+    pub start: usize,
+    /// 1-based inclusive last new-side line of the block.
+    pub end: usize,
+}
+
+impl<'a> BlockSpan<'a> {
+    /// Construct from the verbatim text and its 1-based inclusive span.
+    #[must_use]
+    pub fn new(raw: &'a str, start: usize, end: usize) -> Self {
+        Self { raw, start, end }
+    }
+}
+
 /// Whether the diff's hunks still line up with the working-tree block — the
 /// revision-alignment (N7b) drift guard.
 ///
@@ -210,11 +242,10 @@ pub fn hunk_touches_block(block_start: usize, block_end: usize, hunk: &Hunk) ->
 /// (a hunk may straddle the block edge); a hunk with no `+` lines (a pure
 /// deletion) is vacuously aligned.
 ///
-/// The block is addressed by `(raw, block_start, block_end)` — the
-/// content-agnostic shape (cute-dbt#111) [`hunk_touches_block`] already
-/// uses, so the same drift guard serves the `unit_test` YAML block (#96)
-/// and a model's SQL `raw_code` (#111). YAML callers pass
-/// `(&block.raw, block.block_start, block.block_end)`.
+/// The block is addressed by a [`BlockSpan`] — the content-agnostic shape
+/// (cute-dbt#111), so the same drift guard serves the `unit_test` YAML
+/// block (#96) and a model's SQL `raw_code` (#111). YAML callers build
+/// `BlockSpan::new(&block.raw, block.block_start, block.block_end)`.
 ///
 /// **Whitespace-EXACT by design.** This is the N7b revision-staleness
 /// check (does the diff's new side still describe the working tree?), so a
@@ -223,20 +254,15 @@ pub fn hunk_touches_block(block_start: usize, block_end: usize, hunk: &Hunk) ->
 /// downstream of N7b, to the removed-vs-added change test in
 /// `reconstruct_one`.
 #[must_use]
-pub fn block_aligns_with_hunks(
-    raw: &str,
-    block_start: usize,
-    block_end: usize,
-    hunks: &[Hunk],
-) -> bool {
-    let block_lines: Vec<&str> = raw.split('\n').collect();
+pub fn block_aligns_with_hunks(span: &BlockSpan, hunks: &[Hunk]) -> bool {
+    let block_lines: Vec<&str> = span.raw.split('\n').collect();
     for hunk in hunks {
         for (k, added) in hunk.added_lines.iter().enumerate() {
             let file_line = hunk.new_start + k; // 1-based new-side line
-            if file_line < block_start || file_line > block_end {
+            if file_line < span.start || file_line > span.end {
                 continue; // outside this block — not this block's concern
             }
-            let offset = file_line - block_start; // 0-based into raw
+            let offset = file_line - span.start; // 0-based into raw
             let Some(actual) = block_lines.get(offset) else {
                 return false; // claims a line the block doesn't have
             };
@@ -289,7 +315,8 @@ pub fn block_changed_by_hunks(block: Option<&UnitTestYamlBlock>, hunks: &[Hunk])
     let Some(block) = block else {
         return true; // absent block → conservative keep
     };
-    if !block_aligns_with_hunks(&block.raw, block.block_start, block.block_end, hunks) {
+    let span = BlockSpan::new(&block.raw, block.block_start, block.block_end);
+    if !block_aligns_with_hunks(&span, hunks) {
         return true; // stale diff (N7b mismatch) → conservative keep
     }
     hunks
@@ -487,7 +514,8 @@ pub fn reconstruct_block_diffs(
             .unit_test(id)
             .and_then(UnitTest::original_file_path)
             .map_or(&[][..], |ofp| index.hunks_for(ofp));
-        if !block_aligns_with_hunks(&block.raw, block.block_start, block.block_end, hunks) {
+        let span = BlockSpan::new(&block.raw, block.block_start, block.block_end);
+        if !block_aligns_with_hunks(&span, hunks) {
             continue; // stale diff → plain drawer
         }
         let touching: Vec<&Hunk> = hunks
@@ -497,7 +525,7 @@ pub fn reconstruct_block_diffs(
         if touching.is_empty() {
             continue; // change is elsewhere in the file → plain drawer
         }
-        let diff = reconstruct_one(&block.raw, block.block_start, block.block_end, &touching);
+        let diff = reconstruct_one(&span, &touching);
         // A purely-whitespace edit (every touching hunk dropped by
         // `reconstruct_one`) leaves an all-Context diff → no drawer diff
         // (cute-dbt#111). The change-pair still kept the test `updated` via
@@ -577,20 +605,21 @@ fn model_sql_diff(model: &Node, index: &NormalizedDiffIndex) -> Option<BlockDiff
     // Strip git's single trailing terminator (engine-divergent — see the
     // module-level fn doc). A real blank line at EOF survives.
     let raw = raw_code.strip_suffix('\n').unwrap_or(raw_code);
-    let (block_start, block_end) = (1, raw.split('\n').count());
+    // Whole-file span: 1..=line count.
+    let span = BlockSpan::new(raw, 1, raw.split('\n').count());
 
     let hunks = index.hunks_for(ofp);
-    if !block_aligns_with_hunks(raw, block_start, block_end, hunks) {
+    if !block_aligns_with_hunks(&span, hunks) {
         return None; // stale diff (N7b) → plain SQL view
     }
     let touching: Vec<&Hunk> = hunks
         .iter()
-        .filter(|h| hunk_touches_block(block_start, block_end, h))
+        .filter(|h| hunk_touches_block(span.start, span.end, h))
         .collect();
     if touching.is_empty() {
         return None; // .sql not touched (model in scope via a changed test)
     }
-    let diff = reconstruct_one(raw, block_start, block_end, &touching);
+    let diff = reconstruct_one(&span, &touching);
     // Whitespace-only model edit → all-Context → no diff (plain SQL).
     diff.has_real_change().then_some(diff)
 }
@@ -662,11 +691,30 @@ fn removed_diff_lines(h: &Hunk) -> Vec<DiffLine> {
         .collect()
 }
 
+/// Whether a hunk has the `--unified=0` shape the reconstruction is
+/// contracted on: its new-side footprint (`new_len`, from the `@@` range)
+/// equals its recorded `+` body count (`added_lines.len()`).
+///
+/// Under `--unified=0` this always holds — pure insertion `N == N`, pure
+/// deletion `0 == 0`, replacement `N == N`. A default (context-bearing)
+/// `git diff` violates it: the `cli::pr_diff` parser drops the ` `-prefixed
+/// context lines, so `new_len > added_lines.len()`. cute-dbt is spec'd on
+/// `--unified=0`; a context-bearing hunk is not a trustworthy line-precise
+/// diff, so [`reconstruct_one`] degrades the whole block to the plain view
+/// rather than panic on the body/footprint mismatch or mislabel
+/// the uncovered new-side lines as Added ("cute-dbt never panics on a bad
+/// diff"). The check is the per-hunk basis of that whole-block degrade.
+fn hunk_is_unified_zero(h: &Hunk) -> bool {
+    h.new_len == h.added_lines.len()
+}
+
 /// Fold one hunk's edits into `edits`. The removed bodies splice before the
 /// hunk's anchor (clamped into the block); each covered new-side line is a
 /// real addition unless it is the new side of a ws-only pair (cute-dbt#111,
 /// then it stays Context); a clean 1:1 replacement records the added line's
-/// intra-line emphasis.
+/// intra-line emphasis. The caller has already verified every touching hunk
+/// is [`hunk_is_unified_zero`], so iterating `0..h.new_len` indexes
+/// `added_lines`/`removed_lines` only within bounds.
 fn fold_hunk_edits(edits: &mut HunkEdits, h: &Hunk, bs: usize, be: usize) {
     let anchor = if h.new_len == 0 {
         h.new_start + 1
@@ -716,13 +764,12 @@ fn block_line_diff(edits: &HunkEdits, line_no: usize, text: String) -> DiffLine
 /// touching it (cute-dbt#96, generalized to any source block at
 /// cute-dbt#111).
 ///
-/// The block is addressed by `(raw, block_start, block_end)` — the
-/// content-agnostic shape, so the same reconstruction serves the
-/// `unit_test` YAML block (#96, `(&block.raw, block.block_start,
-/// block.block_end)`) and a model's SQL `raw_code` (#111, the whole-file
-/// span). Callers pass `raw` already trailing-`\n`-normalized to git's
-/// line frame so `raw.split('\n')` lines up with the hunks' new-side
-/// numbering.
+/// The block is addressed by a [`BlockSpan`] — the content-agnostic shape,
+/// so the same reconstruction serves the `unit_test` YAML block (#96,
+/// `BlockSpan::new(&block.raw, block.block_start, block.block_end)`) and a
+/// model's SQL `raw_code` (#111, the whole-file span). Callers pass `raw`
+/// already trailing-`\n`-normalized to git's line frame so `raw.split('\n')`
+/// lines up with the hunks' new-side numbering.
 ///
 /// **Whitespace-only line-pairs render as Context** ([`pair_is_ws_only`]):
 /// a re-indentation / trailing-whitespace / blank-churn edit is not a
@@ -730,21 +777,33 @@ fn block_line_diff(edits: &HunkEdits, line_no: usize, text: String) -> DiffLine
 /// splice, no emphasis. When every change in the block is whitespace-only
 /// the result is all-Context; the caller tests [`BlockDiff::has_real_change`]
 /// and emits no [`BlockDiff`] so the view falls back to plain text.
-fn reconstruct_one(
-    raw: &str,
-    block_start: usize,
-    block_end: usize,
-    touching: &[&Hunk],
-) -> BlockDiff {
-    let block_lines: Vec<String> = raw.split('\n').map(trim_cr).collect();
-    let (bs, be) = (block_start, block_end);
+///
+/// **Degrades to the plain view on a non-`--unified=0` hunk**
+/// ([`hunk_is_unified_zero`]): cute-dbt is contracted on `--unified=0`, but
+/// the parser accepts a default-context `git diff` (`new_len >
+/// added_lines.len()`). Rather than panic on the body/footprint mismatch or
+/// mislabel uncovered new-side lines as Added, an all-Context diff is
+/// returned (→ `has_real_change()` is false → caller shows plain text),
+/// consistent with the stale-diff degrade.
+fn reconstruct_one(span: &BlockSpan, touching: &[&Hunk]) -> BlockDiff {
+    let block_lines: Vec<String> = span.raw.split('\n').map(trim_cr).collect();
+    let (bs, be) = (span.start, span.end);
+
+    // Contract guard: every touching hunk must be `--unified=0`-shaped
+    // (`new_len == added_lines.len()`). A context-bearing / malformed hunk
+    // makes the line-precise reconstruction untrustworthy (and would index
+    // `added_lines` out of bounds), so degrade the whole block to the plain
+    // view — render every line as Context.
+    let trustworthy = touching.iter().all(|h| hunk_is_unified_zero(h));
 
     // Removed-line groups to splice immediately before a given new-side
     // line; `added_real` marks genuine (non-whitespace) additions;
     // `added_emphasis` carries the clean-1:1 intra-line span (cute-dbt#111).
     let mut edits = HunkEdits::default();
-    for h in touching {
-        fold_hunk_edits(&mut edits, h, bs, be);
+    if trustworthy {
+        for h in touching {
+            fold_hunk_edits(&mut edits, h, bs, be);
+        }
     }
 
     let mut lines: Vec<DiffLine> = Vec::new();
@@ -1011,9 +1070,7 @@ mod tests {
         let block = block_at(ALIGN_RAW, 2); // [2, 4]
         // Replace line 3 with the line that is actually there → aligned.
         assert!(block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[repl(3, &["    model: m"])]
         ));
     }
@@ -1026,9 +1083,7 @@ mod tests {
         // 1`, not `new_start - 1` — pins the per-line index arithmetic
         // (`file_line = new_start + k`) so a `+`→`-` slip on `k` is caught.
         assert!(block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[repl(3, &["    model: m", "    given: []"])]
         ));
     }
@@ -1038,9 +1093,7 @@ mod tests {
         let block = block_at(ALIGN_RAW, 2); // [2, 4]
         // Claims "    model: m" at line 2, but line 2 is "  - name: t".
         assert!(!block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[repl(2, &["    model: m"])]
         ));
     }
@@ -1049,9 +1102,7 @@ mod tests {
     fn block_misaligns_when_added_line_content_is_corrupted() {
         let block = block_at(ALIGN_RAW, 2); // [2, 4]
         assert!(!block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[repl(3, &["    model: CORRUPTED"])]
         ));
     }
@@ -1061,9 +1112,7 @@ mod tests {
         let block = block_at("  - name: t\n    model: m", 8); // [8, 9]
         // A hunk in the file header — entirely above the block → ignored.
         assert!(block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[repl(1, &["version: 3"])]
         ));
     }
@@ -1073,9 +1122,7 @@ mod tests {
         let block = block_at("  - name: t\n    model: m", 2);
         // A deletion carries no `+` lines → nothing to verify → aligned.
         assert!(block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[del(2)]
         ));
     }
@@ -1086,9 +1133,7 @@ mod tests {
         // (str::lines). A CRLF working tree must not read as stale.
         let block = block_at("  - name: t\r\n    model: m\r", 2); // ["  - name: t\r", "    model: m\r"]
         assert!(block_aligns_with_hunks(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &[repl(3, &["    model: m"])]
         ));
     }
@@ -1105,7 +1150,7 @@ mod tests {
         // block_end overstated to 5; the hunk claims line 4 (offset 3) which
         // raw doesn't have.
         assert!(
-            !block_aligns_with_hunks(raw, 1, 5, &[repl(4, &["phantom"])]),
+            !block_aligns_with_hunks(&BlockSpan::new(raw, 1, 5), &[repl(4, &["phantom"])]),
             "a hunk claiming a line beyond `raw` is stale, not aligned",
         );
     }
@@ -1435,9 +1480,7 @@ mod tests {
             ..block
         };
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1469,9 +1512,7 @@ mod tests {
             &["    model: orders"],
         )];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1492,9 +1533,7 @@ mod tests {
         // Deletion gap after new-side line 11 → removed renders between 11 and 12.
         let hunks = [delete(11, &["      # note"])];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1514,9 +1553,7 @@ mod tests {
         let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
         let hunks = [delete(9, &["  # leading"])];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1536,9 +1573,7 @@ mod tests {
         let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
         let hunks = [delete(12, &["  # trailing"])];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1559,9 +1594,7 @@ mod tests {
         let block = block_at("    model: m2\n    given: []\n      rows: []", 10); // [10,12]
         let hunks = [replace(9, &["old8", "old9"], &["new9", "    model: m2"])];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1585,9 +1618,7 @@ mod tests {
             replace(13, &["oldB"], &["newB"]),
         ];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1610,9 +1641,7 @@ mod tests {
         let block = block_at("  - name: t\nnewA\nnewB\n    given: []", 10); // [10,13]
         let hunks = [replace(11, &["oldA", "oldB"], &["newA", "newB"])];
         let got = reconstruct_one(
-            &block.raw,
-            block.block_start,
-            block.block_end,
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
             &hunks.iter().collect::<Vec<_>>(),
         );
         assert_eq!(
@@ -1629,11 +1658,48 @@ mod tests {
     }
 
     #[test]
-    fn reconstruct_does_not_panic_on_a_malformed_hunk_with_an_empty_added_body() {
-        // A diff can declare `new_len: 1` yet carry no `+` body (malformed).
-        // The clean-1:1 emphasis path indexes `added_lines[0]`, so the
-        // `added_lines.len() == 1` guard is what keeps this from panicking
-        // (CodeRabbit #110): it degrades to a line-level Added, no emphasis.
+    fn reconstruct_two_removed_one_added_is_not_clean_1to1_no_emphasis() {
+        // `is_clean_1to1` requires ALL THREE of new_len==1, removed.len()==1,
+        // added.len()==1 (it gates intra-line emphasis). A `@@ -N,2 +N,1 @@`
+        // shape — TWO old lines collapse into ONE new line — is a valid
+        // `--unified=0` hunk (new_len(1) == added.len(1)) but NOT a clean 1:1
+        // (removed.len()==2). The removed lines must carry NO emphasis: a
+        // mutant relaxing `is_clean_1to1`'s `&&` to `||` would qualify this as
+        // clean and emit a spurious <strong> on removed[0] — this pins both
+        // `&&`s (cargo mutants 2026-05-31).
+        let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
+        let hunks = [replace(
+            11,
+            &["    model: was", "    extra: gone"],
+            &["    model: m"],
+        )];
+        let got = reconstruct_one(
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
+            &hunks.iter().collect::<Vec<_>>(),
+        );
+        assert_eq!(
+            got.lines,
+            vec![
+                ctx("  - name: t"),
+                rem("    model: was"), // NO emphasis (not a clean 1:1)
+                rem("    extra: gone"),
+                add("    model: m"), // NO emphasis
+                ctx("    given: []"),
+            ],
+            "a 2-removed/1-added replacement carries no intra-line emphasis",
+        );
+    }
+
+    #[test]
+    fn reconstruct_degrades_on_a_malformed_hunk_with_an_empty_added_body() {
+        // A diff that declares `new_len: 1` yet carries no `+` body is
+        // `new_len(1) != added_lines.len(0)` — the same non-`--unified=0`
+        // mismatch as a context-bearing hunk, so it degrades the whole block
+        // to the plain view (all Context). This both avoids the
+        // `added_lines[0]` OOB panic the #110 review flagged AND is honest:
+        // a hunk that claims a new-side line with no recorded `+` body is not
+        // a trustworthy line-precise diff, so cute-dbt shows the plain text
+        // rather than fabricate an Added line from the block content.
         let block = block_at("  - name: t\n    model: m\n    given: []", 10); // [10,12]
         let hunk = Hunk {
             new_start: 11,
@@ -1641,16 +1707,22 @@ mod tests {
             removed_lines: vec!["    model: was".to_owned()],
             added_lines: Vec::new(),
         };
-        let got = reconstruct_one(&block.raw, block.block_start, block.block_end, &[&hunk]);
+        let got = reconstruct_one(
+            &BlockSpan::new(&block.raw, block.block_start, block.block_end),
+            &[&hunk],
+        );
         assert_eq!(
             got.lines,
             vec![
                 ctx("  - name: t"),
-                rem("    model: was"),
-                add("    model: m"),
+                ctx("    model: m"),
                 ctx("    given: []"),
             ],
         );
+        assert!(
+            !got.has_real_change(),
+            "malformed hunk degrades to plain view"
+        );
     }
 
     // ----- reconstruct_block_diffs: the gating (present AND aligned AND touched) -----
@@ -1761,7 +1833,7 @@ mod tests {
     // ----- BlockDiff serde: the exact JS wire shape -----
 
     #[test]
-    fn yaml_block_diff_serializes_to_the_exact_renderyamldiff_contract() {
+    fn block_diff_serializes_to_the_exact_renderblockdiff_contract() {
         let diff = BlockDiff {
             lines: vec![
                 ctx("  - name: t"),
@@ -1848,7 +1920,10 @@ mod tests {
             &["select a", "from t"],
             &["  select a", "from u"],
         )];
-        let got = reconstruct_one(raw, 1, 2, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &BlockSpan::new(raw, 1, 2),
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         // The whitespace goal is met: line 1 ("  select a") renders as
         // CONTEXT (not Added) and only the substantive "from t"→"from u"
         // pair diffs. The removed line splices at the hunk anchor (its
@@ -1901,7 +1976,10 @@ mod tests {
         // new-side line is Context. Frame: 3 context lines, no real change.
         let raw = "  - name: t\n    model: m\n    given: []"; // [10,12]
         let hunks = [replace(11, &["model: m"], &["    model: m"])];
-        let got = reconstruct_one(raw, 10, 12, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &BlockSpan::new(raw, 10, 12),
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         assert_eq!(
             got.lines,
             vec![
@@ -1925,7 +2003,10 @@ mod tests {
             replace(11, &["model: m"], &["    model: m"]), // ws-only → dropped
             replace(12, &["    given: []"], &["    given: [1]"]), // real → kept
         ];
-        let got = reconstruct_one(raw, 10, 12, &hunks.iter().collect::<Vec<_>>());
+        let got = reconstruct_one(
+            &BlockSpan::new(raw, 10, 12),
+            &hunks.iter().collect::<Vec<_>>(),
+        );
         // Common prefix "    given: [" (12); removed "]" has no own changed
         // span (it is the shorter side's shared suffix → None); added "1]"
         // contributes "1" at codepoint 12.
@@ -2171,4 +2252,85 @@ mod tests {
         let scope = ModelInScopeSet::from_iter([NodeId::new("model.s.noraw")]);
         assert!(reconstruct_model_sql_diffs(&current, &scope, &index).is_empty());
     }
+
+    #[test]
+    fn reconstruct_model_sql_diffs_skips_a_model_with_empty_raw_code() {
+        // A model shipping `raw_code: ""` (some node types do) is treated as
+        // absent — matches `build_model_payload`'s `raw_sql` filter, so we
+        // never compute a diff the template would not show.
+        let ofp = "models/empty.sql";
+        let m = model_with_raw("model.s.empty", "", ofp);
+        let current = manifest_with_models(vec![m]);
+        let diff = PrDiff {
+            files: vec![FileHunks {
+                path: ofp.to_owned(),
+                hunks: vec![replace(1, &["old"], &["new"])],
+            }],
+        };
+        let index = NormalizedDiffIndex::new(&diff, None);
+        let scope = ModelInScopeSet::from_iter([NodeId::new("model.s.empty")]);
+        assert!(reconstruct_model_sql_diffs(&current, &scope, &index).is_empty());
+    }
+
+    // ----- Non-`--unified=0` (context-bearing) hunk safety -----
+    //
+    // A hunk's `new_len` (from the `@@` header range) is independent of
+    // `added_lines.len()` (the counted `+` bodies). cute-dbt is contracted on
+    // `--unified=0` (`new_len == added_lines.len()`), but the parser ACCEPTS
+    // a default-context `git diff` (`consume_body_line` drops context lines),
+    // yielding `new_len > added_lines.len()`. Reconstruction must never panic
+    // on that (the "cute-dbt never panics on a bad diff" contract) and must
+    // not mislabel context lines as Added — it degrades the block to the
+    // plain view, consistent with the stale→plain-view fallback.
+
+    /// A context-bearing hunk: `new_len` spans more new-side lines than the
+    /// `added_lines` body carries (the default-`git diff` shape the
+    /// `--unified=0` contract excludes).
+    fn context_bearing(new_start: usize, new_len: usize, removed: &[&str], added: &[&str]) -> Hunk {
+        Hunk {
+            new_start,
+            new_len, // deliberately != added.len()
+            removed_lines: removed.iter().map(|s| (*s).to_owned()).collect(),
+            added_lines: added.iter().map(|s| (*s).to_owned()).collect(),
+        }
+    }
+
+    #[test]
+    fn reconstruct_one_degrades_on_a_context_bearing_hunk_without_panicking() {
+        // `new_len = 3` but only one `+` body — a default-context git diff.
+        // Must NOT panic (no `added_lines[k]` OOB) and must NOT label the
+        // uncovered new-side lines as Added.
+        let raw = "select a\nfrom t\nwhere x"; // [1,3]
+        let hunks = [context_bearing(1, 3, &["from was"], &["from t"])];
+        let got = reconstruct_one(
+            &BlockSpan::new(raw, 1, 3),
+            &hunks.iter().collect::<Vec<_>>(),
+        );
+        // Degrade to plain view: a context-bearing hunk is not a trustworthy
+        // line-precise diff, so the block carries no Added/Removed lines.
+        assert!(
+            !got.has_real_change(),
+            "a context-bearing hunk degrades to the plain view; got {:?}",
+            got.lines,
+        );
+    }
+
+    #[test]
+    fn reconstruct_model_sql_diffs_degrades_on_a_context_bearing_hunk() {
+        let ofp = "models/ctx.sql";
+        let m = model_with_raw("model.s.ctx", "select a\nfrom t\nwhere x", ofp);
+        let current = manifest_with_models(vec![m]);
+        // A default-context git diff: the `@@` claims 3 new-side lines but
+        // only one `+` body is recorded (parser drops context lines).
+        let diff = PrDiff {
+            files: vec![FileHunks {
+                path: ofp.to_owned(),
+                hunks: vec![context_bearing(1, 3, &["from was"], &["from t"])],
+            }],
+        };
+        let index = NormalizedDiffIndex::new(&diff, None);
+        let scope = ModelInScopeSet::from_iter([NodeId::new("model.s.ctx")]);
+        // No panic; degrades to plain SQL view (no entry).
+        assert!(reconstruct_model_sql_diffs(&current, &scope, &index).is_empty());
+    }
 }
diff --git a/tests/changed_files_provider.rs b/tests/changed_files_provider.rs
index 935de204..48bd88f5 100644
--- a/tests/changed_files_provider.rs
+++ b/tests/changed_files_provider.rs
@@ -151,3 +151,62 @@ fn valid_diff_touching_unit_test_yaml_puts_that_test_in_scope_exit_0() {
         "the banner states PR-diff provenance",
     );
 }
+
+#[test]
+fn a_default_context_git_diff_does_not_panic_and_renders_a_report() {
+    // BLOCKER regression (review 2026-05-31): cute-dbt is contracted on
+    // `--unified=0`, but the parser ACCEPTS a default `git diff` (3 context
+    // lines), yielding hunks whose `new_len` (from the `@@` range) exceeds
+    // `added_lines.len()` (context lines are dropped). The #111
+    // reconstruction must NOT panic on that body/footprint mismatch (the
+    // "cute-dbt never panics on a bad diff" contract) — it degrades the
+    // affected block to the plain view. This drives a default-context diff
+    // touching a real model `.sql` end-to-end through `parse_diff` →
+    // `reconstruct_model_sql_diffs` (+ `reconstruct_block_diffs`) via the
+    // binary, asserting a clean exit 0 + a written report.
+    let current = fixture("jaffle-shop-current.json");
+    let diff = tmp("cfp-default-context.patch");
+    // A default `git diff --unified=3`-shaped hunk: `@@ -1,5 +1,5 @@` claims
+    // 5 new-side lines but records ONE `+` body (the rest are ` `-context).
+    // `customers` is a real compiled model (models/customers.sql, raw_code
+    // begins `with customers as (`).
+    fs::write(
+        &diff,
+        "--- a/models/customers.sql\n\
++++ b/models/customers.sql\n\
+@@ -1,5 +1,5 @@\n\
+ with customers as (\n\
+ \n\
+-    select * from raw.customers\n\
++    select * from raw.customers_v2\n\
+     where 1=1\n\
+ ),\n",
+    )
+    .expect("write default-context patch");
+    let out = tmp("cfp-default-context-report.html");
+    clear(&out);
+
+    let output = run_cli(&[
+        "--manifest",
+        s(&current),
+        "--pr-diff",
+        &format!("@{}", s(&diff)),
+        "--out",
+        s(&out),
+    ]);
+
+    assert!(
+        output.status.success(),
+        "a default-context git diff must render (exit 0), not panic; stderr: {}",
+        String::from_utf8_lossy(&output.stderr),
+    );
+    assert!(
+        out.exists(),
+        "a report is written for a default-context diff"
+    );
+    let html = fs::read_to_string(&out).expect("report is readable");
+    assert!(
+        html.contains("from PR file diff"),
+        "the report banner states PR-diff provenance",
+    );
+}
diff --git a/tests/steps/pr_diff_scoping.rs b/tests/steps/pr_diff_scoping.rs
index 581238ff..8f081bb5 100644
--- a/tests/steps/pr_diff_scoping.rs
+++ b/tests/steps/pr_diff_scoping.rs
@@ -956,13 +956,38 @@ fn model_carries_sql_diff(world: &mut World, name: String) {
         panic!("model {name:?} should carry a sql_diff with lines; got {model:?}")
     });
     let kinds: Vec<&str> = lines.iter().filter_map(|l| l["kind"].as_str()).collect();
+    // Content + ORDER oracle (not just presence): the synthesized Edit hunk
+    // rewrites raw_code line 2 (`select * from {{ ref('upstream') }}`), so the
+    // diff must show a Removed line (the old `..old_upstream..` body)
+    // IMMEDIATELY followed by the Added working-tree line — a flipped
+    // removed↔added or a stray reconstruction would fail here.
+    let removed_idx = lines.iter().position(|l| l["kind"] == "removed");
+    let added_idx = lines.iter().position(|l| l["kind"] == "added");
+    let (Some(ri), Some(ai)) = (removed_idx, added_idx) else {
+        panic!("sql_diff for {name:?} must carry a removed AND an added line; got kinds {kinds:?}");
+    };
+    assert_eq!(
+        ai,
+        ri + 1,
+        "the added line must immediately follow the removed line (change pair); got kinds {kinds:?}",
+    );
+    let removed_text = lines[ri]["text"].as_str().unwrap_or_default();
+    let added_text = lines[ai]["text"].as_str().unwrap_or_default();
     assert!(
-        kinds.contains(&"removed"),
-        "sql_diff for {name:?} should include a removed line; got kinds {kinds:?}",
+        removed_text.contains("old_upstream"),
+        "the removed line is the pre-edit `..old_upstream..` body; got {removed_text:?}",
     );
     assert!(
-        kinds.contains(&"added"),
-        "sql_diff for {name:?} should include an added line; got kinds {kinds:?}",
+        added_text.contains("ref('upstream')") && !added_text.contains("old_upstream"),
+        "the added line is the working-tree raw_code line; got {added_text:?}",
+    );
+    // And the surrounding raw_code lines are Context (line 1 `with src as (`).
+    assert!(
+        lines.iter().any(|l| l["kind"] == "context"
+            && l["text"]
+                .as_str()
+                .is_some_and(|t| t.contains("with src as"))),
+        "the unchanged raw_code lines render as Context; got {kinds:?}",
     );
 }
 

From ea43ec929b6647c076bee19b2f93775d216944d7 Mon Sep 17 00:00:00 2001
From: Christopher Bays <cmbays91@gmail.com>
Date: Sun, 31 May 2026 16:45:45 -0400
Subject: [PATCH 4/5] feat: stderr note when --pr-diff is not git diff
 --unified=0
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

cute-dbt#111 follow-up (Christopher-approved, same PR): a context-bearing
diff silently degrades every affected block to the plain view (the
reconstruct_one contract guard). Emit ONE actionable stderr line so a user
who forgot --unified=0 isn't left thinking inline diffs are broken.

- domain (pure, std-only, no I/O): NormalizedDiffIndex::context_bearing_
  hunk_count() counts hunks where new_len != added_lines.len() — exact
  for "not --unified=0" (insert N==N / delete 0==0 / replace N==N always
  hold under -U0). Unit-tested (exact count on a mixed diff; 0 on a clean
  -U0 diff incl. a pure-deletion hunk); 3/3 mutants caught.
- cli (the I/O lives here, not in domain): warn_if_not_unified_zero emits
  once on the PrDiff arm only:
  "cute-dbt: warning: the supplied diff is not `git diff --unified=0`
   (N context-bearing hunk(s)); inline diffs are disabled — showing plain
   views. Re-run the diff with --unified=0 for inline diffs."
- integration (tests/changed_files_provider.rs): the note is PRESENT on a
  default-context diff and ABSENT on a clean --unified=0 diff.

Examples + manifest-digest snapshot byte-stable (stderr-only, no payload
or template change). Feature-count stays 10.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/cli/mod.rs                  | 30 +++++++++++++
 src/domain/pr_diff.rs           | 78 +++++++++++++++++++++++++++++++++
 tests/changed_files_provider.rs | 49 +++++++++++++++++++++
 3 files changed, 157 insertions(+)

diff --git a/src/cli/mod.rs b/src/cli/mod.rs
index 551e48f7..4339cb21 100644
--- a/src/cli/mod.rs
+++ b/src/cli/mod.rs
@@ -182,6 +182,14 @@ fn execute(cli: &Cli) -> Result<(), RunError> {
         }
         ScopeInput::Baseline { .. } => HashMap::new(),
     };
+    // cute-dbt#111: a non-`--unified=0` diff degrades every affected block to
+    // the plain view (the `reconstruct_one` contract guard). Surface that ONCE
+    // on stderr so a user who forgot `--unified=0` isn't left thinking the
+    // inline diffs are broken. PrDiff arm only (baseline mode has no hunks);
+    // the domain predicate is pure — the I/O (`eprintln!`) lives here in cli.
+    if let ScopeInput::PrDiff { index } = &scope_input {
+        warn_if_not_unified_zero(index);
+    }
     let (report_title, report_subtitle) = resolve_report_strings(cli);
     let (baseline_label, scope_source) = scope_banner(cli, &scope_input);
     render(
@@ -362,6 +370,28 @@ fn scope_banner(cli: &Cli, scope_input: &ScopeInput) -> (String, ScopeSource) {
     }
 }
 
+/// Emit a single stderr note when the supplied `--pr-diff` is not
+/// `git diff --unified=0` (cute-dbt#111).
+///
+/// A context-bearing diff degrades every affected block to the plain view
+/// (the `reconstruct_one` contract guard in `domain::pr_diff`), so without
+/// this note a user who forgot `--unified=0` would see plain views and
+/// assume the inline diffs are broken. The decision is a pure domain
+/// predicate ([`NormalizedDiffIndex::context_bearing_hunk_count`]); the
+/// `eprintln!` (the only I/O) lives here in cli, not in `domain`. Emitted
+/// once per run on the `PrDiff` arm only.
+fn warn_if_not_unified_zero(index: &NormalizedDiffIndex) {
+    let n = index.context_bearing_hunk_count();
+    if n > 0 {
+        let plural = if n == 1 { "hunk" } else { "hunks" };
+        eprintln!(
+            "cute-dbt: warning: the supplied diff is not `git diff --unified=0` \
+             ({n} context-bearing {plural}); inline diffs are disabled — showing \
+             plain views. Re-run the diff with --unified=0 for inline diffs."
+        );
+    }
+}
+
 /// The `parse_ctes` stage — a named no-op call site.
 ///
 /// Per-model CTE parsing happens inside the renderer's payload
diff --git a/src/domain/pr_diff.rs b/src/domain/pr_diff.rs
index 6a1666bc..280b1d82 100644
--- a/src/domain/pr_diff.rs
+++ b/src/domain/pr_diff.rs
@@ -151,6 +151,30 @@ impl NormalizedDiffIndex {
             .get(&normalize_path(original_file_path, None))
             .map_or(&[], Vec::as_slice)
     }
+
+    /// How many hunks across all files are **not** `--unified=0`-shaped —
+    /// i.e. carry context lines (cute-dbt#111).
+    ///
+    /// A hunk's `new_len` (from the `@@` range) equals its recorded `+`
+    /// body count (`added_lines.len()`) iff the diff was produced with
+    /// `--unified=0`: pure insertion `N == N`, pure deletion `0 == 0`,
+    /// replacement `N == N` all hold. A default (context-bearing) `git
+    /// diff` drops its ` `-prefixed context lines at parse time, so
+    /// `new_len > added_lines.len()`. This counts exactly those hunks.
+    ///
+    /// Pure computation over the parsed index (std-only, no I/O). The CLI
+    /// reads it once on the `PrDiff` arm to emit a single stderr note when a
+    /// user forgot `--unified=0` — inline diffs degrade to the plain view
+    /// (`reconstruct_one`'s `hunk_is_unified_zero` guard), and this makes
+    /// that silent degrade visible.
+    #[must_use]
+    pub fn context_bearing_hunk_count(&self) -> usize {
+        self.by_path
+            .values()
+            .flatten()
+            .filter(|h| h.new_len != h.added_lines.len())
+            .count()
+    }
 }
 
 // ---------------------------------------------------------------------
@@ -962,6 +986,60 @@ mod tests {
         assert_eq!(index.hunks_for("models/_ut.yml").len(), 2);
     }
 
+    #[test]
+    fn context_bearing_hunk_count_counts_only_non_unified_zero_hunks() {
+        // A `--unified=0` diff: replacement (new_len == added.len()) and a
+        // pure deletion (new_len == 0 == added.len()) both satisfy the
+        // predicate → count 0.
+        let unified_zero = PrDiff {
+            files: vec![
+                FileHunks {
+                    path: "models/a.sql".to_owned(),
+                    hunks: vec![repl(3, &["new line"]), del(7)],
+                },
+                FileHunks {
+                    path: "models/b.yml".to_owned(),
+                    hunks: vec![repl(1, &["x", "y"])], // new_len 2 == added 2
+                },
+            ],
+        };
+        assert_eq!(
+            NormalizedDiffIndex::new(&unified_zero, None).context_bearing_hunk_count(),
+            0,
+            "a pure --unified=0 diff (incl. a pure-deletion hunk) has zero context-bearing hunks",
+        );
+
+        // A context-bearing (default `git diff`) shape: `new_len` claims more
+        // new-side lines than the recorded `+` bodies (context lines dropped).
+        // Two such hunks across two files + one clean replacement → count 2.
+        let context_bearing = |new_start, new_len, added: &[&str]| Hunk {
+            new_start,
+            new_len, // > added.len()
+            removed_lines: vec!["was".to_owned()],
+            added_lines: added.iter().map(|s| (*s).to_owned()).collect(),
+        };
+        let mixed = PrDiff {
+            files: vec![
+                FileHunks {
+                    path: "models/a.sql".to_owned(),
+                    hunks: vec![
+                        context_bearing(1, 5, &["one +"]), // 5 != 1 → context-bearing
+                        repl(20, &["clean replacement"]),  // 1 == 1 → unified-zero
+                    ],
+                },
+                FileHunks {
+                    path: "models/b.sql".to_owned(),
+                    hunks: vec![context_bearing(1, 3, &["a", "b"])], // 3 != 2 → context-bearing
+                },
+            ],
+        };
+        assert_eq!(
+            NormalizedDiffIndex::new(&mixed, None).context_bearing_hunk_count(),
+            2,
+            "counts exactly the hunks whose new_len != added_lines.len()",
+        );
+    }
+
     // =================================================================
     // Block-precise narrowing (cute-dbt#96 Step 2)
     // =================================================================
diff --git a/tests/changed_files_provider.rs b/tests/changed_files_provider.rs
index 48bd88f5..f4b89c16 100644
--- a/tests/changed_files_provider.rs
+++ b/tests/changed_files_provider.rs
@@ -209,4 +209,53 @@ fn a_default_context_git_diff_does_not_panic_and_renders_a_report() {
         html.contains("from PR file diff"),
         "the report banner states PR-diff provenance",
     );
+    // cute-dbt#111: a one-line stderr note tells the user the diff isn't
+    // `--unified=0` so the plain views aren't mistaken for a broken feature.
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        stderr.contains("not `git diff --unified=0`")
+            && stderr.contains("--unified=0 for inline diffs"),
+        "a context-bearing diff emits the actionable --unified=0 note; stderr: {stderr}",
+    );
+}
+
+#[test]
+fn a_unified_zero_diff_emits_no_context_bearing_note() {
+    // The converse of the above: a clean `--unified=0` diff (every hunk
+    // `new_len == added_lines.len()`) must NOT emit the context-bearing note
+    // — inline diffs work, so the note would be misleading noise.
+    let current = fixture("jaffle-shop-current.json");
+    let diff = tmp("cfp-unified-zero.patch");
+    // `@@ -3,1 +3,1 @@` with exactly one `-`/`+` body, no context lines.
+    fs::write(
+        &diff,
+        "--- a/models/customers.sql\n\
++++ b/models/customers.sql\n\
+@@ -3,1 +3,1 @@\n\
+-    select * from raw.customers\n\
++    select * from raw.customers_v2\n",
+    )
+    .expect("write unified=0 patch");
+    let out = tmp("cfp-unified-zero-report.html");
+    clear(&out);
+
+    let output = run_cli(&[
+        "--manifest",
+        s(&current),
+        "--pr-diff",
+        &format!("@{}", s(&diff)),
+        "--out",
+        s(&out),
+    ]);
+
+    assert!(
+        output.status.success(),
+        "a --unified=0 diff renders (exit 0); stderr: {}",
+        String::from_utf8_lossy(&output.stderr),
+    );
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        !stderr.contains("not `git diff --unified=0`"),
+        "a clean --unified=0 diff emits no context-bearing note; stderr: {stderr}",
+    );
 }

From 681268d301a7cf0c46f240a6845ed8c252fd775c Mon Sep 17 00:00:00 2001
From: Christopher Bays <cmbays91@gmail.com>
Date: Sun, 31 May 2026 16:59:41 -0400
Subject: [PATCH 5/5] refactor: drop redundant CR-trim in pair_is_ws_only
 (cute-dbt#113 review)

ws_equal compares split_whitespace token sequences, which already ignore a trailing carriage return, so the trim before it was dead. Gemini review finding on PR #113. Behavior-preserving: 543 tests green, clippy --locked clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/domain/pr_diff.rs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/domain/pr_diff.rs b/src/domain/pr_diff.rs
index 280b1d82..ee17c110 100644
--- a/src/domain/pr_diff.rs
+++ b/src/domain/pr_diff.rs
@@ -666,11 +666,9 @@ fn trim_cr(s: &str) -> String {
 /// diffs. Only meaningful for equal-count hunks; a genuine insertion /
 /// deletion (unequal counts) has no pairing and is always a real change.
 fn pair_is_ws_only(h: &Hunk, i: usize) -> bool {
-    h.removed_lines.len() == h.added_lines.len()
-        && ws_equal(
-            h.removed_lines[i].trim_end_matches('\r'),
-            h.added_lines[i].trim_end_matches('\r'),
-        )
+    // No `\r`-trim needed: `ws_equal` compares `split_whitespace()` token
+    // sequences, which already ignore a trailing `\r` (cute-dbt#113 review).
+    h.removed_lines.len() == h.added_lines.len() && ws_equal(&h.removed_lines[i], &h.added_lines[i])
 }
 
 /// The new-side edits a set of touching hunks impose on a block: which