@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Avalonia;
@@ -189,7 +189,7 @@ private void StatementsContextMenu_Opening(object? sender, System.ComponentModel
     private void UpdateStatementMenuForSelection()
     {
         var substitutable = StatementsGrid.SelectedItem is StatementRow row
-            && ParameterSubstitution.Apply(row.Statement.StatementText, row.Statement.Parameters)
+            && ParameterSubstitution.Apply(PlanOrCapturedStatementText(row.Statement), row.Statement.Parameters)
                 .SubstitutionCount > 0;
 
         // Say so on the label rather than substituting silently: the text the plan records and the
@@ -219,7 +219,7 @@ private async void CopyStatementText_Click(object? sender, RoutedEventArgs e)
     private async void CopyParameterizedStatementText_Click(object? sender, RoutedEventArgs e)
     {
         if (StatementsGrid.SelectedItem is not StatementRow row) return;
-        var text = row.Statement.StatementText;
+        var text = PlanOrCapturedStatementText(row.Statement);
         if (string.IsNullOrEmpty(text)) return;
 
         await ClipboardHelper.TrySetTextAsync(this, text);
@@ -237,13 +237,34 @@ private void OpenInEditor_Click(object? sender, RoutedEventArgs e)
     /// <summary>
     /// The statement text with the plan's parameter values put back, or the text as-is when the plan
     /// carries no values to put back.
+    /// </summary>
+    private string RunnableStatementText(PlanStatement statement) =>
+        ParameterSubstitution.Apply(PlanOrCapturedStatementText(statement), statement.Parameters).Text;
+
+    /// <summary>
+    /// The text to hand the user for a statement: the plan's copy normally, the text this plan was
+    /// captured from when the plan's copy has been truncated (#502).
+    ///
+    /// <para>This used to read the plan and nothing else, on the reasoning that the query editor's
+    /// buffer is only right when the user just executed from that tab. That reasoning still holds
+    /// for the buffer — but this is not the buffer. It is the text handed to <c>LoadPlan</c> at the
+    /// moment the plan was captured, which is null for a plan opened from a file and is the stored
+    /// query for one opened from Query Store. When it is there, it is the same query the plan
+    /// describes, minus SQL Server's 4,000-character cap.</para>
     ///
-    /// <para>The plan is the only source used. The query editor's buffer holds the original text in
-    /// exactly one case — the user just executed it from that tab — and is wrong for a plan opened
-    /// from a file, from Query Store, or from another session.</para>
+    /// <para>Single-statement plans only. The captured text is the whole batch, and showplan records
+    /// no statement offsets, so for a multi-statement batch there is no way to tell which slice of it
+    /// belongs to the row the user picked — and handing back a confidently wrong statement is worse
+    /// than handing back a short one. Rule 39 says so on the plan either way.</para>
     /// </summary>
-    private static string RunnableStatementText(PlanStatement statement) =>
-        ParameterSubstitution.Apply(statement.StatementText, statement.Parameters).Text;
+    private string PlanOrCapturedStatementText(PlanStatement statement) =>
+        statement.IsTextTruncated && !string.IsNullOrEmpty(_queryText) && IsSingleStatementPlan
+            ? _queryText!
+            : statement.StatementText;
+
+    /// <summary>True when the loaded plan holds exactly one statement across all of its batches.</summary>
+    private bool IsSingleStatementPlan =>
+        _currentPlan != null && _currentPlan.Batches.Sum(b => b.Statements.Count) == 1;
 
     private static void CollectNodeWarnings(PlanNode node, List<PlanWarning> warnings)
     {
 
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace PlanViewer.Core.Models;
@@ -31,7 +31,22 @@ public class PlanBatch
 
 public class PlanStatement
 {
+    /// <summary>
+    /// SQL Server caps StatementText at 4,000 characters when it writes showplan XML, so a
+    /// statement at or near that length is almost certainly missing its tail. The few characters
+    /// of margin absorb the trimming the server does around the boundary (#502).
+    /// </summary>
+    public const int TruncationLengthThreshold = 3990;
+
     public string StatementText { get; set; } = "";
+
+    /// <summary>
+    /// True when <see cref="StatementText"/> looks like it hit the showplan cap. The plan carries
+    /// no marker for this, so length is the only signal there is — and the consequence is not
+    /// cosmetic: a statement cut mid-token is not valid T-SQL, so anything that tries to re-run or
+    /// format it fails for reasons that look unrelated to the plan (#502).
+    /// </summary>
+    public bool IsTextTruncated => StatementText.Length >= TruncationLengthThreshold;
     public string StatementType { get; set; } = "";
     public double StatementSubTreeCost { get; set; }
     public double StatementEstRows { get; set; }
 
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -22,6 +22,33 @@ private static void AnalyzeStatement(PlanStatement stmt, AnalyzerConfig cfg, Ser
         Rule38_StandardEditionDop(stmt, cfg, serverMetadata);
         Rule30_MissingIndexQuality(stmt, cfg, serverMetadata);
         Rule22Stmt_TableVariable(stmt, cfg, serverMetadata);
+        Rule39_TruncatedStatementText(stmt, cfg, serverMetadata);
+    }
+
+    /// <summary>
+    /// Rule 39: the plan's copy of the query text hit SQL Server's showplan cap (#502).
+    ///
+    /// <para>Worth saying out loud rather than leaving the user to work it out. Everything
+    /// downstream of the plan reads this text — the advice on this screen, Copy Query Text, Open in
+    /// Query Editor — so all of them show a query that stops mid-statement, and re-running or
+    /// formatting that text fails with a syntax error that points nowhere near the real cause. The
+    /// full query is not in the plan at all; only the session that ran it still has it.</para>
+    /// </summary>
+    private static void Rule39_TruncatedStatementText(PlanStatement stmt, AnalyzerConfig cfg, ServerMetadata? serverMetadata)
+    {
+        if (cfg.IsRuleDisabled(39) || !stmt.IsTextTruncated)
+            return;
+
+        stmt.PlanWarnings.Add(new PlanWarning
+        {
+            WarningType = "Truncated Query Text",
+            Message =
+                "SQL Server truncated this query's text at 4,000 characters when it wrote the plan, "
+                + "so the query shown here stops early and is not valid T-SQL on its own. "
+                + "Advice, copied text, and Open in Query Editor are all working from the shortened "
+                + "version. Go back to the original query text to re-run or format it.",
+            Severity = PlanWarningSeverity.Info
+        });
     }
 
     private static void Rule03_SerialPlan(PlanStatement stmt, AnalyzerConfig cfg, ServerMetadata? serverMetadata)
@@ -105,7 +132,7 @@ private static void Rule03_SerialPlan(PlanStatement stmt, AnalyzerConfig cfg, Se
             {
                 var text = stmt.StatementText ?? "";
                 var hasMaxdop1InText = Regex.IsMatch(text, @"MAXDOP\s+1\b", RegexOptions.IgnoreCase);
-                var isTruncated = text.Length >= 3990;
+                var isTruncated = stmt.IsTextTruncated;
 
                 if (hasMaxdop1InText)
                 {
 
@@ -0,0 +1,187 @@
+using System;
+using System.IO;
+using System.Linq;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.LogicalTree;
+using PlanViewer.App.Controls;
+using PlanViewer.Core.Models;
+using PlanViewer.Core.Services;
+
+namespace PlanViewer.Core.Tests;
+
+/// <summary>
+/// #502: SQL Server caps StatementText at 4,000 characters when it writes showplan XML, so for a
+/// long query every consumer of the plan — advice, Copy Query Text, Open in Query Editor — was
+/// handing back a query that stops mid-statement. The reporter's symptom was the second-order one:
+/// the shortened text is not valid T-SQL, so re-running or formatting it failed with a syntax error
+/// that pointed nowhere near the truncation.
+///
+/// <para>Two halves. The plan says so (Rule 39), and where the full query was captured alongside the
+/// plan it is handed out instead of the plan's short copy.</para>
+/// </summary>
+public class TruncatedStatementTextTests
+{
+    private const string CapturedQuery = "SELECT 'the full query the session actually ran';";
+
+    // ---------------------------------------------------------------
+    // Rule 39: say so on the plan
+    // ---------------------------------------------------------------
+
+    [Fact]
+    public void Rule39_FlagsAStatementThatHitTheCap()
+    {
+        var plan = AnalyzeStatementOfLength(PlanStatement.TruncationLengthThreshold);
+
+        var warning = Assert.Single(PlanTestHelper.WarningsOfType(plan, "Truncated Query Text"));
+        Assert.Equal(PlanWarningSeverity.Info, warning.Severity);
+        Assert.Contains("4,000 characters", warning.Message);
+    }
+
+    [Fact]
+    public void Rule39_SaysNothingAboutAQueryThatFits()
+    {
+        var plan = AnalyzeStatementOfLength(PlanStatement.TruncationLengthThreshold - 1);
+
+        Assert.Empty(PlanTestHelper.WarningsOfType(plan, "Truncated Query Text"));
+    }
+
+    [Fact]
+    public void Rule39_CanBeTurnedOff()
+    {
+        var stmt = StatementOfLength(PlanStatement.TruncationLengthThreshold);
+        var plan = new ParsedPlan();
+        plan.Batches.Add(new PlanBatch { Statements = { stmt } });
+
+        PlanAnalyzer.Analyze(plan, new AnalyzerConfig { Rules = new RulesConfig { Disabled = { 39 } } });
+
+        Assert.Empty(PlanTestHelper.WarningsOfType(plan, "Truncated Query Text"));
+    }
+
+    // ---------------------------------------------------------------
+    // Hand back the captured query instead of the plan's short copy
+    // ---------------------------------------------------------------
+
+    [Fact]
+    public void SingleStatement_OpenInQueryEditor_HandsBackTheCapturedQuery()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var viewer = LoadPlan("isnull_plan.sqlplan", Truncated, CapturedQuery);
+
+            Assert.Equal(CapturedQuery, OpenInEditorText(viewer));
+        });
+    }
+
+    /// <summary>
+    /// A plan opened from a file has no captured text, and nothing can invent it — the short copy is
+    /// all there is. Rule 39 is what tells the user why.
+    /// </summary>
+    [Fact]
+    public void SingleStatement_WithNothingCaptured_StillHandsBackThePlanText()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var viewer = LoadPlan("isnull_plan.sqlplan", Truncated, queryText: null);
+
+            var text = OpenInEditorText(viewer);
+            Assert.NotEqual(CapturedQuery, text);
+            Assert.True(text!.Length >= PlanStatement.TruncationLengthThreshold);
+        });
+    }
+
+    /// <summary>
+    /// The captured text is the whole batch and showplan records no statement offsets, so for a
+    /// multi-statement plan there is no way to tell which slice belongs to the selected row. Handing
+    /// back a confidently wrong statement would be worse than handing back a short one.
+    /// </summary>
+    [Fact]
+    public void MultiStatement_KeepsThePlanTextEvenThoughItIsTruncated()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var viewer = LoadPlan("eager_table_spool_plan.sqlplan", Truncated, CapturedQuery);
+
+            Assert.NotEqual(CapturedQuery, OpenInEditorText(viewer));
+        });
+    }
+
+    [Fact]
+    public void UntruncatedPlan_IsUnaffectedByAnyOfThis()
+    {
+        HeadlessUi.Run(() =>
+        {
+            var viewer = LoadPlan("isnull_plan.sqlplan", xml => xml, CapturedQuery);
+
+            Assert.NotEqual(CapturedQuery, OpenInEditorText(viewer));
+        });
+    }
+
+    // ---------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------
+
+    private static PlanStatement StatementOfLength(int length) =>
+        new() { StatementText = new string('x', length), StatementType = "SELECT" };
+
+    private static ParsedPlan AnalyzeStatementOfLength(int length)
+    {
+        var plan = new ParsedPlan();
+        plan.Batches.Add(new PlanBatch { Statements = { StatementOfLength(length) } });
+        PlanAnalyzer.Analyze(plan);
+        return plan;
+    }
+
+    /// <summary>
+    /// Pads the plan's first recorded statement past the cap, so the fixture looks the way a real
+    /// capped plan looks. Letters and a space only — this goes back into an XML attribute.
+    /// </summary>
+    private static string Truncated(string xml)
+    {
+        const string marker = "StatementText=\"";
+        var start = xml.IndexOf(marker, StringComparison.Ordinal);
+        Assert.True(start >= 0, "fixture has no StatementText to pad");
+
+        var valueEnd = xml.IndexOf('"', start + marker.Length);
+        Assert.True(valueEnd > start, "fixture's StatementText is not terminated");
+
+        return xml[..valueEnd]
+            + " " + new string('x', PlanStatement.TruncationLengthThreshold)
+            + xml[valueEnd..];
+    }
+
+    private static PlanViewerControl LoadPlan(string planFileName, Func<string, string> shape, string? queryText)
+    {
+        var path = Path.Combine("Plans", planFileName);
+        Assert.True(File.Exists(path), $"Test plan not found: {path}");
+        var xml = shape(File.ReadAllText(path).Replace("encoding=\"utf-16\"", "encoding=\"utf-8\""));
+
+        var viewer = new PlanViewerControl();
+        Assert.True(viewer.LoadPlan(xml, planFileName, queryText), $"Plan failed to load: {viewer.LastLoadError}");
+
+        return viewer;
+    }
+
+    /// <summary>
+    /// Drives the menu entry the reporter used and returns the text it handed over. Goes through the
+    /// real right-click so the Opening event configures the menu first, the way #467 established.
+    /// </summary>
+    private static string? OpenInEditorText(PlanViewerControl viewer)
+    {
+        var window = new Window { Content = viewer, Width = 1400, Height = 900 };
+        window.Show();
+        window.UpdateLayout();
+
+        var grid = viewer.GetLogicalDescendants().OfType<DataGrid>().First(g => g.Name == "StatementsGrid");
+        grid.RaiseEvent(new ContextRequestedEventArgs());
+
+        string? opened = null;
+        viewer.OpenInEditorRequested += (_, text) => opened = text;
+
+        grid.ContextMenu!.Items.OfType<MenuItem>().First(i => i.Name == "OpenStatementInEditorItem")
+            .RaiseEvent(new RoutedEventArgs(MenuItem.ClickEvent));
+
+        return opened;
+    }
+}