diff --git a/Darling/Darling.Tests/DarlingMcpToolClassification.cs b/Darling/Darling.Tests/DarlingMcpToolClassification.cs
index 6da2438b77..c9ebb37335 100644
--- a/Darling/Darling.Tests/DarlingMcpToolClassification.cs
+++ b/Darling/Darling.Tests/DarlingMcpToolClassification.cs
@@ -50,7 +50,7 @@ internal static class DarlingMcpToolClassification
         "get_pg_replication_slots", "get_pg_replication_stats", "get_pg_server_config",
         "get_pg_server_config_changes", "get_pg_session_states", "get_pg_table_bloat", "get_pg_top_queries",
         "get_pg_wait_sampling", "get_pg_wait_stats", "get_pg_wait_trend", "get_pg_wraparound_risk",
-        "get_pg_write_stats", "get_pg_xmin_horizon", "get_plan_cache_bloat", "get_plan_corrections", "get_plan_xml",
+        "get_pg_write_stats", "get_pg_xmin_horizon", "get_plan_cache_bloat", "get_plan_corrections", "get_plan_force_precheck", "get_plan_xml",
         "get_procedure_duration_trend", "get_procedure_plan_xml", "get_pvs_stats", "get_query_duration_trend",
         "get_query_heatmap", "get_query_repro_script", "get_query_store_clutter", "get_query_store_duration_trend",
         "get_query_store_health", "get_query_store_plan_xml", "get_query_store_query_history",
diff --git a/Darling/Darling.Tests/McpPayloadContractCensusTests.cs b/Darling/Darling.Tests/McpPayloadContractCensusTests.cs
index e73bb5b84a..1771441f94 100644
--- a/Darling/Darling.Tests/McpPayloadContractCensusTests.cs
+++ b/Darling/Darling.Tests/McpPayloadContractCensusTests.cs
@@ -2039,6 +2039,8 @@ public static readonly (string Spelling, string File, string WhatItIs)[] Severit
             "audit_config's edition-NAME fallback (Enterprise / Standard / … / Unknown) — a name, spelled as the canon by coincidence"),
         ("Unknown", "McpAnalysisTools.cs",
             "audit_config's edition-NAME fallback — the Lite twin of the above"),
+        ("unknown", "DarlingMcpPlanForcePrecheckTools.cs",
+            "get_plan_force_precheck's unknown[] section name: the checks the store could not answer, listed beside refusals and never a refusal (#5632). A section name, not a band"),
         ("unknown", "DarlingMcpTools.cs",
             "mute_analysis_finding's kind (plain / read-only / per-database) for a resolved server that has no definition row in the store (one defined in darling.json) — a registration kind, not a band"),
         ("unknown", "DarlingMcpPgWaitSamplingTools.cs",
diff --git a/Darling/Darling.Tests/PlanForcePrecheckLiveTests.cs b/Darling/Darling.Tests/PlanForcePrecheckLiveTests.cs
new file mode 100644
index 0000000000..aa21e48b28
--- /dev/null
+++ b/Darling/Darling.Tests/PlanForcePrecheckLiveTests.cs
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Npgsql;
+using NpgsqlTypes;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Service.Mcp;
+using PerformanceMonitor.Darling.Storage;
+using Xunit;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// #5632 step A2: get_plan_force_precheck over seeded store rows. Each case plants one query's Query Store rows, its text and its
+/// stored plans, reads the tool, and asserts the verdict and the stable refusal codes. as_of is fixed so no clock decides the window.
+/// </summary>
+[Collection("live-postgres")]
+public sealed class PlanForcePrecheckLiveTests
+{
+    private const string ServerName = "darling-force-precheck";
+    private static readonly int ServerId = ServerIdHelper.GetDeterministicHashCode(ServerName);
+    private const string Db = "ForceDb";
+
+    private static readonly DateTime Anchor = DateTime.SpecifyKind(DarlingMcpTestData.TruncateToSeconds(DateTime.UtcNow).AddHours(-6), DateTimeKind.Unspecified);
+    private static readonly DateTime AsOf = Anchor.AddHours(1);
+
+    private static string? ConnectionString => Environment.GetEnvironmentVariable("DARLING_TEST_PG");
+
+    private static string Plan(string? value = null, string extra = "", string stmtAttrs = "", string? queryPlanAttrs = null) =>
+        "<ShowPlanXML xmlns=\"http://schemas.microsoft.com/sqlserver/2004/07/showplan\" Version=\"1.564\"><BatchSequence><Batch><Statements>"
+        + "<StmtSimple StatementText=\"SELECT 1\" StatementId=\"1\" StatementType=\"SELECT\"" + stmtAttrs + ">" + extra
+        + "<QueryPlan CachedPlanSize=\"16\"" + queryPlanAttrs + ">"
+        + (value is null ? "" : "<ParameterList><ColumnReference Column=\"@p\" ParameterDataType=\"int\" ParameterCompiledValue=\"" + value + "\" ParameterRuntimeValue=\"" + value + "\"/></ParameterList>")
+        + "</QueryPlan></StmtSimple></Statements></Batch></BatchSequence></ShowPlanXML>";
+
+    private sealed record Seed(long QueryId, string Text, (long PlanId, long Rows, long Execs, int LastExecMinutesBeforeAnchor, string Xml, bool Forced)[] Plans);
+
+    private static async Task<JsonDocument> RunAsync(Seed seed, Func<NpgsqlConnection, CancellationToken, Task>? extra = null, long? planId = null, long? compare = null)
+    {
+        var cs = ConnectionString;
+        Assert.SkipWhen(string.IsNullOrEmpty(cs), "Set DARLING_TEST_PG to a Postgres connection string to run the live pre-check test.");
+        var ct = TestContext.Current.CancellationToken;
+        await using var connection = new NpgsqlConnection(cs);
+        await connection.OpenAsync(ct);
+        await PgMigrations.MigrateAsync(connection, ct);
+        await DeleteAsync(connection, ct);
+        await using var postgres = NpgsqlDataSource.Create(cs!);
+        var ok = false;
+        try
+        {
+            await DarlingMcpTestData.RegisterServerAsync(connection, ServerId, ServerName, ct);
+            await Exec(connection, ct, "INSERT INTO collect.query_store_text (server_id, database_name, query_id, query_sql_text, last_seen) VALUES ($1,$2,$3,$4,$5)", ServerId, Db, seed.QueryId, seed.Text, Anchor);
+            foreach (var p in seed.Plans)
+            {
+                var last = Anchor.AddMinutes(-p.LastExecMinutesBeforeAnchor);
+                await Exec(connection, ct, @"INSERT INTO query_store_stats
+(collection_id, collection_time, server_id, server_name, database_name, query_id, plan_id, execution_type_desc, runtime_stats_interval_id,
+ interval_start_time_utc, first_execution_time, last_execution_time, execution_count, avg_cpu_time_us, avg_duration_us, avg_rowcount, is_forced_plan, force_failure_count)
+VALUES ($1,$2,$3,$4,$5,$6,$7,'Regular',$7,$8,$8,$9,$10,5000,7000,$11,$12,0)",
+                    CollectionIdGenerator.Next(), Anchor, ServerId, ServerName, Db, seed.QueryId, p.PlanId, last.AddHours(-1), last, p.Execs, p.Rows, p.Forced);
+                var stored = p.Xml + "<!-- plan " + p.PlanId.ToString(CultureInfo.InvariantCulture) + " -->";
+                var digest = PayloadDimensions.Digest(stored);
+                await using (var dim = new NpgsqlCommand("INSERT INTO query_plan_dim (digest, query_plan_xml, last_seen) VALUES ($1,$2,$3) ON CONFLICT DO NOTHING", connection))
+                {
+                    dim.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.Bytea, Value = digest });
+                    dim.Parameters.AddWithValue(stored);
+                    dim.Parameters.AddWithValue(NpgsqlDbType.Timestamp, Anchor);
+                    await dim.ExecuteNonQueryAsync(ct);
+                }
+
+                await using var map = new NpgsqlCommand("INSERT INTO collect.query_store_plan_map (server_id, database_name, plan_id, digest, plan_hash, last_seen) VALUES ($1,$2,$3,$4,$5,$6)", connection);
+                map.Parameters.AddWithValue(ServerId);
+                map.Parameters.AddWithValue(Db);
+                map.Parameters.AddWithValue(p.PlanId);
+                map.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.Bytea, Value = digest });
+                map.Parameters.AddWithValue("0x5632");
+                map.Parameters.AddWithValue(NpgsqlDbType.Timestamp, Anchor);
+                await map.ExecuteNonQueryAsync(ct);
+            }
+
+            if (extra is not null) await extra(connection, ct);
+            var json = await DarlingMcpPlanForcePrecheckTools.GetPlanForcePrecheck(
+                postgres, Db, seed.QueryId, planId ?? seed.Plans[0].PlanId, ServerName, compare, 24, AsOf.ToString("o", CultureInfo.InvariantCulture), cancellationToken: ct);
+            var doc = JsonDocument.Parse(json);
+            ok = true;
+            return doc;
+        }
+        finally
+        {
+            await LiveStoreCleanup.RunAsync(cs!, ok, async (c, t) => await DeleteAsync(c, t));
+        }
+    }
+
+    private static Task Exec(NpgsqlConnection c, CancellationToken ct, string sql, params object?[] values) =>
+        DarlingMcpTestData.ExecAsync(c, ct, sql, values.Select(v => v is DateTime d ? DateTime.SpecifyKind(d, DateTimeKind.Unspecified) : v).ToArray());
+
+    private static string[] Codes(JsonDocument d) =>
+        d.RootElement.GetProperty("refusals").EnumerateArray().Select(r => r.GetProperty("code").GetString()!).ToArray();
+
+    private static string[] UnknownChecks(JsonDocument d) =>
+        d.RootElement.GetProperty("unknown").EnumerateArray().Select(r => r.GetProperty("check").GetString()!).ToArray();
+
+    /* A clean query: two plans of about the same output, both well run, both recent, no hint, no temp table. The candidate is the cheap, older plan. */
+    private static Seed Clean(long q = 7001, string text = "SELECT * FROM dbo.widgets WHERE id = @p") =>
+        new(q, text, [(1, 100, 60, 30, Plan("1"), false), (2, 120, 60, 5, Plan("1"), false)]);
+
+    [Fact]
+    public async Task ACleanCandidate_HasNoRefusal_ButTheVerdictNeverSaysSafe()
+    {
+        using var doc = await RunAsync(Clean());
+        var codes = Codes(doc);
+        /* The store holds no force state, so the gate's state_unavailable is the one refusal; every check this read owns is quiet. */
+        Assert.DoesNotContain(codes, c => c is "recompile_hint" or "temp_table" or "not_run_recently" or "too_few_executions" or "psp_variant" or "output_differs" or "query_store_read_only");
+        Assert.Contains("query_store_read_only", UnknownChecks(doc));
+        Assert.DoesNotContain("safe", doc.RootElement.GetProperty("verdict").GetString(), StringComparison.OrdinalIgnoreCase);
+    }
+
+    [Fact]
+    public async Task Pattern1_AStatementWithOptionRecompile_IsRefused()
+    {
+        using var doc = await RunAsync(Clean(7002, "SELECT * FROM dbo.widgets WHERE id = @p OPTION (RECOMPILE)"));
+        Assert.Contains("recompile_hint", Codes(doc));
+        Assert.Equal("refuse", doc.RootElement.GetProperty("verdict").GetString());
+    }
+
+    [Fact]
+    public async Task Pattern2_PlansReturning26000AndFiftyRowsPerCall_AreRefusedAsOutputDiffers()
+    {
+        var seed = new Seed(7003, "SELECT 1", [(1, 50, 60, 30, Plan("1"), false), (2, 26_000, 60, 5, Plan("1"), false)]);
+        using var doc = await RunAsync(seed);
+        Assert.Contains("output_differs", Codes(doc));
+    }
+
+    [Fact]
+    public async Task ABlockerFromTheExistingGate_AppearsUnderItsOwnCode()
+    {
+        var seed = new Seed(7004, "SELECT 1", [(1, 100, 60, 30, Plan("1"), true), (2, 100, 60, 5, Plan("1"), false)]);
+        using var doc = await RunAsync(seed);
+        Assert.Contains("already_forced", Codes(doc));
+    }
+
+    [Fact]
+    public async Task ARunStoppedQuery_AndAThinPlan_AreRefused()
+    {
+        var seed = new Seed(7005, "SELECT 1", [(1, 100, 3, 300, Plan("1"), false), (2, 100, 60, 240, Plan("1"), false)]);
+        using var doc = await RunAsync(seed);
+        var codes = Codes(doc);
+        Assert.Contains("not_run_recently", codes);
+        Assert.Contains("too_few_executions", codes);
+    }
+
+    [Fact]
+    public async Task DifferentCompiledValues_AreShown_NeverRefused()
+    {
+        var seed = new Seed(7006, "SELECT 1", [(1, 100, 60, 30, Plan("111"), false), (2, 100, 60, 5, Plan("222"), false)]);
+        using var doc = await RunAsync(seed);
+        Assert.DoesNotContain(Codes(doc), c => c is "output_differs" or "recompile_hint" or "psp_variant");
+        var raw = doc.RootElement.GetRawText();
+        Assert.Contains("\"compiled_value\":\"111\"", raw, StringComparison.Ordinal);
+        Assert.Contains("\"compiled_value\":\"222\"", raw, StringComparison.Ordinal);
+        Assert.Equal(PerformanceMonitor.Common.McpDataDetailMasker.ReplacedValue,
+            System.Text.Json.Nodes.JsonNode.Parse(McpDataDetailMasker.MaskJson(raw, McpDataDetail.MaskLiterals))!["shown"]!["plans"]![0]!["compiled_values"]![0]!["compiled_value"]!.GetValue<string>());
+        var meta = McpDataDetailMasker.MaskJson(raw, McpDataDetail.MetadataOnly);
+        Assert.DoesNotContain("111", meta, StringComparison.Ordinal);
+        Assert.DoesNotContain("222", meta, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task ATempTable_AndAPspVariant_AreRefused_AndATableVariableIsNot()
+    {
+        var temp = Plan("1", "<RelOp NodeId=\"0\"><Object Database=\"[ForceDb]\" Schema=\"[dbo]\" Table=\"[#orders]\"/></RelOp>");
+        var tableVar = Plan("1", "<RelOp NodeId=\"0\"><Object Database=\"[ForceDb]\" Schema=\"[dbo]\" Table=\"[@orders]\"/></RelOp>");
+        using (var d1 = await RunAsync(new Seed(7007, "SELECT 1", [(1, 100, 60, 30, temp, false), (2, 100, 60, 5, Plan("1"), false)])))
+            Assert.Contains("temp_table", Codes(d1));
+        using (var d2 = await RunAsync(new Seed(7008, "SELECT 1", [(1, 100, 60, 30, tableVar, false), (2, 100, 60, 5, Plan("1"), false)])))
+            Assert.DoesNotContain("temp_table", Codes(d2));
+        using var d3 = await RunAsync(new Seed(7009, "SELECT 1", [(1, 100, 60, 30, Plan("1", queryPlanAttrs: " QueryVariantID=\"2\""), false), (2, 100, 60, 5, Plan("1"), false)]));
+        Assert.Contains("psp_variant", Codes(d3));
+        Assert.Contains("psp_variant_siblings", UnknownChecks(d3));
+    }
+
+    [Fact]
+    public async Task AReadOnlyQueryStore_IsRefused_AndNoHealthRowIsUnknown()
+    {
+        using var ro = await RunAsync(Clean(7010), async (c, ct) => await Exec(c, ct,
+            @"INSERT INTO collect.query_store_health (config_id, capture_time, server_id, server_name, database_name, actual_state, desired_state, readonly_reason)
+              VALUES ($1,$2,$3,$4,$5,'READ_ONLY','READ_WRITE',65536)", CollectionIdGenerator.Next(), Anchor, ServerId, ServerName, Db));
+        Assert.Contains("query_store_read_only", Codes(ro));
+        using var none = await RunAsync(Clean(7011));
+        Assert.DoesNotContain("query_store_read_only", Codes(none));
+        Assert.Contains("query_store_read_only", UnknownChecks(none));
+    }
+
+    private static async Task DeleteAsync(NpgsqlConnection c, CancellationToken ct)
+    {
+        foreach (var table in new[] { "query_store_stats", "collect.query_store_text", "collect.query_store_health", "collect.query_store_plan_map" })
+            await Exec(c, ct, "DELETE FROM " + table + " WHERE server_id = $1", ServerId);
+        await Exec(c, ct, "DELETE FROM query_plan_dim WHERE last_seen = $1 AND query_plan_xml LIKE '%<!-- plan %'", Anchor);
+        await Exec(c, ct, "DELETE FROM servers WHERE server_id = $1", ServerId);
+    }
+}
diff --git a/Darling/Darling.Tests/WebDatabaseFilterBehaviourTests.cs b/Darling/Darling.Tests/WebDatabaseFilterBehaviourTests.cs
index bfe80d384b..482a501566 100644
--- a/Darling/Darling.Tests/WebDatabaseFilterBehaviourTests.cs
+++ b/Darling/Darling.Tests/WebDatabaseFilterBehaviourTests.cs
@@ -261,6 +261,7 @@ public void TheRuntimeCensus_WithEveryDatabaseScopedReadFiltered_GivesEachOneAll
         Assert.Equal(3, scopes.GetProperty("UNFILTERED").GetInt32());
         /* Six since #5300: the Query Store History panel's read is one query's own rows, keyed by its database and query_id. */
         /* Nine since the Blocking and Deadlocks plan reads (#5236) and the repro script (#5233) joined the plan viewer: each names one stored row. */
-        Assert.Equal(9, scopes.GetProperty("IDENTITY").GetInt32());
+        /* Ten since #5632: the force pre-check reads one query's plans, keyed by its database and query_id. */
+        Assert.Equal(10, scopes.GetProperty("IDENTITY").GetInt32());
     }
 }
diff --git a/Darling/Darling.Tests/WebDatabaseFilterReadsTests.cs b/Darling/Darling.Tests/WebDatabaseFilterReadsTests.cs
index ab85d28aea..e4fd281c68 100644
--- a/Darling/Darling.Tests/WebDatabaseFilterReadsTests.cs
+++ b/Darling/Darling.Tests/WebDatabaseFilterReadsTests.cs
@@ -243,11 +243,11 @@ public void EveryClassedRead_IsInTheReadCatalog()
     /// together; moving a read from one to the other keeps the total), and FILTERED is a subset of what the plan filters: none of
     /// the three deadlock reads.</summary>
     [Fact]
-    public void TheIdentityReads_AreTheNineRowIdentityReads_AndTheDatabaseScopedReadsAreThirtyFour()
+    public void TheIdentityReads_AreTheTenRowIdentityReads_AndTheDatabaseScopedReadsAreThirtyFour()
     {
         var classes = Classes();
         Assert.Equal(
-            Sorted(new[] { "get_query_trend", "get_plan_xml", "get_query_store_plan_xml", "get_active_query_plan_xml", "get_procedure_plan_xml", "get_query_store_query_history", "get_blocking_plan_xml", "get_deadlock_plan_xml", "get_query_repro_script" }),
+            Sorted(new[] { "get_query_trend", "get_plan_xml", "get_query_store_plan_xml", "get_active_query_plan_xml", "get_procedure_plan_xml", "get_query_store_query_history", "get_plan_force_precheck", "get_blocking_plan_xml", "get_deadlock_plan_xml", "get_query_repro_script" }),
             Sorted(classes["IDENTITY"]));
         Assert.Equal(34, classes["FILTERED"].Length + classes["UNFILTERED"].Length);
         Assert.DoesNotContain(classes["FILTERED"], read => read is "get_deadlock_trend" or "get_deadlocks" or "get_deadlock_detail");
diff --git a/Darling/Darling.Tests/WebReadCancellationPinTests.cs b/Darling/Darling.Tests/WebReadCancellationPinTests.cs
index bb11534fc9..83aa6fcc48 100644
--- a/Darling/Darling.Tests/WebReadCancellationPinTests.cs
+++ b/Darling/Darling.Tests/WebReadCancellationPinTests.cs
@@ -54,14 +54,14 @@ private static NpgsqlDataSource DeadStore() =>
     /// <summary>
     /// An <see cref="HttpContext"/> whose request is already aborted, carrying query values for the few
     /// required text parameters (<c>get_query_trend</c>'s <c>query_hash</c> / <c>database_name</c>, and
-    /// <c>get_wait_trend</c>'s <c>wait_type</c>, <c>get_alert_details</c>'s alert key) so a dispatch entry with a synchronous "is this parameter
+    /// <c>get_wait_trend</c>'s <c>wait_type</c>, <c>get_alert_details</c>'s alert key, <c>get_plan_force_precheck</c>'s <c>plan_id</c>) so a dispatch entry with a synchronous "is this parameter
     /// present" gate still reaches its store call instead of returning a missing-parameter envelope with
     /// nothing cancelled.
     /// </summary>
     private static HttpContext CancelledRequest()
     {
         var context = new DefaultHttpContext();
-        context.Request.QueryString = new QueryString("?kind=query_hash&query_hash=deadbeef&database_name=probe&counter_name=x&wait_type=CXPACKET&metric=total_waits&query_id=1&sql_handle=0x01&collection_time=2026-01-01T00:00:00.000000Z&session_id=1&event_time=2026-01-01T00:00:00.000000Z&blocked_spid=1&blocking_spid=2&deadlock_time=2026-01-01T00:00:00.000000Z&server_id=1&metric_name=x&alert_time=2026-01-01T00:00:00Z");
+        context.Request.QueryString = new QueryString("?kind=query_hash&query_hash=deadbeef&database_name=probe&counter_name=x&wait_type=CXPACKET&metric=total_waits&query_id=1&plan_id=1&sql_handle=0x01&collection_time=2026-01-01T00:00:00.000000Z&session_id=1&event_time=2026-01-01T00:00:00.000000Z&blocked_spid=1&blocking_spid=2&deadlock_time=2026-01-01T00:00:00.000000Z&server_id=1&metric_name=x&alert_time=2026-01-01T00:00:00Z");
         context.RequestAborted = new CancellationToken(canceled: true);
         return context;
     }
diff --git a/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs b/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
index 935c212ce0..de728e0cfa 100644
--- a/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
@@ -6548,6 +6548,7 @@ fetched when its Analysis row is first expanded. The key is the page's own row i
             ["get_query_store_clutter"] = R(CatData, "The Query Store CLUTTER view: per database the collector's read cost (how often and by how much it was the slowest fan-out item), plan churn (plans per query, arrivals per day, one-shot plans) and the options row, each with raw numbers and a decomposed verdict; ONE per-server overhead block (non-sleep QDS_* wait deltas with the excluded sleep waits named, and the Query Store memory clerk). Replicas excluded by architecture with the reason on the row; query_capture_mode (ALL / AUTO / CUSTOM / NONE) carried with capture_mode_known beside it, null meaning a capture older than the V137 rung rather than NONE. window_truncated says the raw tier did not hold the whole window. Composed from collected rows - no new query against the server.", PServer(), PHours(24), PLimit(DarlingMcpQueryStoreClutterTools.DefaultLimit), PBool("include_fleet_median", false), PAsOf(), PDatabases()),
             ["get_resource_use_by_tag"] = R(CatData, "Resource use rolled up by query tag, one section per source (plan cache, Query Store, procedures, blocking, deadlocks); sections are never summed. Omit the server for the fleet.", PServer(), PHours(24), PText("tag"), PLimit(DarlingMcpQueryTagRollupTools.DefaultLimit), PAsOf()),
             ["get_query_store_query_history"] = R(CatData, "One Query Store query's executions, duration and CPU per plan over the window (requires database_name, query_id).", PReqText("database_name"), PReqInt("query_id"), PServer(), PHours(24), PAsOf()),
+            ["get_plan_force_precheck"] = R(CatData, "Checks one Query Store plan before anyone forces it: verdict refuse or no_refusal_found (never safe), the refusals with stable codes, what a person should read first, and the checks the store could not answer (requires database_name, query_id, plan_id; compare_plan_id optional).", PReqText("database_name"), PReqInt("query_id"), PReqInt("plan_id"), PInt("compare_plan_id"), PServer(), PHours(24), PAsOf()),
             ["get_query_store_top"] = R(CatData, "Top Query Store queries in the window, optionally filtered by execution outcome or to one exact module before ranking; window_truncated says the raw tier did not hold the whole window (effective_hours_back how far it reached).", PServer(), PHours(24), PTop(20), PDatabases(), PAsOf(), PText("execution_type"), PText("module_name"), PBool("full_text", false), PText("tag")),
             ["get_long_query_completions"] = R(CatData, "Completed long-running queries captured by the XE trace.", PServer(), PHours(24), PLimit(30), PAsOf(), PDatabases(), PText("tag")),
             ["get_server_properties"] = R(CatData, "Server properties/inventory for a server.", PServer()),
@@ -7550,6 +7551,14 @@ budget cut does not silently shrink what the viewer renders. */
                 : !OptionalLong(c, "query_id", out var qshQueryId) ? UnparseableParam("query_id")
                 : qshQueryId is null ? MissingParam("query_id")
                 : DarlingMcpQueryStoreHistoryTools.GetQueryStoreQueryHistory(pg, qshDatabase, qshQueryId.Value, Server(c), Hours(c, 24), AsOf(c), c.RequestAborted),
+            ["get_plan_force_precheck"] = (c, pg, an) => !RequireText(c, "database_name", out var pfDatabase)
+                ? MissingParam("database_name")
+                : !OptionalLong(c, "query_id", out var pfQueryId) ? UnparseableParam("query_id")
+                : pfQueryId is null ? MissingParam("query_id")
+                : !OptionalLong(c, "plan_id", out var pfPlanId) ? UnparseableParam("plan_id")
+                : pfPlanId is null ? MissingParam("plan_id")
+                : !OptionalLong(c, "compare_plan_id", out var pfCompareId) ? UnparseableParam("compare_plan_id")
+                : DarlingMcpPlanForcePrecheckTools.GetPlanForcePrecheck(pg, pfDatabase, pfQueryId.Value, pfPlanId.Value, Server(c), pfCompareId, Hours(c, 24), AsOf(c), logger, c.RequestAborted),
             ["get_query_store_top"] = (c, pg, an) => DatabaseNames(c) is { } databases
                 ? DarlingMcpDataTools.GetQueryStoreTop(pg, Server(c), Hours(c, 24), Rows(c, "top", 20), databases, as_of: AsOf(c), execution_type: Str(c, "execution_type"), module_name: Str(c, "module_name"), full_text: QueryBool(c, "full_text", false), previewLength: 2000, cancellationToken: c.RequestAborted, tag: Str(c, "tag"))
                 : DatabaseNamesRefusal(c),
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpHostService.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpHostService.cs
index 654649837b..003f28ff9a 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpHostService.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpHostService.cs
@@ -1285,6 +1285,8 @@ the subset Gemini/Antigravity accepts — collapsing nullable type unions and
             .WithGeminiCompatibleTools<DarlingMcpPlanTools>()
             /* #5234: get_query_store_query_history, the per-plan history behind the web Query Store grid's History button. */
             .WithGeminiCompatibleTools<DarlingMcpQueryStoreHistoryTools>()
+            /* #5632 step A2: get_plan_force_precheck, the read that checks a Query Store plan before anyone forces it. */
+            .WithGeminiCompatibleTools<DarlingMcpPlanForcePrecheckTools>()
             /* #5983: get_resource_use_by_tag, resource use rolled up by query tag (wave 2 of #5971). */
             .WithGeminiCompatibleTools<DarlingMcpQueryTagRollupTools>()
             /* The core data-read tools (resource metrics, query performance, discovery/health —
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpInstructions.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpInstructions.cs
index da8f2cc31e..648eb28096 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpInstructions.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpInstructions.cs
@@ -142,7 +142,7 @@ writes arm "on". */
     /// are identical, so a new tool moves this or fails there.
     /// </summary>
     private const string CatalogCensus =
-        "This server exposes 205 tools. 107 are the same names Lite exposes. The remaining 98 are unique to Darling: " +
+        "This server exposes 206 tools. 107 are the same names Lite exposes. The remaining 99 are unique to Darling: " +
         "thirty-five are the PostgreSQL reads (`get_pg_*`), plus Custom Views, custom-alert-rule, alert-tuning, server/query-tag, " +
         "onboarding and investigation-wait tools, and central-store-only reads (`get_fleet_overview`, `get_ag_health` — Availability Groups — " +
         "`get_sweep_reports`, `get_store_metrics`, `get_store_log`). `get_blocking` = Lite's `get_blocked_process_reports`.";
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPlanForcePrecheckTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPlanForcePrecheckTools.cs
new file mode 100644
index 0000000000..20bee4234f
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPlanForcePrecheckTools.cs
@@ -0,0 +1,558 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Server;
+using Npgsql;
+using PerformanceMonitor.Analysis;
+using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Analysis;
+using PerformanceMonitor.Darling.Storage;
+using PerformanceMonitor.PlanAnalysis;
+
+#pragma warning disable CA1707 // MCP tools use snake_case naming convention
+
+namespace PerformanceMonitor.Darling.Service.Mcp;
+
+/// <summary>
+/// #5632 step A2: <c>get_plan_force_precheck</c>, a store-only read that answers "may this Query Store plan be forced, and what
+/// should a person see first". It writes nothing and never connects to the monitored server. Nothing calls it automatically yet.
+/// <para><b>The verdict is one-sided.</b> <c>refuse</c> when any check fires, else <c>no_refusal_found</c>. The read never says a force
+/// is safe or will help. A check the store cannot answer is listed in <c>unknown</c> and is not a refusal; the one exception is the
+/// gate's own <c>state_unavailable</c>, which the gate treats as a blocker.</para>
+/// <para><b>Reads.</b> The query's per-plan history from the grid's own tier (<see cref="DarlingMcpQueryStoreHistoryTools"/>'s helpers),
+/// the force gate (<see cref="ForcePlanBotPolicy.Blockers"/> over <see cref="DarlingForcePlanTargetStateReader"/>), the two stored
+/// plans, the statement text, the newest <c>query_store_health</c> row, the newest <c>index_object_stats</c> capture and the
+/// <c>job_history</c> names. Compiled parameter values are customer values: they ride under <c>compiled_value</c>, which
+/// <c>mcp.dataDetail</c> masks or withholds, and are never logged and never put in a refusal.</para>
+/// </summary>
+[McpServerToolType]
+public sealed class DarlingMcpPlanForcePrecheckTools
+{
+    /// <summary>Stable refusal codes (a consumer API: add freely, never respell). The gate's own blockers keep their own names.</summary>
+    internal const string CodeRecompileHint = "recompile_hint";
+    internal const string CodeTempTable = "temp_table";
+    internal const string CodeQueryStoreReadOnly = "query_store_read_only";
+    internal const string CodeNotRunRecently = "not_run_recently";
+    internal const string CodeTooFewExecutions = "too_few_executions";
+    internal const string CodePspVariant = "psp_variant";
+    internal const string CodeOutputDiffers = "output_differs";
+
+    /// <summary>A query whose newest execution, over any plan, is older than this before <c>as_of</c> has stopped running: a force there has nothing to act on.</summary>
+    internal static readonly TimeSpan NotRunRecentlyAfter = TimeSpan.FromHours(2);
+
+    /// <summary>
+    /// The per-plan execution floor: the same 25 PLAN_REGRESSION's per-plan group keeps (<c>HAVING SUM(execs) &gt;= 25</c> in
+    /// <c>PgFactCollector.QueryPerf</c>) and the force bot's review floor, taken from the bot's setting so there is one number.
+    /// </summary>
+    internal static readonly int MinPlanExecutions = ForcePlanBotSettings.Default.MinReviewExecutions;
+
+    /// <summary>Most rows each of the shown lists carries.</summary>
+    internal const int MaxListed = 20;
+
+    /// <summary>How far back, before <c>as_of</c>, a job run is read for a forcing-named job or step.</summary>
+    internal const int JobLookbackDays = 30;
+
+    private static readonly string s_planColumns = """
+        plan_id, collection_time, execution_count,
+        CAST(avg_duration_us AS double precision), CAST(avg_cpu_time_us AS double precision), CAST(avg_rowcount AS double precision),
+        last_execution_time, is_forced_plan, force_failure_count, last_force_failure_reason, plan_forcing_type
+        """;
+
+    /// <summary>The raw tier: the history tool's own dedupe (#1841), then the columns this read folds.</summary>
+    internal static readonly string RawPlanRowsSql =
+        DarlingMcpQueryStoreHistoryTools.HistoryDedupeCte + "\n" + "SELECT " + s_planColumns + "\nFROM deduped WHERE rn = 1 "
+        + DarlingMcpQueryStoreHistoryTools.HistoryOrder;
+
+    /// <summary>The interval table: the history tool's own FROM and WHERE (one row per interval identity, #5300).</summary>
+    internal static readonly string TablePlanRowsSql =
+        "SELECT " + s_planColumns + "\n" + DarlingMcpQueryStoreHistoryTools.HistoryTableFromWhere + " " + DarlingMcpQueryStoreHistoryTools.HistoryOrder;
+
+    /// <summary>$1 server, $2 database, $3 query, $4 window start, $5 window end. The statement text, the text dimension first and the newest inline text second, as the grid resolves it.</summary>
+    internal const string QueryTextSql = """
+        SELECT COALESCE(
+            (SELECT x.query_sql_text FROM query_store_text AS x WHERE x.server_id = $1 AND x.database_name = $2 AND x.query_id = $3),
+            (SELECT s.query_text FROM query_store_stats AS s
+              WHERE s.server_id = $1 AND s.database_name = $2 AND s.query_id = $3
+              AND s.collection_time >= $4 AND s.collection_time <= $5 AND s.query_text IS NOT NULL
+              ORDER BY s.collection_time DESC, s.collection_id DESC LIMIT 1))
+        """;
+
+    /// <summary>$1 server, $2 database, $3 as_of. The newest health row for the database at or before as_of.</summary>
+    internal const string HealthSql = """
+        SELECT actual_state, desired_state, readonly_reason, capture_time
+        FROM v_query_store_health
+        WHERE server_id = $1 AND database_name = $2 AND capture_time <= $3
+        ORDER BY capture_time DESC
+        LIMIT 1
+        """;
+
+    /// <summary>$1 server, $2 database, $3 as_of. Every index the database's newest capture at or before as_of lists, by table.</summary>
+    internal const string IndexCaptureSql = """
+        SELECT schema_name, table_name, index_name, collection_time
+        FROM v_index_object_stats
+        WHERE server_id = $1 AND database_name = $2
+        AND collection_time = (SELECT MAX(collection_time) FROM v_index_object_stats WHERE server_id = $1 AND database_name = $2 AND collection_time <= $3)
+        """;
+
+    /// <summary>$1 server, $2 window floor, $3 as_of. Job and step names that mention forcing, as a word.</summary>
+    internal const string JobNamesSql = """
+        SELECT DISTINCT job_name, step_name
+        FROM job_history
+        WHERE server_id = $1 AND collection_time >= $2 AND collection_time <= $3
+        AND (job_name ~* '\mforc(e|es|ed|ing)\M' OR step_name ~* '\mforc(e|es|ed|ing)\M')
+        ORDER BY job_name, step_name
+        LIMIT 20
+        """;
+
+    internal sealed record PlanRow(
+        long PlanId, DateTime CollectionTime, long Executions, double? DurationUs, double? CpuUs, double? Rows,
+        DateTime? LastExecution, bool IsForced, long? FailureCount, string? FailureReason, string? ForcingType);
+
+    internal sealed record PlanFold(
+        long PlanId, long Executions, double? CpuPerExecMs, double? DurationPerExecMs, double? AvgRows, DateTime? LastExecution,
+        bool IsForced, long? FailureCount, string? FailureReason, string? ForcingType);
+
+    internal sealed record Refusal(string Code, string Sentence, object? Evidence);
+
+    internal sealed record Unknown(string Check, string Reason);
+
+    private static async Task<List<PlanRow>> ReadPlanRowsAsync(NpgsqlDataReader reader, CancellationToken cancellationToken)
+    {
+        var rows = new List<PlanRow>();
+        while (await reader.ReadAsync(cancellationToken))
+        {
+            rows.Add(new PlanRow(
+                reader.GetInt64(0), reader.GetDateTime(1), reader.IsDBNull(2) ? 0 : reader.GetInt64(2),
+                reader.IsDBNull(3) ? null : reader.GetDouble(3), reader.IsDBNull(4) ? null : reader.GetDouble(4),
+                reader.IsDBNull(5) ? null : reader.GetDouble(5), reader.IsDBNull(6) ? null : reader.GetDateTime(6),
+                !reader.IsDBNull(7) && reader.GetBoolean(7), reader.IsDBNull(8) ? null : reader.GetInt64(8),
+                reader.IsDBNull(9) ? null : reader.GetString(9), reader.IsDBNull(10) ? null : reader.GetString(10)));
+        }
+
+        return rows;
+    }
+
+    /// <summary>
+    /// One line per plan, execution-weighted as <see cref="DarlingMcpQueryStoreHistoryTools.FoldPlans"/> folds a plan. Rows per call is
+    /// null when any snapshot of the plan has no <c>avg_rowcount</c>: a missing count never reads as a small one (#5631). The forcing
+    /// facts come from the plan's newest snapshot; the failure count is the largest seen.
+    /// </summary>
+    internal static List<PlanFold> Fold(IEnumerable<PlanRow> rows) =>
+        rows.GroupBy(r => r.PlanId).OrderBy(g => g.Key).Select(g =>
+        {
+            var members = g.ToList();
+            var execs = members.Sum(r => r.Executions);
+            var newest = members.OrderByDescending(r => r.CollectionTime).First();
+            return new PlanFold(
+                g.Key, execs,
+                execs > 0 ? members.Sum(r => r.Executions * (r.CpuUs ?? 0)) / execs / 1000.0 : null,
+                execs > 0 ? members.Sum(r => r.Executions * (r.DurationUs ?? 0)) / execs / 1000.0 : null,
+                execs > 0 && members.All(r => r.Rows is not null) ? members.Sum(r => r.Executions * r.Rows!.Value) / execs : null,
+                members.Max(r => r.LastExecution), newest.IsForced, members.Max(r => r.FailureCount),
+                members.OrderByDescending(r => r.CollectionTime).Select(r => r.FailureReason).FirstOrDefault(s => !string.IsNullOrEmpty(s)),
+                newest.ForcingType);
+        }).ToList();
+
+    /// <summary>True when the plan's rows per call differ by <see cref="PlanInputComparison.OutputGrowthRatio"/> or more, either way, each floored at <see cref="PlanInputComparison.RowFloor"/>.</summary>
+    internal static bool OutputDiffers(double candidateRows, double compareRows)
+    {
+        var a = Math.Max(candidateRows, PlanInputComparison.RowFloor);
+        var b = Math.Max(compareRows, PlanInputComparison.RowFloor);
+        return a >= PlanInputComparison.OutputGrowthRatio * b || b >= PlanInputComparison.OutputGrowthRatio * a;
+    }
+
+    /// <summary>What a stored plan says about the checks that read it. Null members mean the plan could not be read.</summary>
+    internal sealed record PlanFacts(IReadOnlyList<string> TempTables, bool IsPspVariant, string? PspBasis, IReadOnlyList<(string Schema, string Table, string Index)> Indexes);
+
+    /// <summary>Reads the three plan checks from one plan's XML. Null for a missing, withheld or unparseable plan.</summary>
+    internal static PlanFacts? ReadPlanFacts(string? planXml, string database)
+    {
+        if (string.IsNullOrWhiteSpace(planXml) || SensitiveStatements.IsWithheldPlan(planXml)) return null;
+        try
+        {
+            var doc = XDocument.Parse(planXml, LoadOptions.None);
+            var temps = new SortedSet<string>(StringComparer.Ordinal);
+            var indexes = new List<(string, string, string)>();
+            foreach (var o in doc.Descendants().Where(e => e.Name.LocalName == "Object"))
+            {
+                var table = o.Attribute("Table")?.Value;
+                if (string.IsNullOrEmpty(table)) continue;
+                if (table.StartsWith("[#", StringComparison.Ordinal)) { temps.Add(table); continue; }
+                if (table.StartsWith("[@", StringComparison.Ordinal)) continue;
+                var index = o.Attribute("Index")?.Value;
+                var db = o.Attribute("Database")?.Value;
+                if (string.IsNullOrEmpty(index) || (db is not null && !string.Equals(Unbracket(db), database, StringComparison.OrdinalIgnoreCase))) continue;
+                indexes.Add((Unbracket(o.Attribute("Schema")?.Value), Unbracket(table), Unbracket(index)));
+            }
+
+            var parsed = ShowPlanParser.Parse(planXml);
+            var statements = PlanStatements.EnumerateAll(parsed).ToList();
+            var variant = statements.FirstOrDefault(s => s.QueryVariantID > 0);
+            var basis = variant is not null ? $"QueryVariantID {variant.QueryVariantID}" : statements.Any(s => s.Dispatcher is not null) ? "Dispatcher element" : null;
+            return new PlanFacts(temps.ToList(), basis is not null, basis, indexes.Distinct().ToList());
+        }
+        catch (Exception ex) when (ex is System.Xml.XmlException or InvalidOperationException)
+        {
+            return null;
+        }
+    }
+
+    private static string Unbracket(string? name) => (name ?? "").Trim().TrimStart('[').TrimEnd(']');
+
+    [McpServerTool(Name = "get_plan_force_precheck"), Description(
+        "Checks one Query Store plan before anyone forces it: verdict refuse (any refusal fired) or no_refusal_found, which never means the force is safe or will help. " +
+        "refusals each carry a stable code, one sentence and evidence numbers; shown holds what a person reads first; unknown lists checks the store could not answer, which are not refusals. <<GUIDE>> " +
+        "Store-only and read-only. Refusal codes: the force gate's own blockers by name (parameter_sensitivity_cofired, secondary_replica_evidence, apc_owns_it, already_forced, forcing_failed_on_this_plan, apc_withdrew_it, apc_resolved_differently, " +
+        "state_unavailable, apc_enabled_for_database, apc_names_this_plan_as_regressed), recompile_hint (OPTION RECOMPILE), temp_table (the plan names a #temp table; a @table variable does not count), query_store_read_only (newest health row not READ_WRITE), " +
+        "not_run_recently (no execution of any plan in the 2 hours before as_of), too_few_executions (the plan ran under 25 times in the window), psp_variant (either plan is a Parameter Sensitive Plan variant) and output_differs (rows per call differ 10x or more between the two plans). " +
+        "compare_plan_id defaults to the query's plan with the newest last_execution_time; when that is plan_id itself the plan-to-plan checks go to unknown. " +
+        "Different compiled parameter values are shown (compiled_values, masked or withheld by mcp.dataDetail) with PlanInputComparison's judgement and are never a refusal. " +
+        "Indexes the plan names that are not in the table's newest index_object_stats capture are 'not in the latest capture': the capture may not list every index. Agent jobs whose job or step name mentions forcing are a name match only; the store holds no job step command.")]
+    public static async Task<string> GetPlanForcePrecheck(
+        NpgsqlDataSource postgres,
+        [Description("The database_name from get_query_store_top.")] string database_name,
+        [Description("The query_id from get_query_store_top.")] long query_id,
+        [Description("The plan_id someone wants to force.")] long plan_id,
+        [Description("Server name or display name.")] string? server_name = null,
+        [Description("Plan to compare it with. Default: the query's plan with the newest last_execution_time.")] long? compare_plan_id = null,
+        [Description("Hours of history ending at as_of (default 24).")] int hours_back = 24,
+        [Description(McpHelpers.AsOfDescription)] string? as_of = null,
+        ILogger? logger = null,
+        CancellationToken cancellationToken = default)
+    {
+        var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
+        if (error != null) return error;
+
+        var validation = DarlingReadWindow.Validate(hours_back, as_of, out var windowEnd);
+        if (validation != null) return validation;
+        var start = windowEnd.AddHours(-hours_back);
+
+        try
+        {
+            var table = await DarlingMcpQueryStoreHistoryTools.TryReadFromTableAsync(
+                postgres, resolved.ServerId, database_name, query_id, start, windowEnd, TablePlanRowsSql, ReadPlanRowsAsync, cancellationToken);
+            List<PlanRow> rows;
+            DateTime effectiveStart;
+            if (table is { } served)
+            {
+                rows = served.Rows;
+                effectiveStart = served.Plan.ReadStart;
+            }
+            else
+            {
+                await using var command = postgres.CreateCommand(RawPlanRowsSql);
+                command.CommandTimeout = McpCommandDeadlines.ReadSeconds;
+                command.Parameters.AddWithValue(resolved.ServerId);
+                command.Parameters.AddWithValue(database_name);
+                command.Parameters.AddWithValue(query_id);
+                command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(start, DateTimeKind.Unspecified));
+                command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(windowEnd, DateTimeKind.Unspecified));
+                await using var reader = await command.ExecuteReaderAsync(cancellationToken);
+                rows = await ReadPlanRowsAsync(reader, cancellationToken);
+                ReadScope.NoteSource(ReadScope.SourceRaw);
+                effectiveStart = start;
+            }
+
+            if (rows.Count == 0)
+                return await DarlingEngineCapability.NotCollectedStatusAsync(postgres, resolved.ServerId, resolved.ServerName, "query_store", cancellationToken)
+                    ?? McpHelpers.Status("empty",
+                        $"No Query Store history for query_id {query_id} in database '{database_name}' in the {hours_back}-hour window searched, so there is nothing to check.");
+
+            var plans = Fold(rows);
+            var candidate = plans.FirstOrDefault(p => p.PlanId == plan_id);
+            if (candidate is null)
+                return McpHelpers.Status("empty",
+                    $"plan_id {plan_id} has no Query Store history for query_id {query_id} in database '{database_name}' in the {hours_back}-hour window searched, so it cannot be checked.");
+
+            PlanFold? compare;
+            if (compare_plan_id is long wanted)
+            {
+                compare = plans.FirstOrDefault(p => p.PlanId == wanted);
+                if (compare is null)
+                    return McpHelpers.Status("empty", $"compare_plan_id {wanted} has no Query Store history for query_id {query_id} in the window searched.");
+            }
+            else
+            {
+                var newest = plans.OrderByDescending(p => p.LastExecution ?? DateTime.MinValue).ThenByDescending(p => p.PlanId).First();
+                compare = newest.PlanId == plan_id ? null : newest;
+            }
+
+            var queryLastExecution = plans.Max(p => p.LastExecution);
+            var refusals = new List<Refusal>();
+            var unknown = new List<Unknown>();
+            var shown = new Dictionary<string, object?>();
+
+            /* 1. The existing gate. */
+            await AddGateRefusalsAsync(postgres, resolved.ServerId, database_name, query_id, candidate, windowEnd, logger, refusals, unknown, cancellationToken);
+
+            /* 2. recompile_hint. */
+            string? text;
+            await using (var textCommand = postgres.CreateCommand(QueryTextSql))
+            {
+                textCommand.CommandTimeout = McpCommandDeadlines.ReadSeconds;
+                textCommand.Parameters.AddWithValue(resolved.ServerId);
+                textCommand.Parameters.AddWithValue(database_name);
+                textCommand.Parameters.AddWithValue(query_id);
+                textCommand.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(start, DateTimeKind.Unspecified));
+                textCommand.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(windowEnd, DateTimeKind.Unspecified));
+                text = await textCommand.ExecuteScalarAsync(cancellationToken) as string;
+            }
+
+            if (string.IsNullOrWhiteSpace(text) || WithheldStatementMarker.IsMarker(text))
+                unknown.Add(new Unknown(CodeRecompileHint, "the statement text is not stored for this query, or is withheld by the statement filter"));
+            else if (PlanInputComparison.HasRecompileHint(text))
+                refusals.Add(new Refusal(CodeRecompileHint, "The statement has OPTION (RECOMPILE), so every call gets its own plan and a forced plan is not what runs.", new { has_recompile_hint = true }));
+
+            /* 5. not_run_recently. */
+            if (queryLastExecution is { } lastRun && windowEnd - lastRun > NotRunRecentlyAfter)
+                refusals.Add(new Refusal(CodeNotRunRecently,
+                    $"No plan of this query has run in the {NotRunRecentlyAfter.TotalHours:0} hours before {FormatTime(windowEnd)}.",
+                    new { newest_last_execution_time = FormatTime(lastRun), as_of = FormatTime(windowEnd), threshold_hours = NotRunRecentlyAfter.TotalHours }));
+
+            /* 6. too_few_executions. */
+            if (candidate.Executions < MinPlanExecutions)
+                refusals.Add(new Refusal(CodeTooFewExecutions,
+                    $"Plan {plan_id} ran {candidate.Executions} times in the window, under the {MinPlanExecutions} PLAN_REGRESSION needs per plan.",
+                    new { executions = candidate.Executions, minimum = MinPlanExecutions, hours_back }));
+
+            /* 8. output_differs. */
+            if (compare is null)
+                unknown.Add(new Unknown(CodeOutputDiffers, compare_plan_id is null ? "plan_id is itself the query's newest plan and no compare_plan_id was given, so there is no second plan to compare" : "no second plan"));
+            else if (candidate.AvgRows is not { } candRows || compare.AvgRows is not { } compRows)
+                unknown.Add(new Unknown(CodeOutputDiffers, "a stored interval of one of the two plans has no avg_rowcount, so rows per call is not known"));
+            else if (OutputDiffers(candRows, compRows))
+                refusals.Add(new Refusal(CodeOutputDiffers,
+                    "The two plans return very different row counts per call, so their cost is not comparable and the cheaper plan may be cheap only because it returns less.",
+                    new { candidate_avg_rows = candRows, compare_avg_rows = compRows, ratio_threshold = PlanInputComparison.OutputGrowthRatio, row_floor = PlanInputComparison.RowFloor }));
+
+            /* 3, 7, the compiled values and the indexes: the two stored plans. */
+            var candidateXml = await ReadPlanXmlAsync(postgres, resolved.ServerId, database_name, query_id, plan_id, cancellationToken);
+            var compareXml = compare is null ? null : await ReadPlanXmlAsync(postgres, resolved.ServerId, database_name, query_id, compare.PlanId, cancellationToken);
+            var candidateFacts = ReadPlanFacts(candidateXml, database_name);
+            var compareFacts = compare is null ? null : ReadPlanFacts(compareXml, database_name);
+
+            if (candidateFacts is null)
+                unknown.Add(new Unknown(CodeTempTable, "the candidate plan's XML is not stored, is withheld by the statement filter, or cannot be read"));
+            else if (candidateFacts.TempTables.Count > 0)
+                refusals.Add(new Refusal(CodeTempTable,
+                    "The plan reads or writes a temporary table; a force on such a statement failed when replayed.", new { tables = candidateFacts.TempTables }));
+
+            var pspSides = new List<object>();
+            if (candidateFacts?.IsPspVariant == true) pspSides.Add(new { plan_id, basis = candidateFacts.PspBasis });
+            if (compareFacts?.IsPspVariant == true) pspSides.Add(new { plan_id = compare!.PlanId, basis = compareFacts.PspBasis });
+            if (pspSides.Count > 0)
+            {
+                refusals.Add(new Refusal(CodePspVariant,
+                    "A plan is a Parameter Sensitive Plan variant; a force on a variant got 0 executions because the parent statement moved to another query and plan.", new { variants = pspSides }));
+                unknown.Add(new Unknown(CodePspVariant + "_siblings", "the parent query and the sibling variants cannot be named: the store keeps no parent_query_id for a variant"));
+            }
+            else if (candidateFacts is null || (compare is not null && compareFacts is null))
+                unknown.Add(new Unknown(CodePspVariant, "a plan's XML is not stored, is withheld or cannot be read, so whether it is a Parameter Sensitive Plan variant is not known"));
+
+            /* 4. query_store_read_only. */
+            await AddReadOnlyAsync(postgres, resolved.ServerId, database_name, windowEnd, refusals, unknown, cancellationToken);
+
+            /* Shown. */
+            shown["query_last_execution_time"] = FormatTime(queryLastExecution);
+            var shownPlans = new List<object> { ShownPlan("candidate", candidate, candidateXml) };
+            if (compare is not null) shownPlans.Add(ShownPlan("compare", compare, compareXml));
+            shown["plans"] = shownPlans;
+            if (compare is not null)
+                shown["compiled_value_judgement"] = candidateXml is null || compareXml is null ? null : PlanInputComparison.JudgePlans(compareXml, candidateXml).ToString();
+            shown["indexes_not_in_latest_capture"] = await MissingIndexesAsync(postgres, resolved.ServerId, database_name, windowEnd, candidateFacts, unknown, cancellationToken);
+            shown["job_name_matches"] = await JobNameMatchesAsync(postgres, resolved.ServerId, windowEnd, cancellationToken);
+
+            /* A dictionary, not an anonymous object: "shown" is this read's own section, not a page cut (the cut-key census reads a `shown =` member as one). */
+            return JsonSerializer.Serialize(new Dictionary<string, object?>
+            {
+                ["server"] = resolved.ServerName,
+                ["database_name"] = database_name,
+                ["query_id"] = query_id,
+                ["plan_id"] = plan_id,
+                ["compare_plan_id"] = compare?.PlanId,
+                ["as_of"] = FormatTime(windowEnd),
+                ["hours_back"] = hours_back,
+                ["effective_start"] = McpHelpers.FormatEffectiveStart(effectiveStart),
+                ["verdict"] = refusals.Count > 0 ? "refuse" : "no_refusal_found",
+                ["refusals"] = refusals.Select(r => new { code = r.Code, sentence = r.Sentence, evidence = r.Evidence }),
+                ["shown"] = shown,
+                ["unknown"] = unknown.Select(u => new { check = u.Check, reason = u.Reason }),
+                ["note"] = "no_refusal_found means no check fired; it does not mean the force is safe or will help."
+            }, McpHelpers.JsonOptions);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            return McpHelpers.FormatError("get_plan_force_precheck", ex);
+        }
+    }
+
+    private static string? FormatTime(DateTime? t) => t?.ToString("o", CultureInfo.InvariantCulture);
+
+    private static object ShownPlan(string role, PlanFold p, string? xml)
+    {
+        var values = xml is null ? null : PlanInputComparison.CompiledValues(xml);
+        return new
+        {
+            role,
+            plan_id = p.PlanId,
+            executions = p.Executions,
+            cpu_per_execution_ms = p.CpuPerExecMs,
+            duration_per_execution_ms = p.DurationPerExecMs,
+            avg_rows = p.AvgRows,
+            last_execution_time = FormatTime(p.LastExecution),
+            is_forced_plan = p.IsForced,
+            force_failure_count = p.FailureCount,
+            last_force_failure_reason = p.FailureReason,
+            plan_forcing_type = p.ForcingType,
+            compiled_values = values?.Select(kv => new { parameter = kv.Key, compiled_value = kv.Value }).ToList(),
+        };
+    }
+
+    private static Task<string?> ReadPlanXmlAsync(NpgsqlDataSource postgres, int serverId, string database, long queryId, long planId, CancellationToken ct) =>
+        DarlingStoredPlanReader.ReadQueryStorePlanByIdAsync(postgres, serverId, database, queryId, planId, cancellationToken: ct);
+
+    /// <summary>
+    /// The gate. The target is the current PLAN_REGRESSION finding's own for this query when there is one (its replica role and
+    /// parameter-sensitivity flag come from the finding, <see cref="FactRemediation.ExtractPlanRegressionTargets"/> builds it), with
+    /// the plan swapped to plan_id. With no finding the target comes from the store rows: database, query and plan, the plan's last
+    /// run as the best-plan age, and every finding-only field at its default (no replica role, no parameter-sensitivity flag, factor 0),
+    /// and the two finding-only blockers go to <c>unknown</c> because nothing here can answer them.
+    /// </summary>
+    private static async Task AddGateRefusalsAsync(
+        NpgsqlDataSource postgres, int serverId, string database, long queryId, PlanFold candidate, DateTime windowEnd, ILogger? logger,
+        List<Refusal> refusals, List<Unknown> unknown, CancellationToken ct)
+    {
+        ForcePlanTarget? fromFinding = null;
+        try
+        {
+            var findings = await new PgFindingStore(postgres, logger).GetRecentFindingsAsync(serverId, 24, FindingOccurrences.WindowCoveringLimit, windowEnd, ct);
+            fromFinding = findings
+                .Where(f => string.Equals(f.RootFactKey, "PLAN_REGRESSION", StringComparison.Ordinal) && f.Remediation?.Targets is { Count: > 0 })
+                .OrderByDescending(f => f.AnalysisTime)
+                .SelectMany(f => f.Remediation!.Targets)
+                .FirstOrDefault(t => t.QueryId == queryId && string.Equals(t.Database, database, StringComparison.OrdinalIgnoreCase));
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            logger?.LogWarning(ex, "The PLAN_REGRESSION finding read for get_plan_force_precheck failed for server {ServerId}.", serverId);
+            unknown.Add(new Unknown("parameter_sensitivity_cofired", "the current PLAN_REGRESSION findings could not be read"));
+        }
+
+        ForcePlanTarget target;
+        if (fromFinding is not null)
+        {
+            target = fromFinding with { PlanId = candidate.PlanId, BestPlanHash = null };
+        }
+        else
+        {
+            target = new ForcePlanTarget(database, queryId, candidate.PlanId, BestPlanLastSeenUtc: candidate.LastExecution);
+            unknown.Add(new Unknown(ForcePlanBlockerNames.ParameterSensitivityCoFired, "no current PLAN_REGRESSION finding for this query, so the parameter-sensitivity signature is not known"));
+            unknown.Add(new Unknown(ForcePlanBlockerNames.SecondaryReplicaEvidence, "no current PLAN_REGRESSION finding for this query, so the replica the regression was measured on is not known"));
+        }
+
+        var carrier = new AnalysisFinding
+        {
+            ServerId = serverId,
+            RootFactKey = "PLAN_REGRESSION",
+            Remediation = new RemediationAction("PLAN_REGRESSION", "force", new[] { target }),
+        };
+        var (states, reason) = await DarlingForcePlanTargetStateReader.TryReadAsync(postgres, serverId, new[] { carrier }, windowEnd, logger, ct);
+        ForcePlanTargetState? state = null;
+        states?.TryGetValue(ForcePlanTargetKey.Of(target), out state);
+        foreach (var blocker in ForcePlanBotPolicy.Blockers(target, state, states is null ? reason : null, enablementIsCollected: false))
+            refusals.Add(new Refusal(blocker.Name, blocker.Evidence, null));
+    }
+
+    private static async Task AddReadOnlyAsync(
+        NpgsqlDataSource postgres, int serverId, string database, DateTime windowEnd, List<Refusal> refusals, List<Unknown> unknown, CancellationToken ct)
+    {
+        await using var command = postgres.CreateCommand(HealthSql);
+        command.CommandTimeout = McpCommandDeadlines.ReadSeconds;
+        command.Parameters.AddWithValue(serverId);
+        command.Parameters.AddWithValue(database);
+        command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(windowEnd, DateTimeKind.Unspecified));
+        await using var reader = await command.ExecuteReaderAsync(ct);
+        if (!await reader.ReadAsync(ct) || reader.IsDBNull(0) || string.IsNullOrWhiteSpace(reader.GetString(0)))
+        {
+            unknown.Add(new Unknown(CodeQueryStoreReadOnly, "no query_store_health row for this database at or before as_of, so Query Store's state is not known"));
+            return;
+        }
+
+        var actual = reader.GetString(0);
+        var desired = reader.IsDBNull(1) ? null : reader.GetString(1);
+        var readonlyReason = reader.IsDBNull(2) ? 0 : reader.GetInt32(2);
+        if (!string.Equals(actual, "READ_WRITE", StringComparison.OrdinalIgnoreCase))
+            refusals.Add(new Refusal(CodeQueryStoreReadOnly,
+                $"Query Store is {actual} for this database, so a force is not recorded or kept.",
+                new
+                {
+                    actual_state = actual,
+                    desired_state = desired,
+                    readonly_reason = readonlyReason,
+                    readonly_reason_decoded = readonlyReason == 0 ? null : QueryStoreReadonlyReason.Decode(readonlyReason),
+                    captured_at = FormatTime(reader.GetDateTime(3)),
+                }));
+    }
+
+    private static async Task<object> MissingIndexesAsync(
+        NpgsqlDataSource postgres, int serverId, string database, DateTime windowEnd, PlanFacts? facts, List<Unknown> unknown, CancellationToken ct)
+    {
+        if (facts is null || facts.Indexes.Count == 0) return Array.Empty<object>();
+        var captured = new Dictionary<(string, string), HashSet<string>>();
+        await using (var command = postgres.CreateCommand(IndexCaptureSql))
+        {
+            command.CommandTimeout = McpCommandDeadlines.ReadSeconds;
+            command.Parameters.AddWithValue(serverId);
+            command.Parameters.AddWithValue(database);
+            command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(windowEnd, DateTimeKind.Unspecified));
+            await using var reader = await command.ExecuteReaderAsync(ct);
+            while (await reader.ReadAsync(ct))
+            {
+                var key = (reader.IsDBNull(0) ? "" : reader.GetString(0), reader.IsDBNull(1) ? "" : reader.GetString(1));
+                if (!captured.TryGetValue(key, out var set)) captured[key] = set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                if (!reader.IsDBNull(2)) set.Add(reader.GetString(2));
+            }
+        }
+
+        if (captured.Count == 0)
+        {
+            unknown.Add(new Unknown("indexes_not_in_latest_capture", "no index_object_stats capture for this database at or before as_of"));
+            return Array.Empty<object>();
+        }
+
+        return facts.Indexes
+            .Where(i => captured.TryGetValue((i.Schema, i.Table), out var set) && !set.Contains(i.Index))
+            .Select(i => new { schema = i.Schema, table = i.Table, index_name = i.Index, basis = "not in the latest index_object_stats capture; the capture may not list every index" })
+            .Take(MaxListed).ToList();
+    }
+
+    private static async Task<object> JobNameMatchesAsync(NpgsqlDataSource postgres, int serverId, DateTime windowEnd, CancellationToken ct)
+    {
+        var matches = new List<object>();
+        await using var command = postgres.CreateCommand(JobNamesSql);
+        command.CommandTimeout = McpCommandDeadlines.ReadSeconds;
+        command.Parameters.AddWithValue(serverId);
+        command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(windowEnd.AddDays(-JobLookbackDays), DateTimeKind.Unspecified));
+        command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(windowEnd, DateTimeKind.Unspecified));
+        await using var reader = await command.ExecuteReaderAsync(ct);
+        while (await reader.ReadAsync(ct))
+            matches.Add(new { job_name = reader.IsDBNull(0) ? null : reader.GetString(0), step_name = reader.IsDBNull(1) ? null : reader.GetString(1), basis = "name match only; the store holds no job step command" });
+        return matches;
+    }
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryStoreHistoryTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryStoreHistoryTools.cs
index 9339944858..fa143b12cf 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryStoreHistoryTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryStoreHistoryTools.cs
@@ -80,13 +80,16 @@ internal static List<T> NewestWithinBudget<T>(IReadOnlyList<T> rows, Func<T, int
     /// (the newest collection_time, then the largest execution_count), so no total adds one interval twice. The
     /// partition is the one <c>DarlingDataReader.QueryStoreTopRawPrefix</c> uses; PostgreSQL matches NULL to NULL in it.
     /// </summary>
-    internal const string HistorySql = """
+    internal const string HistoryDedupeCte = """
         WITH deduped AS (
             SELECT *, ROW_NUMBER() OVER (PARTITION BY plan_id, runtime_stats_interval_id, first_execution_time, execution_type_desc, replica_role
                                          ORDER BY collection_time DESC, execution_count DESC) AS rn
             FROM query_store_stats
             WHERE server_id = $1 AND database_name = $2 AND query_id = $3
             AND collection_time >= $4 AND collection_time <= $5)
+        """;
+
+    internal const string HistorySql = HistoryDedupeCte + "\n" + """
         SELECT plan_id, collection_time, execution_count,
                CAST(avg_duration_us AS double precision) / 1000.0,
                CAST(avg_cpu_time_us AS double precision) / 1000.0,
@@ -94,6 +97,18 @@ FROM query_store_stats
         FROM deduped WHERE rn = 1
         """ + " " + HistoryOrder;
 
+    /// <summary>
+    /// The interval-table read's FROM and WHERE (#5300, #5807, #5523), shared with <c>get_plan_force_precheck</c> (#5632) so a
+    /// second reader of the same table takes the same index-friendly predicates and cannot drift from them.
+    /// </summary>
+    internal static readonly string HistoryTableFromWhere = $$"""
+        FROM query_store_interval_wide
+        WHERE server_id = $1 AND database_name = $2 AND query_id = $3
+        AND collection_time >= $4 AND collection_time <= $5
+        AND first_execution_time >= $4 - {{QueryStoreIntervalWide.PurgeEdgeMarginSql}}
+        AND first_execution_time <= $5 + {{QueryStoreIntervalWide.FirstExecUpperSlackSql}}
+        """;
+
     /// <summary>
     /// The interval table's twin of <see cref="HistorySql"/> (#5300), the tier the grid reads below raw retention:
     /// <c>query_store_interval_wide</c> already holds ONE row per interval identity, its latest snapshot (the dedupe above,
@@ -115,12 +130,7 @@ FROM query_store_stats
                CAST(avg_duration_us AS double precision) / 1000.0,
                CAST(avg_cpu_time_us AS double precision) / 1000.0,
                first_execution_time, last_execution_time, is_forced_plan
-        FROM query_store_interval_wide
-        WHERE server_id = $1 AND database_name = $2 AND query_id = $3
-        AND collection_time >= $4 AND collection_time <= $5
-        AND first_execution_time >= $4 - {{QueryStoreIntervalWide.PurgeEdgeMarginSql}}
-        AND first_execution_time <= $5 + {{QueryStoreIntervalWide.FirstExecUpperSlackSql}}
-        """ + " " + HistoryOrder;
+        """ + "\n" + HistoryTableFromWhere + " " + HistoryOrder;
 
     internal readonly record struct HistoryRow(
         long PlanId, DateTime CollectionTime, long ExecutionCount, double? AvgDurationMs, double? AvgCpuMs,
@@ -208,8 +218,17 @@ private static async Task<List<HistoryRow>> ReadRowsAsync(NpgsqlDataReader reade
     /// decision and the read it authorizes see one snapshot. Null (never an empty list) when the gate says raw or anything
     /// before the table read fails; a fault falls back to raw, as the grid's does. Cancellation propagates.
     /// </summary>
-    private static async Task<(List<HistoryRow> Rows, QueryStoreIntervalWide.WideReadPlan Plan)?> TryReadFromTableAsync(
-        NpgsqlDataSource postgres, int serverId, string databaseName, long queryId, DateTime start, DateTime end, CancellationToken cancellationToken)
+    private static Task<(List<HistoryRow> Rows, QueryStoreIntervalWide.WideReadPlan Plan)?> TryReadFromTableAsync(
+        NpgsqlDataSource postgres, int serverId, string databaseName, long queryId, DateTime start, DateTime end, CancellationToken cancellationToken) =>
+        TryReadFromTableAsync(postgres, serverId, databaseName, queryId, start, end, HistoryTableSql, ReadRowsAsync, cancellationToken);
+
+    /// <summary>
+    /// The tier choice with the row shape and the select list left to the caller (#5632): <c>get_plan_force_precheck</c> reads
+    /// the same table under the same gate with more columns. <paramref name="tableSql"/> takes $1 to $5 as <see cref="HistoryTableSql"/> does.
+    /// </summary>
+    internal static async Task<(List<T> Rows, QueryStoreIntervalWide.WideReadPlan Plan)?> TryReadFromTableAsync<T>(
+        NpgsqlDataSource postgres, int serverId, string databaseName, long queryId, DateTime start, DateTime end,
+        string tableSql, Func<NpgsqlDataReader, CancellationToken, Task<List<T>>> readRows, CancellationToken cancellationToken)
     {
         if (!DarlingDataReader.QueryStoreTopMayReadTable(start, end)) return null;
         var gateDecided = false;
@@ -232,14 +251,14 @@ private static async Task<List<HistoryRow>> ReadRowsAsync(NpgsqlDataReader reade
             }
 
             gateDecided = true;
-            await using var command = new NpgsqlCommand(HistoryTableSql, connection) { Transaction = transaction, CommandTimeout = McpCommandDeadlines.ReadSeconds };
+            await using var command = new NpgsqlCommand(tableSql, connection) { Transaction = transaction, CommandTimeout = McpCommandDeadlines.ReadSeconds };
             command.Parameters.AddWithValue(serverId);
             command.Parameters.AddWithValue(databaseName);
             command.Parameters.AddWithValue(queryId);
             command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(plan.ReadStart, DateTimeKind.Unspecified));
             command.Parameters.AddWithValue(NpgsqlTypes.NpgsqlDbType.Timestamp, DateTime.SpecifyKind(end, DateTimeKind.Unspecified));
             await using var reader = await command.ExecuteReaderAsync(cancellationToken);
-            var rows = await ReadRowsAsync(reader, cancellationToken);
+            var rows = await readRows(reader, cancellationToken);
             ReadScope.NoteSource(ReadScope.SourceIntervalTable);
             return (rows, plan);
         }
diff --git a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
index c0c3201c36..cb2f19660a 100644
--- a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
@@ -141,6 +141,7 @@ get_blocking_stats is uncapped on the MCP side (ValidateUncappedWindow). */
         ["get_query_store_regressions"] = List("query_store"),
         ["get_query_store_clutter"] = List("query_store"),
         ["get_query_store_query_history"] = List("query_store"),
+        ["get_plan_force_precheck"] = List("query_store"),
         ["get_resource_use_by_tag"] = List("query_stats"),
         ["get_long_query_completions"] = List("long_query_completions"),
         ["get_plan_corrections"] = List("plan_correction"),
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/database-filter-reads.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/database-filter-reads.js
index c7c358223d..daae1c6037 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/database-filter-reads.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/database-filter-reads.js
@@ -50,7 +50,7 @@ export const UNFILTERED = new Set([
  *  injected into them and they show no chip. */
 export const IDENTITY = new Set([
   "get_query_trend", "get_plan_xml", "get_query_store_plan_xml", "get_active_query_plan_xml", "get_procedure_plan_xml",
-  "get_query_store_query_history", "get_blocking_plan_xml", "get_deadlock_plan_xml", "get_query_repro_script",
+  "get_query_store_query_history", "get_plan_force_precheck", "get_blocking_plan_xml", "get_deadlock_plan_xml", "get_query_repro_script",
 ]);
 
 /** Every other SQL Server read a module of the server page names: the data has no database, so the filter does not apply.
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/plain-text.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/plain-text.js
index b6effc8720..c167488ca2 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/plain-text.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/plain-text.js
@@ -42,7 +42,7 @@ export const MCP_TOOL_NAMES = [
   "get_pg_query_duration_trend", "get_pg_replication_slots", "get_pg_replication_stats", "get_pg_server_config",
   "get_pg_server_config_changes", "get_pg_session_states", "get_pg_table_bloat", "get_pg_top_queries",
   "get_pg_wait_sampling", "get_pg_wait_stats", "get_pg_wait_trend", "get_pg_wraparound_risk", "get_pg_write_stats",
-  "get_pg_xmin_horizon", "get_plan_cache_bloat", "get_plan_corrections", "get_plan_xml",
+  "get_pg_xmin_horizon", "get_plan_cache_bloat", "get_plan_corrections", "get_plan_force_precheck", "get_plan_xml",
   "get_procedure_duration_trend", "get_procedure_plan_xml", "get_pvs_stats", "get_query_duration_trend",
   "get_query_heatmap", "get_query_repro_script", "get_query_store_clutter", "get_query_store_duration_trend",
   "get_query_store_health", "get_query_store_plan_xml", "get_query_store_query_history",