sp_StatUpdate_Diag.sql

SET ANSI_NULLS ON;
GO
SET QUOTED_IDENTIFIER ON;
GO

/*

sp_StatUpdate_Diag - Diagnostic & Recommendation Engine

Copyright (c) 2026 Community Contribution
https://github.com/nanoDBA/sp_StatUpdate

Purpose:    Analyze CommandLog data from sp_StatUpdate runs to detect problems,
            identify suboptimal configurations, and recommend parameter changes.
            Supports obfuscated output mode for safe external sharing.

Based on:   sp_StatUpdate CommandLog format and Ola Hallengren's CommandLog table.

License:    MIT License

            Permission is hereby granted, free of charge, to any person obtaining a copy
            of this software and associated documentation files (the "Software"), to deal
            in the Software without restriction, including without limitation the rights
            to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
            copies of the Software, and to permit persons to whom the Software is
            furnished to do so, subject to the following conditions:

            The above copyright notice and this permission notice shall be included in all
            copies or substantial portions of the Software.

            THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
            IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
            FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
            AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
            LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
            OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
            SOFTWARE.

Version:    2026.07.03.1 (CalVer: YYYY.MM.DD; same-day patches append .1, .2, etc.)

History:    2026.07.03.1 - I8/RS13 DataStatus surface (w5p2 / gh-532):
                           I8 and RS13 no longer go silently empty when Query Store
                           CPU history is sparse or absent.  New @i8_data_status
                           (AVAILABLE / INSUFFICIENT_HISTORY / UNAVAILABLE) computed
                           from QS-CPU-bearing runs and tracked-stat counts.  Sparse
                           I8 findings carry a machine-readable suffix:
                           [DataStatus: X; QSCpuRuns: N; TrackedStats: N] (AVAILABLE
                           findings unchanged -- no suffix).  RS13 returns a single
                           [NO DATA] sentinel row (full production column list, reason
                           text in StatisticsName) instead of zero rows whenever
                           status <> AVAILABLE, on both the multi-result-set and
                           @SingleResultSet paths.  The empty-CommandLog early return
                           emits the same I8 UNAVAILABLE finding and RS13 sentinel so
                           first-run users get the explanation too.  @Help I8 catalog
                           entry updated.
            2026.07.02.2 - Phase-C diagnostic batch (sw82, 9ufm, atk1, 9axc):
                           (sw82) @CriticalTables coverage: ingest CriticalTables /
                           CriticalSamplePercent / CriticalTablesFirst into #runs; ingest
                           IsCritical / CriticalSampleOverride into #stat_updates (both cache
                           and direct paths).  New W16 CRITICAL_TABLES_NO_MATCH: fires when
                           CriticalTables configured but zero IsCritical=1 stat rows in that
                           run.  New I17 CRITICAL_TABLES_COVERAGE: leadership-friendly summary
                           when critical stats exist (count updated, avg ProcessingPosition,
                           override count).  Both checks registered in the @Help catalog.
                           Cache auto-upgrade adds IsCritical / CriticalSampleOverride columns.
                           (9ufm) Version-aware param gating: #runs gains HasFullParamsLog
                           (1 when the run's sp_StatUpdate version >= 2.15, the full-parameter-
                           logging era).  W1a / W1b / I4a / I4c / I4d only reason about absent
                           parameter elements on such runs -- there, FOR XML omitting NULL
                           params means absence IS the signal (TimeLimit absent = genuinely
                           unlimited).  Pre-2.15 runs are excluded from param reasoning, so they
                           no longer produce false UNUSED_FEATURES / SUBOPTIMAL_PARAMS findings.
                           (Per-element .exist() gating was rejected: it gates each check on
                           the very element whose absence the check detects.)
                           (atk1) Executive Dashboard TIME_LIMIT annotation: COMPLETION Headline
                           gains a ' [!] Time limit exhausted in N% of runs' banner when the
                           C3 threshold is met; COMPLETION Detail gains a CompletionReason clause;
                           OVERALL Detail gains a short flag.  Score/grade math unchanged;
                           12 existing structure tests remain valid.
                           (9axc) History watermark robustness: StatUpdateDiagHistory gains
                           MaxStartTime datetime2(3) NULL via ALTER-if-missing pattern.
                           Watermark WRITE now records both MaxCommandLogID and MaxStartTime.
                           Watermark READ selects MAX(MaxStartTime) into @history_max_run_start.
                           NOT EXISTS on RunLabel remains the final duplicate guard.
                           (hardening) All three #stat_updates ingestion builds now start with
                           a CONVERT(nvarchar(max), N'') operand: sub-4000-char literal pieces
                           previously made intermediate concats nvarchar(4000), silently
                           truncating the assembled batch at 4000 chars -- the direct-path
                           batch lost its WHERE tail and every ingest failed with
                           'Incorrect syntax near AND' while the proc kept running with an
                           empty #stat_updates.  Cache CREATE path brought into lockstep with
                           the upgrade ALTERs (IsCritical / CriticalSampleOverride).
            2026.07.02.1 - Phase-B diagnostic batch (70hh, 1h2l, 8gws, xmxs, 4g9s, t8lj):
                           (70hh) Skip-row ingestion fix: SKIPPED: Command and TOCTOU_SKIP
                           ErrorMessage rows excluded at cache and direct-path ingestion
                           layers.  They no longer pollute duration/appearance/top-table
                           aggregates.  StatsToctou ingested from END Summary XML into
                           #runs and surfaced in RS4 Run Detail.
                           (1h2l) QSEnrichmentSkipped ingested from END Summary XML into
                           #runs.  W5 QS_NOT_EFFECTIVE now uses it as the primary signal
                           (direct element read); inference via QSPlanCount/CPU fallback
                           retained for older rows where element is absent.
                           (8gws) I4 UNUSED_FEATURES catalog refresh: added I4c
                           (@FirstTimeFullScanCapRows, v3.5.4), I4d (@CriticalTables,
                           v3.5.0), I4e (@AbortOnIntegrityError, v3.5.9 -- only
                           surfaces when IO_CORRUPTION stop reason is seen in history).
                           (xmxs) Removed dead v2 leftover: GroupByJoinPattern XPath
                           extraction, @latest_group_join variable, and GroupByJoinPattern
                           column from #runs and RS8 Parameter History.  Element is absent
                           in v3 START XML and variable had zero consumers.
                           (4g9s) New W14 RECURRING_SAFETY_STOP: fires when the same
                           safety StopReason (TEMPDB_PRESSURE, AG_REDO_QUEUE,
                           LOG_SPACE_HIGH, IO_CORRUPTION, FAIL_FAST,
                           CONSECUTIVE_FAILURES, BATCH_LIMIT) appears in >= 2 runs.
                           One finding row per recurring reason with reason-specific
                           remediation.  Evidence caps at 10 most-recent StartTimes.
                           (t8lj) New WarningsCodes column in #runs, ingested from END
                           Summary XML (pipe-delimited tokens, v3.5.9+).  New W15
                           RECURRING_RUNTIME_WARNING (environmental/actionable codes)
                           and I16 RECURRING_RUNTIME_WARNING (informational codes) fire
                           when a code appears in >= 3 runs or >= 50%% of non-killed
                           runs.  Old runs without element produce zero findings.
            2026.06.12.1 - Silent no-op parallel run detection (sp_StatUpdate-kzx0,
                           validated against the -v31y zombie-queue incident).
                           (1) New CRITICAL check C6 SILENT_NOOP_RUN: flags
                           non-killed runs that report a normal-completion
                           StopReason (PARALLEL_COMPLETE/COMPLETED/NATURAL_END)
                           with StatsFound > 0 but StatsProcessed = 0, when no
                           other worker in the same time window processed
                           anything and no sp_StatUpdate UPDATE_STATISTICS
                           activity overlaps the run window.  Catches zombied
                           queue leadership and any future claim-nothing
                           failure that self-reports success.
                           (2) W3 STALE_BACKLOG un-suppressed when the C6
                           signature is present: @w3_parallel_complete is
                           forced 0 so the backstop check and the COMPLETION
                           grade-A fast path no longer trust PARALLEL_COMPLETE
                           blindly (also closes the grade-A hole for zombie
                           joiners that report StatsRemaining = 0 from an
                           empty skip-discovery temp table).
                           (3) #qs_efficacy completion math: PARALLEL_COMPLETE
                           with StatsRemaining > 0 is self-contradictory
                           telemetry -- CompletionPct now cross-checks the
                           worker group (overlapping parallel runs) and uses
                           SUM(StatsProcessed) / MAX(StatsFound) instead of a
                           constant 100.0 when the group did not drain the
                           queue.  WorkloadCoveragePct same treatment.
                           Genuinely-drained runs (group SUM(processed) >=
                           MAX(found), or remaining = 0) keep the 3j5l
                           (2026.05.28.1) behavior -- no false-F regression.
            2026.06.10.1 - Catalog completion (sp_StatUpdate-8gzw follow-on to
                           g4c0): added the 10 emitted-but-undocumented checks
                           to the @Help checks catalog -- W7
                           HIGH_IMPACT_STATS_DEPRIORITIZED, W8 MOPUP_INEFFECTIVE,
                           W9 LOCK_TIMEOUT_INEFFECTIVE, W10 PARAMETER_CHURN,
                           C5 SAMPLE_RATE_DEGRADATION, I9 WORKLOAD_CONCENTRATION,
                           I11 FAILURE_CLUSTERING, I12 QS_COVERAGE_DRIFT,
                           I13 PARALLEL_OPPORTUNITY, I14 MOPUP_MISSING_PAGECOUNT.
                           All ten existed as real checks (v2.29 generation +
                           Phase 3) but never appeared in @Help.  No behavior
                           change to the checks themselves.
            2026.06.08.2 - Cosmetic: added QS_PARALLEL_UNRELIABLE to diagnostic
                           checks catalog (sp_StatUpdate-g4c0).
            2026.06.08.1 - sp_StatUpdate-6x80: W5/I10 QS-parallel refinements.
                           (1) W5 parallel-aware: when all QS-priority runs use
                           @StatsInParallel='Y' and QS CPU data IS present in
                           stat updates (QSTotalCpuMs > 0), W5's zero-data-runs
                           branch is suppressed -- per-worker ProcessingPosition
                           counters make the "QS data not captured" signal
                           unreliable in parallel mode.  A softer INFO note is
                           inserted instead of a WARNING.
                           (2) I10 W5-conditional QS drop: I10 now only reverts
                           @SortOrder to MODIFICATION_COUNTER and clears
                           @QueryStore when W5 fired due to genuine absence of
                           QS data (not a parallel-ordering artifact).  When W5
                           fired but runs are parallel AND QS CPU data was
                           observed, I10 keeps @SortOrder=QUERY_STORE and
                           @QueryStore=CPU.
                           (3) TimeLimit jitter normalization: when MAX-MIN of
                           TimeLimit across recent non-killed runs is < 300 s,
                           I10 rounds to the nearest minute
                           (ROUND(AVG / 60.0, 0) * 60) to avoid echoing jittery
                           @StopByTime-derived values like 21599/21598.
                           (4) @CriticalTables hint: when W9
                           LOCK_TIMEOUT_INEFFECTIVE has fired, I10 appends a
                           suggested @CriticalTables comment to the recommended
                           EXEC call listing the top contended tables so the
                           operator can apply per-table priority boost.
            2026.05.28.1 - Two parallel-mode false-positive fixes.
                           (1) sp_StatUpdate-772k: #runs dedup tiebreaker is now
                           ORDER BY StartTime DESC, IsKilled ASC, EndTime DESC.
                           The prior 2026.04.20.1 EndTime DESC ordering could
                           pick a synthetic KILLED orphan-cleanup END over the
                           real END (the KILLED row often has a later EndTime),
                           falsely flagging completed parallel runs as killed.
                           IsKilled ASC guarantees the real END (IsKilled = 0)
                           wins.
                           (2) sp_StatUpdate-3j5l: completion_pct now returns
                           100.0 when StopReason IN (COMPLETED, PARALLEL_COMPLETE).
                           In parallel mode StatsFound is the whole-queue total
                           while StatsProcessed is this worker's slice, so the
                           raw ratio understated completion (e.g. 50%) and
                           dragged down the 40%-weighted run-health grade.
            2026.04.22.1 - W13 PERPETUALLY_SKIPPED: new WARNING when stats are
                           discovered but never updated across N consecutive runs
                           due to time limits (gh-504).  Recommends @SortOrder=
                           MODIFICATION_VELOCITY or increasing @TimeLimit.
            2026.04.20.2 - C1 KILLED_RUNS Evidence truncation fix.  When 90+
                           killed runs existed, the STRING_AGG of all killed
                           run StartTimes into the Evidence column overflowed
                           nvarchar(2000) and raised Msg 2628 'String or binary
                           data would be truncated'.  Capped to the 10 most
                           recent dates with a "(10 most recent of N)" prefix
                           when truncation happens.
            2026.04.20.1 - Fix PK_runs violation during #runs INSERT.
                           The INSERT LEFT JOINs SP_STATUPDATE_START to
                           SP_STATUPDATE_END on RunLabel; CommandLog can
                           contain multiple ENDs per RunLabel (orphan-cleanup
                           KILLED record + real END from gh-425) or duplicate
                           STARTs (same-second retries), producing multiple
                           rows per RunLabel and a PK violation before the
                           existing dedup could run.  Removed CONSTRAINT
                           PK_runs from CREATE TABLE; added UX_runs_RunLabel
                           unique index after the dedup CTE.  Dedup tiebreaker
                           now ORDER BY StartTime DESC, EndTime DESC so the
                           real END is preferred over the KILLED orphan
                           record.
            2026.04.18.1 - Parallel false-positive fix (c53, 3 checks):
                           C3 TIME_LIMIT_EXHAUSTION: suppress when all non-killed runs have
                             StatsInParallel='Y' and aggregate StatsRemaining=0 (all workers
                             used parallel coordination; per-worker TIME_LIMIT exits with zero
                             aggregate remaining are not a genuine time-limit signal).
                           W3 STALE_BACKLOG: extend @w3_parallel_complete to also set=1 when
                             @parallel_aggregate_done=1, covering TIME_LIMIT exits alongside
                             the existing PARALLEL_COMPLETE-only path.
                           COMPLETION grade: inherits improvement via @w3_parallel_complete
                             (already awards score=95 when @w3_parallel_complete=1).
            2026.04.17.1 - Diag bug batch Phase 2 (10 issues):
                           gh-471: Sync @procedure_version with header Version.
                           gh-472: Auto-upgrade StatUpdateDiagHistory via COL_LENGTH-gated ALTER.
                           gh-473: C3 denominator/numerator parity -- filter @time_limit_runs by
                             IsKilled=0 to match @total_completed_runs.
                           gh-474: Move @latest_qs_run DECLARE above IF/ELSE so SingleResultSet
                             path can reference it.
                           gh-475: W12 clamp StatsProcessed-MopUpProcessed to >=0 via CASE WHEN.
                           gh-476: W7 evidence filter uses @w7_median_position (ISNULL,0) instead
                             of hard-coded > 5.
                           gh-477: C5 evidence GROUP BY includes DatabaseName/SchemaName/ObjectName
                             to prevent collision across tables sharing a stat name.
                           gh-478: W6 clamp overhead_pct to [0,100] to avoid negative display
                             when stat_ms slightly exceeds wall-clock due to clock skew.
                           gh-479: C4 cross join requires recent_w.parallel_mode = prior_w.parallel_mode
                             to prevent cross-mode throughput comparisons.
                           gh-480: Dashboard SingleResultSet path -- initialize @avg_completion
                             and @tl_run_pct in @w3_parallel_complete=1 branch so downstream
                             COMPLETION detail text always has a value.
            2026.04.13.2 - PARALLEL_COMPLETE parity and new checks (4 issues):
                           NaturalEndRuns (RS3): now counts PARALLEL_COMPLETE in addition to
                             COMPLETED so parallel runs are recognised as natural completions.
                           workload_pct (#qs_efficacy): PARALLEL_COMPLETE treated as 100% coverage
                             same as COMPLETED (all work distributed across workers finished).
                           W1d mop-up suggestion: fires for PARALLEL_COMPLETE runs in addition to
                             COMPLETED/NATURAL_END runs (parallel runs with time budget unused).
                           W12 PRIORITY_PASS_EMPTY: new WARNING when mop-up does all the work
                             (priority pass averages <5 stats across 3+ runs while mop-up runs).
                           SPEED grade parallel-aware: when all non-killed runs are parallel
                             (@StatsInParallel='Y'), grade is based on GB/min throughput instead
                             of sec/stat wall-clock (which underestimates per-worker speed).
            2026.04.13.1 - Parallel-mode false positives (7 issues):
                           W3 STALE_BACKLOG: suppress when all non-killed runs are PARALLEL_COMPLETE
                             with AvgStatsRemaining=0 (per-worker remaining is not a real backlog).
                           W4 OVERLAPPING_RUNS: suppress when both overlapping runs have
                             StatsInParallel='Y' (intentional two-schedule parallel pattern).
                           COMPLETION grade: set score to 95 when all non-killed runs end with
                             PARALLEL_COMPLETE and AvgStatsRemaining=0 (aggregate = done).
                           C3 TIME_LIMIT_EXHAUSTION: also count COMPLETED runs with StatsRemaining>0
                             as functionally time-limited.
                           RS3 AvgDurationSec: exclude killed runs with StatsProcessed=0 (48-hour
                             phantom durations from orphan-cleanup synthetic END records).
                           I10 RECOMMENDED_CONFIG: removed stray @TieredThresholds and
                             @CleanupOrphanedRuns references from I10 code path (v2 params).
                           I11 FAILURE_CLUSTERING: escalate from INFO to WARNING when C2
                             REPEATED_FAILURES is also active and top error covers >80% of failures.
            2026.03.26.1 - RS 13 memory grant and tempdb spill trending (#368): FirstMemoryGrantKB,
                           LastMemoryGrantKB, MemoryGrantChangePct, MemoryGrantTrend, FirstTempdbPages,
                           LastTempdbPages, TempdbChangePct, TempdbTrend columns.  I8 headline includes
                           memory grant trends when data available.  New #stat_updates columns:
                           QSTotalMemoryGrantKB, QSTotalTempdbPages (extracted from ExtendedInfo XML).
                           Cache table auto-upgrade for new columns.
            2026.03.26   - W8 MOPUP_INEFFECTIVE: warn when mop-up consistently finds 0 stats (#347).
                           W9 LOCK_TIMEOUT_INEFFECTIVE: persistent lock timeout victims (#348).
                           W10 PARAMETER_CHURN: key parameters changing frequently (#350).
                           C5 SAMPLE_RATE_DEGRADATION: effective sample rate dropped >50% (#345).
                           I11 FAILURE_CLUSTERING: dominant error code detection (#346).
                           I12 QS_COVERAGE_DRIFT: QS plan count dropping >50% week-over-week (#349).
                           I13 PARALLEL_OPPORTUNITY: serial runs using <40% of TimeLimit (#351).
                           I14 MOPUP_MISSING_PAGECOUNT: throughput underestimation warning (#342).
                           I10 mutual exclusion validation guard (#343).
            2026.03.24   - Mop-up awareness: #runs gets MopUpTriggered/MopUpFound/MopUpProcessed
                           from SP_STATUPDATE_END summary XML.  RS4 Run Detail includes mop-up columns.
                           W1d recommendation: suggest @MopUpPass when runs complete early (<50% of
                           TimeLimit used).  I10 RECOMMENDED_CONFIG includes @MopUpPass when W1d fires.
                           Fix: split #runs INSERT dynamic SQL to avoid nvarchar(4000) literal truncation.
                         - GB throughput metrics: TotalGB computed from per-stat PageCount aggregation.
                           RS3 Run Health Summary: AvgTotalGB, AvgGBPerMin.
                           RS4 Run Detail: TotalGB, GBPerMin per run.
                           RS10 Efficacy Trend: AvgGBPerMin per week.
                           C4 DEGRADING_THROUGHPUT: Evidence includes GB/min for both windows.
                           Dashboard SPEED: headlines include GB/min and GB/run volume context.
            2026.03.23.1 - I10 RECOMMENDED_CONFIG: synthesized parameter set based on diagnostic
                           findings and parameter history.  Preserves safeguards from prior runs,
                           adjusts flagged parameters, suggests untracked safeguards (@MinTempdbFreeMB,
                           @MaxConsecutiveFailures, @MaxAGRedoQueueMB).
            2026.03.23   - NULL RunLabel fix for legacy CommandLog entries (ISNULL fallback).
                         - INSERT...EXEC safety: auto @SkipHistory=1, DB_ID guard, TRY/CATCH on map write.
                         - @ObfuscationMapTable dedup (NOT EXISTS prevents duplicate rows on repeated runs).
                         - Arithmetic overflow fix: nvarchar(10) widened to nvarchar(20) for decimal/ratio conversions.
                         - Unicode arrow (U+2192) replaced with ASCII '->'.
                         - Enhanced @Debug=1: timing at every stage, effective parameter echo, temp table row
                           counts and samples (#qs_efficacy, #executive_dashboard, #recommendations severity
                           breakdown), CommandLog date range, legacy label count, execution summary.
                         - Enhanced @Help=1: grading scale docs, prerequisites/limitations, grade override
                           examples, version history (9 result sets, was 5).
                         - Em dash removal (~60 occurrences) for PowerShell 5.1 compatibility.
            2026.03.20   - 26-issue bulk resolution across 5 phases:
                         Phase 1: Cache watermark sentinel fix (#312), C4 parallelism-aware (#306).
                         Phase 2: ObjectId/StatsId extraction (#268), RS 2 Summary (#283),
                           RS 7 StatsInParallel (#287), RS 12 WorkloadRankPct/CumulativeCpuPct (#262),
                           RS 10 Top5ConcentrationPct (#269), cursor-to-set-based parsing (#302).
                         Phase 3: #workload_impact staging table, ImpactScore in RS 5/7 (#255),
                           WorkloadImpactPct in RS 5 (#261), IsVolatile flag (#259),
                           W7 HIGH_IMPACT_STATS_DEPRIORITIZED (#263), I9 WORKLOAD_CONCENTRATION (#264),
                           C3 workload impact enhancement (#265).
                         Phase 4: W2 CRITICAL escalation (#266), W5 partial read-only (#274),
                           W5/I6 capture mode guidance (#278), I8 improve-then-regress (#276),
                           W6 memory pressure guidance (#285), dashboard non-QS scoring (#267),
                           ExpertMode=0 workload context (#270).
                         Phase 5: AG secondary replica detection (#296), RS 3 ReplicaRole column,
                           15 new tests (162 -> 177).
            2026.03.13   - Fix RS 12 WorkloadRank always=1 in SingleResultSet mode (#280).
                         - Fix RS 11 DeltaVsPrior missing minutes-to-critical delta in SingleResultSet mode (#282).
            2026.03.11   - Fix empty-data RS 3 schema mismatch (#304): 7 columns -> 17 columns
                         matching production RS 3 (Run Health Summary).
            2026.03.10.2 - RS 13 forced plan awareness (#292): ForcedPlanCount column, PlanTrend
                         distinguishes 'MORE PLANS (forced plan at risk)' from generic proliferation.
                         I8 recommendation warns when degrading stats have forced plans.
                         Cross-database sys.query_store_plan lookup (graceful on QS-disabled DBs).
            2026.03.10.1 - @GradeOverrides and @GradeWeights parameters for Executive Dashboard.
                         Force grades (RELIABILITY=A), exclude categories (SPEED=IGNORE),
                         or change weights (COMPLETION=50, auto-normalized to 100%).
                         I6 QS_EFFICACY: graceful message when QS runs exist but no CPU data
                         (was emitting question marks).
            2026.03.10   - DECLARE-in-loop fix for @map_table_msg variable.
                         RAISERROR decode query output when @ObfuscationMapTable is used.
            2026.03.09.3 - W6 EXCESSIVE_OVERHEAD diagnostic check: flags runs where discovery/environment
                         overhead exceeds 40% of wall-clock time.
                         PAGE compression on StatUpdateDiagHistory PK and IX.
            2026.03.09.2 - I8 silent failure: inserts INFO recommendation when no QS CPU data exists (#239).
                         @SingleResultSet=1 auto-promotes @ExpertMode=1 for stable ResultSetID contract (#236).
            2026.03.09.1 - RunLabel dedup prevents PK violation on duplicate START entries (#216).
                         Watermark gap detection resets when CommandLog archived (#232).
                         I5 VERSION_HISTORY implemented (was documented but missing).
                         I8 QS_PERFORMANCE_TREND: per-stat per-execution CPU trend.
                         StatUpdateDiagCache persistent table avoids XML re-parse.
                         New @Help note for automation / @SingleResultSet.
            2026.03.08.1 - Executive Dashboard (RS 1): letter grades A-F, health score 0-100,
                         5 categories (Overall, Completion, Reliability, Speed, Workload Focus).
                         @ExpertMode parameter: 0 = management view (2 RS), 1 = DBA deep-dive (13 RS).
                         Persistent history table (dbo.StatUpdateDiagHistory) with watermark-based
                         incremental inserts. @SkipHistory parameter to opt out.
                         QS Performance Correlation (I8 + RS 13): per-stat CPU trend detail.
                         QS Efficacy Trending (I6/I7 + RS 10/11/12): weekly aggregates,
                         per-run detail, high-CPU stat positions.
                         RS renumbered: RS 1 = Dashboard, RS 2 = Recommendations (always),
                         RS 3-13 = ExpertMode=1 only.
            2026.03.06   - Security/correctness: SQL injection fix in @CommandLogDatabase,
                         missing AG keyword in @Help, parameter validation warnings.
                         12 bug fixes from SME review (BUG-01 through BUG-12).
                         @ObfuscationSeed and @ObfuscationMapTable parameters for
                         deterministic, reproducible obfuscation across runs.
                         @Help enhanced with valid_inputs, examples, operational notes.
            2026.03.04.1 - Version format adopted CalVer (YYYY.MM.DD).
                         @SingleResultSet parameter: wraps all output into one table with
                         stable ResultSetID column for INSERT...EXEC automation.
                         Fix: empty-data path respects @SingleResultSet + @Obfuscate.
            2026.02.12   - Initial release. 8 diagnostic checks (C1-C4, W1-W5, I1-I4),
                         obfuscation mode, @Help, @Debug.
                         9 result sets. 53 tests.

Requires:   - dbo.CommandLog table (Ola Hallengren's SQL Server Maintenance Solution)
            - sp_StatUpdate entries in CommandLog (SP_STATUPDATE_START/END + UPDATE_STATISTICS)
            - SQL Server 2017+ (STRING_AGG; STRING_SPLIT is 2016+ but STRING_AGG requires 2017+)

Key Features:
    - Executive Dashboard with A-F grades and health scores
    - 16 diagnostic checks across CRITICAL/WARNING/INFO severities
    - Obfuscation mode for safe external sharing (HASHBYTES-based)
    - Persistent history for trend tracking (dbo.StatUpdateDiagHistory)
    - Persistent stat cache for fast re-runs (dbo.StatUpdateDiagCache)
    - Query Store efficacy analysis (proves QS prioritization value)
    - @ExpertMode: management view (2 RS) vs DBA deep-dive (13 RS)
    - @SingleResultSet for stable automation interface

Usage:      -- Quick health check (management dashboard):
            EXECUTE dbo.sp_StatUpdate_Diag;

            -- Full DBA deep-dive:
            EXECUTE dbo.sp_StatUpdate_Diag @ExpertMode = 1;

            -- Obfuscated for sharing externally:
            EXECUTE dbo.sp_StatUpdate_Diag @Obfuscate = 1;

            -- Custom analysis window:
            EXECUTE dbo.sp_StatUpdate_Diag @DaysBack = 90, @Debug = 1;

            -- CommandLog in a different database:
            EXECUTE dbo.sp_StatUpdate_Diag @CommandLogDatabase = N'DBATools';
*/

IF OBJECT_ID(N'dbo.sp_StatUpdate_Diag', N'P') IS NULL
BEGIN
    EXECUTE (N'CREATE PROCEDURE dbo.sp_StatUpdate_Diag AS RETURN 138;');
END;
GO

ALTER PROCEDURE
    dbo.sp_StatUpdate_Diag
(
    @DaysBack integer = 30,                     /* history window in days */
    @CommandLogDatabase sysname = NULL,          /* NULL = current DB */
    @Obfuscate bit = 0,                         /* 0 = real names, 1 = hashed names */
    @ObfuscationSeed nvarchar(128) = NULL,       /* salt for HASHBYTES -- makes tokens unpredictable without seed */
    @ObfuscationMapTable sysname = NULL,          /* persist obfuscation map to this table (auto-creates if missing) */
    @LongRunningMinutes integer = 10,            /* threshold for "long-running stat" detection */
    @FailureThreshold integer = 3,               /* same stat failing N+ times = CRITICAL */
    @TimeLimitExhaustionPct integer = 80,         /* warn if >X% of runs hit time limit */
    @ThroughputWindowDays integer = 7,            /* window size for throughput trend comparison */
    @TopN integer = 20,                           /* top N items in detail result sets */
    @EfficacyDaysBack integer = NULL,              /* QS efficacy trending window (NULL = @DaysBack) */
    @EfficacyDetailDays integer = NULL,            /* QS efficacy close-up window (NULL = 14 or @EfficacyDaysBack) */
    @ExpertMode bit = 0,                           /* 0 = Executive Dashboard + Recommendations (management view), 1 = all result sets (DBA view) */
    @SkipHistory bit = 0,                          /* 1 = skip reading/writing dbo.StatUpdateDiagHistory (for testing or transient installs) */
    @GradeOverrides nvarchar(500) = NULL,          /* force grades or IGNORE categories: 'RELIABILITY=A, SPEED=IGNORE' */
    @GradeWeights nvarchar(500) = NULL,            /* custom category weights (auto-normalized): 'COMPLETION=40, WORKLOAD=40' */
    @Help bit = 0,
    @Debug bit = 0,
    @SingleResultSet bit = 0,       /* 0 = default multi-result-set, 1 = single result set with ResultSetID/RowData */
    @Version varchar(20) = NULL OUTPUT,
    @VersionDate datetime = NULL OUTPUT
)
WITH RECOMPILE
AS
BEGIN
    SET NOCOUNT ON;
    SET XACT_ABORT ON;

    /*
    ============================================================================
    VERSION AND CONSTANTS
    ============================================================================
    */
    DECLARE
        @procedure_version varchar(20) = '2026.07.03.1',  /* orchestrator bumps this */
        @procedure_version_date datetime = '20260703';     /* orchestrator bumps this */

    SET @Version = @procedure_version;
    SET @VersionDate = @procedure_version_date;

    /* Debug timing baseline */
    DECLARE @debug_timer datetime2(3) = SYSDATETIME();
    DECLARE @debug_elapsed_ms integer;

    /*
    ============================================================================
    HELP
    ============================================================================
    */
    IF @Help = 1
    BEGIN
        /* Result set 1: Parameters */
        SELECT
            help_topic = N'Parameters',
            parameter_name = parameter_name,
            data_type = data_type,
            description = description,
            valid_inputs = valid_inputs,
            defaults = default_value
        FROM
        (
            VALUES
                (N'@DaysBack',                 N'integer',  N'History window in days -- how far back to scan CommandLog',
                    N'1-3650', N'30'),
                (N'@CommandLogDatabase',        N'sysname',  N'Database containing dbo.CommandLog table. NULL = current database context.',
                    N'NULL, database name (e.g., DBATools, master)', N'NULL (current database)'),
                (N'@Obfuscate',                N'bit',      N'Hash database/schema/table/stat names for safe external sharing. Uses HASHBYTES MD5. Obfuscation map returned as result set 8 (multi-result-set mode only).',
                    N'0, 1', N'0'),
                (N'@ObfuscationSeed',          N'nvarchar(128)', N'Salt prepended to names before hashing. Makes tokens unpredictable without the seed but deterministic across runs/servers with the same seed. NULL = unsalted (backward compatible).',
                    N'NULL, any string up to 128 chars', N'NULL'),
                (N'@ObfuscationMapTable',      N'sysname',  N'Persist obfuscation map to this table (auto-creates if missing, merges new entries on subsequent runs). Enables saving the map on prod while exporting only obfuscated results. Requires @Obfuscate=1.',
                    N'NULL, table name (e.g., dbo.DiagMap, tempdb.dbo.diag_map)', N'NULL'),
                (N'@LongRunningMinutes',        N'integer',  N'Stats taking longer than this (in minutes) are flagged in W2 check and Long-Running Statistics result set',
                    N'1-N minutes', N'10'),
                (N'@FailureThreshold',          N'integer',  N'Same statistic failing this many times across runs triggers C2 CRITICAL finding',
                    N'1-N', N'3'),
                (N'@TimeLimitExhaustionPct',    N'integer',  N'If more than this percentage of runs hit TIME_LIMIT stop reason, triggers C3 CRITICAL finding',
                    N'1-100', N'80'),
                (N'@ThroughputWindowDays',      N'integer',  N'Compare recent N days throughput against prior window for C4 degrading throughput detection',
                    N'1-@DaysBack', N'7'),
                (N'@TopN',                     N'integer',  N'Maximum rows returned in detail result sets (Top Tables, Failing Stats, Long-Running Stats)',
                    N'1-1000', N'20'),
                (N'@EfficacyDaysBack',         N'integer',  N'Broad window for QS efficacy trending (weekly aggregates). NULL inherits from @DaysBack.',
                    N'NULL, 1-3650', N'NULL (= @DaysBack)'),
                (N'@EfficacyDetailDays',       N'integer',  N'Close-up window for run-over-run efficacy detail. NULL defaults to 14 or @EfficacyDaysBack if smaller.',
                    N'NULL, 1-@EfficacyDaysBack', N'NULL (= min(14, @EfficacyDaysBack))'),
                (N'@ExpertMode',              N'bit',      N'0 = Executive Dashboard + Recommendations only (management-friendly, show this to leadership). 1 = All result sets including technical detail (DBA deep-dive). Inspired by sp_Blitz @ExpertMode.',
                    N'0, 1', N'0'),
                (N'@SkipHistory',             N'bit',      N'1 = Skip reading/writing dbo.StatUpdateDiagHistory persistent table. Useful for transient installs, testing, or when you do not want permanent tables created.',
                    N'0, 1', N'0'),
                (N'@GradeOverrides',         N'nvarchar(500)', N'Force dashboard grades or ignore categories. Comma-separated CATEGORY=VALUE pairs. Categories: COMPLETION, RELIABILITY, SPEED, WORKLOAD. Values: A/B/C/D/F (force grade) or IGNORE (exclude from OVERALL). Example: ''RELIABILITY=A, SPEED=IGNORE'' -- forces Reliability to A, excludes Speed from the overall score.',
                    N'NULL, comma-separated pairs (e.g., ''RELIABILITY=A'', ''SPEED=IGNORE, WORKLOAD=B'')', N'NULL'),
                (N'@GradeWeights',           N'nvarchar(500)', N'Custom category weights for OVERALL score. Comma-separated CATEGORY=WEIGHT pairs. Integers, auto-normalized to sum to 100%. Omitted categories keep default weight. Weight of 0 = same as IGNORE. Defaults: COMPLETION=30, RELIABILITY=25, SPEED=20, WORKLOAD=25.',
                    N'NULL, comma-separated pairs (e.g., ''COMPLETION=50'', ''COMPLETION=40, WORKLOAD=40, SPEED=20'')', N'NULL'),
                (N'@Help',                     N'bit',      N'Show this help output and return immediately',
                    N'0, 1', N'0'),
                (N'@Debug',                    N'bit',      N'Verbose diagnostic output -- shows intermediate temp table counts and timing',
                    N'0, 1', N'0'),
                (N'@SingleResultSet',          N'bit',      N'Collapse all result sets into one with columns (ResultSetID, ResultSetName, RowNum, RowData). RowData is JSON. Enables INSERT...EXEC capture in automation. Auto-promotes @ExpertMode=1 so ResultSetIDs 1-13 are always present.',
                    N'0, 1', N'0'),
                (N'@Version',                  N'varchar(20)', N'OUTPUT: returns procedure version string (e.g., 2026.03.04)',
                    N'OUTPUT', N'OUTPUT'),
                (N'@VersionDate',              N'datetime', N'OUTPUT: returns procedure version date',
                    N'OUTPUT', N'OUTPUT')
        ) AS v (parameter_name, data_type, description, valid_inputs, default_value);

        /* Result set 2: Diagnostic checks */
        SELECT
            help_topic = N'Diagnostic Checks',
            check_id = check_id,
            severity = severity,
            category = category,
            description = description
        FROM
        (
            VALUES
                (N'C1', N'CRITICAL', N'KILLED_RUNS',           N'START without matching END (orphaned/killed runs)'),
                (N'C2', N'CRITICAL', N'REPEATED_FAILURES',     N'Same statistic failing consistently across runs'),
                (N'C3', N'CRITICAL', N'TIME_LIMIT_EXHAUSTION', N'Majority of runs hitting TIME_LIMIT with stats remaining'),
                (N'C4', N'CRITICAL', N'DEGRADING_THROUGHPUT',  N'Average seconds-per-stat increasing over time'),
                (N'W1', N'WARNING',  N'SUBOPTIMAL_PARAMS',     N'Parameter choices that may reduce effectiveness'),
                (N'W2', N'WARNING',  N'LONG_RUNNING_STATS',    N'Individual stats consistently exceeding threshold'),
                (N'W3', N'WARNING',  N'STALE_BACKLOG',         N'Persistent backlog of unprocessed qualifying stats'),
                (N'W4', N'WARNING',  N'OVERLAPPING_RUNS',      N'Multiple runs active simultaneously'),
                (N'W5', N'WARNING',  N'QS_NOT_EFFECTIVE',      N'Query Store priority enabled but no QS data captured'),
                (N'I9b', N'INFO',     N'QS_PARALLEL_UNRELIABLE', N'W5 emitted INFO when QS-priority runs are all parallel AND QS CPU data IS present in stat updates -- per-worker ProcessingPosition counters make the zero-QSPlanCount-runs signal unreliable in parallel mode, so this softer note replaces the WARNING.'),
                (N'W6', N'WARNING',  N'EXCESSIVE_OVERHEAD',    N'Discovery/environment checks consuming disproportionate time vs actual UPDATE STATISTICS'),
                (N'W7', N'WARNING',  N'HIGH_IMPACT_STATS_DEPRIORITIZED', N'High workload-impact stats consistently processed late in the run -- sort order may not match workload'),
                (N'W8', N'WARNING',  N'MOPUP_INEFFECTIVE',     N'Mop-up passes repeatedly find 0 qualifying stats -- pure discovery overhead'),
                (N'W9', N'WARNING',  N'LOCK_TIMEOUT_INEFFECTIVE', N'Same stat hits lock timeout (error 1222) across 3+ runs -- persistent blocking victim'),
                (N'W10', N'WARNING', N'PARAMETER_CHURN',       N'Parameters changed frequently across recent runs -- unstable configuration'),
                (N'C5', N'CRITICAL', N'SAMPLE_RATE_DEGRADATION', N'Effective sample rates trending down on large stats -- estimate quality at risk'),
                (N'C6', N'CRITICAL', N'SILENT_NOOP_RUN',        N'Run self-reported normal completion (PARALLEL_COMPLETE/COMPLETED) with StatsFound > 0 but zero stats processed across the worker window -- zombied parallel queue or claim-nothing failure masquerading as success'),
                (N'I9', N'INFO',     N'WORKLOAD_CONCENTRATION', N'Few tables drive most measured query CPU -- prioritization opportunity'),
                (N'I11', N'INFO',    N'FAILURE_CLUSTERING',    N'Failures cluster on one dominant ErrorNumber -- single root cause likely'),
                (N'I12', N'INFO',    N'QS_COVERAGE_DRIFT',     N'QS workload coverage percentage trending down across runs'),
                (N'I13', N'INFO',    N'PARALLEL_OPPORTUNITY',  N'Serial runs are long enough that @StatsInParallel would cut wall-clock time'),
                (N'I14', N'INFO',    N'MOPUP_MISSING_PAGECOUNT', N'Mop-up discovered stats lack page counts -- size-aware ordering unavailable in mop-up'),
                (N'I1', N'INFO',     N'RUN_HEALTH',            N'Completion rate, duration trend, StopReason distribution'),
                (N'I2', N'INFO',     N'PARAMETER_HISTORY',     N'How parameters changed across runs'),
                (N'I3', N'INFO',     N'TOP_TABLES',            N'Tables consuming the most maintenance time'),
                (N'I4', N'INFO',     N'UNUSED_FEATURES',       N'Available features not being used'),
                (N'I5', N'INFO/WARNING', N'VERSION_HISTORY',    N'sp_StatUpdate versions used across analysis window. WARNING if multiple versions detected (version skew).'),
                (N'I6', N'INFO',     N'QS_EFFICACY',           N'Query Store prioritization effectiveness -- what % of high-workload stats get serviced early'),
                (N'I7', N'INFO',     N'QS_INFLECTION',         N'Before/after comparison when sort order changed to Query Store-based prioritization'),
                (N'I8', N'INFO',     N'QS_PERFORMANCE_TREND',  N'Per-stat per-execution query CPU trend -- are queries getting faster after stat updates? Detects forced plans at risk (#292). Finding text always ends with a machine-readable [DataStatus: AVAILABLE|INSUFFICIENT_HISTORY|UNAVAILABLE; QSCpuRuns: N; TrackedStats: N] suffix when data is sparse (w5p2).'),
                (N'I10', N'INFO',    N'RECOMMENDED_CONFIG',    N'Synthesized parameter set balancing immediate fixes, long-term safeguards, and historical parameter usage.  Based on diagnostic findings and parameter change history.'),
                (N'W11', N'WARNING', N'MOPUP_LOW_YIELD',       N'Mop-up pass consistently unable to process most of the stats it discovers (avg <50% yield across 3+ runs).'),
                (N'W12', N'WARNING', N'PRIORITY_PASS_EMPTY',   N'Priority pass averages <5 stats across 3+ mop-up runs -- mop-up is doing all the work.  Lower @ModificationThreshold so the priority pass captures more stats.'),
                (N'I15', N'INFO',    N'HEAP_TIME_BUDGET',      N'Heap tables account for >50% of total maintenance time.  @CollectHeapForwarding and heap REBUILD may help.'),
                (N'W13', N'WARNING', N'PERPETUALLY_SKIPPED',   N'Stats consistently discovered but never updated across N consecutive runs due to time limits.  Increase @TimeLimit, lower @ModificationThreshold, or use @SortOrder=MODIFICATION_VELOCITY.'),
                (N'W14', N'WARNING', N'RECURRING_SAFETY_STOP', N'The same safety-stop StopReason (TEMPDB_PRESSURE, AG_REDO_QUEUE, LOG_SPACE_HIGH, IO_CORRUPTION, FAIL_FAST, CONSECUTIVE_FAILURES, BATCH_LIMIT) appears in >= 2 runs within the analysis window.  Each recurring reason produces one finding row with reason-specific remediation. (4g9s)'),
                (N'W15', N'WARNING', N'RECURRING_RUNTIME_WARNING', N'An environmental/actionable WarningsCodes token from END Summary XML appears in >= 3 runs or >= 50%% of runs.  Codes: BACKUP_RUNNING, BACKUP_STARTED_MID_RUN, LOG_SPACE_HIGH, IO_CORRUPTION, CONTAINER_MEMORY, RCSI_VERSION_STORE, ELASTIC_POOL, PEAK_HOURS, STOPBYTIME_OVERSHOOT, CONSECUTIVE_FAILURES_ELEVATED, PERSIST_SAMPLE_INADEQUATE, PARALLEL_ORPHAN_BACKLOG, STALE_QUEUE_SWEEP, DB_SKIPPED, BACKUP_STARTED_MID_RUN.  Old runs without WarningsCodes produce no findings. (t8lj)'),
                (N'W16', N'WARNING', N'CRITICAL_TABLES_NO_MATCH', N'@CriticalTables is configured (non-NULL) in a recent non-killed run but ZERO stat rows in that run carry IsCritical=1.  The pattern matched nothing -- a silent misconfiguration.  Verify the LIKE patterns match actual table names and that the parameter was logged by a v3.5.0+ sp_StatUpdate version. (sw82)'),
                (N'I16', N'INFO',    N'RECURRING_RUNTIME_WARNING', N'A purely informational WarningsCodes token appears in >= 3 runs or >= 50%% of runs.  Codes: CDC_TABLES, REPLICATION_MAJORITY, COLUMNSTORE_TABLES, RLS_DETECTED, FILTER_MISMATCH, CASE_SENSITIVE_COLLATION, AZURE_SQL_DB/MI/EDGE, LOW_UPTIME, TOCTOU_SKIPS, EMPTY_STRING_PARAM, DEAD_WORKER_TIMEOUT_NULL_COERCED, and any unrecognized codes.  Old runs without WarningsCodes produce no findings. (t8lj)'),
                (N'I17', N'INFO',    N'CRITICAL_TABLES_COVERAGE', N'@CriticalTables is configured and critical stats exist in the analysis window.  Leadership-friendly summary: count of critical stats updated, avg ProcessingPosition when CriticalTablesFirst=Y (early positions prove the priority worked), count with CriticalSampleOverride applied. (sw82)')
        ) AS v (check_id, severity, category, description);

        /* Result set 3: Result set order */
        SELECT
            help_topic = N'Result Sets',
            result_set_number = rs_num,
            name = rs_name,
            description = rs_desc
        FROM
        (
            VALUES
                (1, N'Executive Dashboard',        N'ALWAYS returned first. Letter-graded categories (A-F) with plain English headlines for management. One row per category: Overall, Completion, Reliability, Speed, Workload Coverage. Inspired by sp_Blitz priority system.'),
                (2, N'Recommendations',            N'Severity-categorized findings with parameter suggestions. Returned with @ExpertMode=0 (management view).'),
                (3, N'Run Health Summary',          N'Aggregate metrics across all runs. Requires @ExpertMode=1.'),
                (4, N'Run Detail',                  N'Per-run metrics. Requires @ExpertMode=1.'),
                (5, N'Top Tables',                  N'Top N tables by total update duration. Requires @ExpertMode=1.'),
                (6, N'Failing Statistics',           N'Stats with errors, grouped. Requires @ExpertMode=1.'),
                (7, N'Long-Running Statistics',      N'Stats exceeding threshold. Requires @ExpertMode=1.'),
                (8, N'Parameter Change History',     N'Parameter values across runs. Requires @ExpertMode=1.'),
                (9, N'Obfuscation Map (conditional)', N'Only when @Obfuscate=1. Requires @ExpertMode=1.'),
                (10, N'Efficacy Trend (Weekly)',       N'Weekly QS efficacy metrics: high-workload coverage, completion %, throughput trend. Requires @ExpertMode=1.'),
                (11, N'Efficacy Detail (Per-Run)',    N'Per-run QS efficacy for close-up window (@EfficacyDetailDays). Requires @ExpertMode=1.'),
                (12, N'High-CPU Stat Positions',      N'Top-workload stats from most recent run with their processing positions. Requires @ExpertMode=1.'),
                (13, N'QS Performance Correlation',   N'Per-stat Query Store CPU, memory grant, and tempdb trend across runs. Shows whether queries get faster and use less memory after stat updates. Requires @ExpertMode=1.'),
                (0, N'Unified Result Set',            N'When @SingleResultSet=1: one result set with ResultSetID, ResultSetName, RowNum, RowData (JSON). Replaces all result sets.')
        ) AS v (rs_num, rs_name, rs_desc);

        /* Result set 4: Examples */
        SELECT
            help_topic = N'Examples',
            example_name = example_name,
            example_description = example_description,
            example_code = example_code
        FROM
        (
            VALUES
                (
                    N'Quick Health Check',
                    N'Run with defaults against current database CommandLog',
                    N'EXECUTE dbo.sp_StatUpdate_Diag;'
                ),
                (
                    N'Obfuscated for Sharing',
                    N'Hash all object names for safe sharing with consultants or support',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @Obfuscate = 1;'
                ),
                (
                    N'Extended History',
                    N'Analyze 90 days of history with debug output',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @DaysBack = 90, @Debug = 1;'
                ),
                (
                    N'Remote CommandLog',
                    N'CommandLog lives in a central DBA database',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @CommandLogDatabase = N''DBATools'';'
                ),
                (
                    N'Strict Failure Detection',
                    N'Flag stats failing 2+ times, long-running at 5 min',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @FailureThreshold = 2, @LongRunningMinutes = 5;'
                ),
                (
                    N'Automation Capture',
                    N'Single result set for INSERT...EXEC or PowerShell capture',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @SingleResultSet = 1;'
                ),
                (
                    N'Secure Obfuscated Export',
                    N'Save map on prod, export only obfuscated results for external analysis',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @Obfuscate = 1, @SingleResultSet = 1, @ObfuscationSeed = N''MySecretSeed'', @ObfuscationMapTable = N''dbo.DiagObfuscationMap'';'
                ),
                (
                    N'QS Efficacy Report',
                    N'Show 100-day QS prioritization effectiveness with 14-day close-up',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @EfficacyDaysBack = 100, @EfficacyDetailDays = 14;'
                ),
                (
                    N'Multi-Server (PowerShell)',
                    N'Use Invoke-StatUpdateDiag.ps1 for cross-server analysis',
                    N'.\Invoke-StatUpdateDiag.ps1 -Servers "Server1","Server2" -OutputFormat Markdown -OutputPath C:\Reports'
                )
        ) AS example_data (example_name, example_description, example_code);

        /* Result set 5: Operational Notes */
        SELECT
            help_topic = N'Operational Notes',
            topic = topic,
            detail = detail
        FROM
        (
            VALUES
                (N'Obfuscation',
                 N'@Obfuscate=1 replaces names with MD5 hashes (e.g., DB_a1b2c3, TBL_d4e5f6). Prefixes preserved for readability. Map is result set 8 in multi-result-set mode (excluded from @SingleResultSet=1 to prevent leaking real names). Use @ObfuscationMapTable to persist the map on prod. Use @ObfuscationSeed to salt hashes -- makes tokens stable across servers with the same seed but unpredictable without it.'),
                (N'Killed Run Detection',
                 N'Two detection methods: (1) SP_STATUPDATE_START without matching SP_STATUPDATE_END = orphaned run, (2) SP_STATUPDATE_END with StopReason=KILLED = cleaned up by @CleanupOrphanedRuns. Both trigger C1 CRITICAL.'),
                (N'Throughput Trend (C4)',
                 N'Compares average seconds-per-stat in the recent @ThroughputWindowDays against the prior window of equal length. If recent average is >50% worse, triggers C4 CRITICAL. Data-dependent -- requires sufficient runs in both windows.'),
                (N'Overlapping Runs (W4)',
                 N'Detects concurrent sp_StatUpdate executions by checking for overlapping StartTime/EndTime ranges. Excludes killed runs to prevent false positives from orphan-cleanup END records.'),
                (N'SingleResultSet Mode',
                 N'@SingleResultSet=1 wraps all 8 result sets into one table with columns: ResultSetID (int), ResultSetName (nvarchar), RowNum (int), RowData (nvarchar(max) as JSON). Use OPENJSON(RowData) to parse. Enables INSERT...EXEC patterns that fail with multiple result sets.'),
                (N'CommandLog Requirements',
                 N'Requires Ola Hallengren''s dbo.CommandLog table with sp_StatUpdate entries (CommandType IN SP_STATUPDATE_START, SP_STATUPDATE_END, UPDATE_STATISTICS). No data = no diagnostics (graceful empty result sets). @CommandLogDatabase lets you point to a central logging database.'),
                (N'PowerShell Wrapper',
                 N'Invoke-StatUpdateDiag.ps1 runs sp_StatUpdate_Diag across multiple servers in parallel, detects version skew and parameter inconsistencies, and generates Markdown/HTML/JSON reports. Use -Obfuscate for safe sharing.'),
                (N'Automation / Stable Result Sets',
                 N'The number of result sets varies by @ExpertMode (2 vs 12-13) and @Obfuscate (shifts RS9). For automation, use @SingleResultSet=1 -- it wraps all output into one table with a stable ResultSetID column (values 1-13). This makes INSERT...EXEC reliable regardless of parameter combinations.')
        ) AS notes (topic, detail);

        /* Result set 6: Grading Scale */
        SELECT
            help_topic = N'Grading Scale',
            grade = grade,
            score_range = score_range,
            meaning = meaning
        FROM
        (
            VALUES
                (N'A', N'90-100', N'Excellent -- statistics maintenance is healthy and effective'),
                (N'B', N'75-89',  N'Good -- minor improvements possible but no urgent issues'),
                (N'C', N'60-74',  N'Fair -- noticeable gaps or inefficiencies that deserve attention'),
                (N'D', N'40-59',  N'Poor -- significant problems impacting maintenance quality'),
                (N'F', N'0-39',   N'Failing -- critical issues requiring immediate action')
        ) AS v (grade, score_range, meaning);

        SELECT
            help_topic = N'Grading Scale',
            category = category,
            default_weight = default_weight,
            what_it_measures = what_it_measures
        FROM
        (
            VALUES
                (N'COMPLETION',  N'30%', N'What percentage of qualifying stats get updated each run'),
                (N'RELIABILITY', N'25%', N'Absence of killed runs, failures, and orphaned entries'),
                (N'SPEED',       N'20%', N'Average seconds per stat update -- are updates fast enough'),
                (N'WORKLOAD',    N'25%', N'Are high-CPU stats prioritized early (requires @QueryStore = CPU in v3, @QueryStorePriority=Y in v2)')
        ) AS v (category, default_weight, what_it_measures);

        /* Result set 7: Prerequisites and Known Limitations */
        SELECT
            help_topic = N'Prerequisites and Limitations',
            topic = topic,
            detail = detail
        FROM
        (
            VALUES
                (N'SQL Server Version',
                 N'Requires SQL Server 2016+ (STRING_SPLIT dependency).  Best on 2017+ for STRING_AGG.'),
                (N'CommandLog Table',
                 N'Requires dbo.CommandLog from Ola Hallengren''s Maintenance Solution.  sp_StatUpdate writes SP_STATUPDATE_START, SP_STATUPDATE_END, and UPDATE_STATISTICS entries.  No CommandLog = no diagnostics.'),
                (N'sp_StatUpdate Version',
                 N'Full feature support requires sp_StatUpdate v2.16+ (ProcessingPosition in ExtendedInfo for RS 12).  QS efficacy requires QS-enabled runs (@QueryStore in v3, @QueryStorePriority=Y in v2).  Legacy runs (pre-RunLabel) are supported with synthetic labels.'),
                (N'INSERT...EXEC Limitation',
                 N'@SingleResultSet=1 auto-enables @SkipHistory=1 because SQL Server''s INSERT...EXEC creates an implicit transaction that prevents persistent table writes.  @ObfuscationMapTable writes are attempted but may silently fail in this context.'),
                (N'Obfuscation Map Security',
                 N'@SingleResultSet=1 excludes the obfuscation map from RowData to prevent leaking real names in the unified output.  Use @ObfuscationMapTable to persist the map separately.'),
                (N'WORKLOAD Grade Without QS',
                 N'If no runs use QS prioritization (@QueryStore in v3, @QueryStorePriority=Y in v2), the WORKLOAD category scores a neutral 50/100 (grade C).  Enable QS prioritization for meaningful workload grades.')
        ) AS v (topic, detail);

        /* Result set 8: Additional Examples */
        SELECT
            help_topic = N'Grade Override Examples',
            example_name = example_name,
            example_description = example_description,
            example_code = example_code
        FROM
        (
            VALUES
                (
                    N'Override Reliability Grade',
                    N'Force Reliability to A (you know the killed runs are from planned maintenance)',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @GradeOverrides = N''RELIABILITY=A'';'
                ),
                (
                    N'Ignore Workload (No QS)',
                    N'Exclude Workload from Overall score when QS is not used',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @GradeOverrides = N''WORKLOAD=IGNORE'';'
                ),
                (
                    N'Custom Weights',
                    N'Weight Completion and Reliability heavily, reduce Speed importance',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @GradeWeights = N''COMPLETION=40, RELIABILITY=35, SPEED=5, WORKLOAD=20'';'
                ),
                (
                    N'Combined Override + Weights',
                    N'Force Reliability=A and reweight remaining categories',
                    N'EXECUTE dbo.sp_StatUpdate_Diag @GradeOverrides = N''RELIABILITY=A'', @GradeWeights = N''COMPLETION=50, SPEED=25, WORKLOAD=25'';'
                )
        ) AS v (example_name, example_description, example_code);

        /* Result set 9: Version History */
        SELECT
            help_topic = N'Version History',
            version_date = version_date,
            changes = changes
        FROM
        (
            VALUES
                (N'2026.03.23', N'NULL RunLabel fix, INSERT...EXEC safety, ObfuscationMapTable dedup, nvarchar overflow fixes, enhanced debug output, improved @Help'),
                (N'2026.03.20', N'26-issue bulk resolution: workload impact, check improvements, AG detection, 15 new tests'),
                (N'2026.03.13', N'RS 12 WorkloadRank fix, RS 11 DeltaVsPrior fix in SingleResultSet mode'),
                (N'2026.03.11', N'Empty-data RS 3 schema mismatch fix'),
                (N'2026.03.09', N'RunLabel dedup, QS efficacy, executive dashboard, persistent history')
        ) AS v (version_date, changes);

        RETURN;
    END;

    /*
    ============================================================================
    RUNTIME VERSION GUARD (BUG-02: STRING_AGG requires SQL Server 2017+)
    ============================================================================
    */
    IF CAST(SERVERPROPERTY('ProductMajorVersion') AS integer) < 14
    BEGIN
        RAISERROR(N'sp_StatUpdate_Diag requires SQL Server 2017 or later (STRING_AGG).', 16, 1);
        RETURN;
    END;

    /* #296: AG secondary replica detection -- warn that CommandLog may reflect primary-side maintenance only */
    DECLARE @ag_replica_role nvarchar(20) = NULL;
    BEGIN TRY
        SELECT TOP (1)
            @ag_replica_role = CASE ars.role
                WHEN 1 THEN N'PRIMARY'
                WHEN 2 THEN N'SECONDARY'
                ELSE N'UNKNOWN'
            END
        FROM sys.dm_hadr_availability_replica_states AS ars
        WHERE ars.is_local = 1
        ORDER BY ars.role;

        IF @ag_replica_role = N'SECONDARY'
            RAISERROR(N'WARNING: Running on AG secondary replica -- CommandLog data may reflect primary-side maintenance only.', 10, 1) WITH NOWAIT;
    END TRY
    BEGIN CATCH
        /* Non-AG instances don''t have the DMV -- silently ignore */
        SET @ag_replica_role = NULL;
    END CATCH;

    /*
    ============================================================================
    PARAMETER VALIDATION
    ============================================================================
    */
    DECLARE @errors nvarchar(max) = N'';

    IF @DaysBack < 1 OR @DaysBack > 3650
        SET @errors = @errors + N'@DaysBack must be between 1 and 3650. ';

    IF @LongRunningMinutes < 1
        SET @errors = @errors + N'@LongRunningMinutes must be >= 1. ';

    IF @FailureThreshold < 1
        SET @errors = @errors + N'@FailureThreshold must be >= 1. ';

    IF @TimeLimitExhaustionPct < 1 OR @TimeLimitExhaustionPct > 100
        SET @errors = @errors + N'@TimeLimitExhaustionPct must be between 1 and 100. ';

    IF @ThroughputWindowDays < 1 OR @ThroughputWindowDays > @DaysBack
        SET @errors = @errors + N'@ThroughputWindowDays must be between 1 and @DaysBack. ';

    IF @TopN < 1 OR @TopN > 1000
        SET @errors = @errors + N'@TopN must be between 1 and 1000. ';

    /* Default @EfficacyDaysBack from @DaysBack; @EfficacyDetailDays from min(14, efficacy window) */
    SET @EfficacyDaysBack = ISNULL(@EfficacyDaysBack, @DaysBack);
    SET @EfficacyDetailDays = ISNULL(@EfficacyDetailDays, CASE WHEN @EfficacyDaysBack < 14 THEN @EfficacyDaysBack ELSE 14 END);

    IF @EfficacyDaysBack < 1 OR @EfficacyDaysBack > 3650
        SET @errors = @errors + N'@EfficacyDaysBack must be between 1 and 3650. ';

    IF @EfficacyDetailDays < 1 OR @EfficacyDetailDays > @EfficacyDaysBack
        SET @errors = @errors + N'@EfficacyDetailDays must be between 1 and @EfficacyDaysBack. ';

    IF @Obfuscate = 0 AND @ObfuscationMapTable IS NOT NULL
        RAISERROR(N'WARNING: @ObfuscationMapTable is ignored when @Obfuscate = 0.', 10, 1) WITH NOWAIT;

    IF @Obfuscate = 0 AND @ObfuscationSeed IS NOT NULL
        RAISERROR(N'WARNING: @ObfuscationSeed is ignored when @Obfuscate = 0.', 10, 1) WITH NOWAIT;

    /* ---- Grade Override / Weight parsing ---- */
    DECLARE
        @override_completion  char(1) = NULL,  /* NULL=computed, A-F=forced, X=IGNORE */
        @override_reliability char(1) = NULL,
        @override_speed       char(1) = NULL,
        @override_workload    char(1) = NULL,
        @weight_completion    decimal(5, 2) = 30.0,
        @weight_reliability   decimal(5, 2) = 25.0,
        @weight_speed         decimal(5, 2) = 20.0,
        @weight_workload      decimal(5, 2) = 25.0,
        @has_overrides        bit = 0;

    IF @GradeOverrides IS NOT NULL
    BEGIN
        SET @has_overrides = 1;

        /* #302: Set-based parsing (replaces cursor) */
        DECLARE @go_parsed TABLE (pair nvarchar(100), cat nvarchar(50), val nvarchar(50));
        INSERT INTO @go_parsed (pair, cat, val)
        SELECT
            pair = LTRIM(RTRIM(s.value)),
            cat  = UPPER(LTRIM(RTRIM(LEFT(LTRIM(RTRIM(s.value)), CHARINDEX(N'=', LTRIM(RTRIM(s.value))) - 1)))),
            val  = UPPER(LTRIM(RTRIM(SUBSTRING(LTRIM(RTRIM(s.value)), CHARINDEX(N'=', LTRIM(RTRIM(s.value))) + 1, 50))))
        FROM STRING_SPLIT(@GradeOverrides, N',') AS s
        WHERE LTRIM(RTRIM(s.value)) <> N''
        AND   CHARINDEX(N'=', LTRIM(RTRIM(s.value))) > 0;

        /* Collect errors for malformed pairs (no '=') */
        SELECT @errors = @errors + N'@GradeOverrides: invalid pair ''' + LTRIM(RTRIM(s.value)) + N''' (expected CATEGORY=VALUE). '
        FROM STRING_SPLIT(@GradeOverrides, N',') AS s
        WHERE LTRIM(RTRIM(s.value)) <> N''
        AND   CHARINDEX(N'=', LTRIM(RTRIM(s.value))) = 0;

        /* Unknown categories */
        SELECT @errors = @errors + N'@GradeOverrides: unknown category ''' + p.cat + N'''. Valid: COMPLETION, RELIABILITY, SPEED, WORKLOAD. '
        FROM @go_parsed AS p
        WHERE p.cat NOT IN (N'COMPLETION', N'RELIABILITY', N'SPEED', N'WORKLOAD');

        /* Invalid values */
        SELECT @errors = @errors + N'@GradeOverrides: invalid value ''' + p.val + N''' for ' + p.cat + N'. Valid: A, B, C, D, F, IGNORE. '
        FROM @go_parsed AS p
        WHERE p.cat IN (N'COMPLETION', N'RELIABILITY', N'SPEED', N'WORKLOAD')
        AND   p.val NOT IN (N'A', N'B', N'C', N'D', N'F', N'IGNORE');

        /* Apply valid overrides (ISNULL preserves defaults for unmentioned categories) */
        SELECT
            @override_completion  = ISNULL(MAX(CASE WHEN p.cat = N'COMPLETION'  THEN CASE WHEN p.val = N'IGNORE' THEN 'X' ELSE LEFT(p.val, 1) END END), @override_completion),
            @override_reliability = ISNULL(MAX(CASE WHEN p.cat = N'RELIABILITY' THEN CASE WHEN p.val = N'IGNORE' THEN 'X' ELSE LEFT(p.val, 1) END END), @override_reliability),
            @override_speed       = ISNULL(MAX(CASE WHEN p.cat = N'SPEED'       THEN CASE WHEN p.val = N'IGNORE' THEN 'X' ELSE LEFT(p.val, 1) END END), @override_speed),
            @override_workload    = ISNULL(MAX(CASE WHEN p.cat = N'WORKLOAD'    THEN CASE WHEN p.val = N'IGNORE' THEN 'X' ELSE LEFT(p.val, 1) END END), @override_workload)
        FROM @go_parsed AS p
        WHERE p.cat IN (N'COMPLETION', N'RELIABILITY', N'SPEED', N'WORKLOAD')
        AND   p.val IN (N'A', N'B', N'C', N'D', N'F', N'IGNORE');
    END;

    IF @GradeWeights IS NOT NULL
    BEGIN
        SET @has_overrides = 1;

        /* #302: Set-based parsing (replaces cursor) */
        DECLARE @gw_parsed TABLE (pair nvarchar(100), cat nvarchar(50), val_str nvarchar(50));
        INSERT INTO @gw_parsed (pair, cat, val_str)
        SELECT
            pair    = LTRIM(RTRIM(s.value)),
            cat     = UPPER(LTRIM(RTRIM(LEFT(LTRIM(RTRIM(s.value)), CHARINDEX(N'=', LTRIM(RTRIM(s.value))) - 1)))),
            val_str = LTRIM(RTRIM(SUBSTRING(LTRIM(RTRIM(s.value)), CHARINDEX(N'=', LTRIM(RTRIM(s.value))) + 1, 50)))
        FROM STRING_SPLIT(@GradeWeights, N',') AS s
        WHERE LTRIM(RTRIM(s.value)) <> N''
        AND   CHARINDEX(N'=', LTRIM(RTRIM(s.value))) > 0;

        /* Malformed pairs (no '=') */
        SELECT @errors = @errors + N'@GradeWeights: invalid pair ''' + LTRIM(RTRIM(s.value)) + N''' (expected CATEGORY=WEIGHT). '
        FROM STRING_SPLIT(@GradeWeights, N',') AS s
        WHERE LTRIM(RTRIM(s.value)) <> N''
        AND   CHARINDEX(N'=', LTRIM(RTRIM(s.value))) = 0;

        /* Unknown categories */
        SELECT @errors = @errors + N'@GradeWeights: unknown category ''' + p.cat + N'''. Valid: COMPLETION, RELIABILITY, SPEED, WORKLOAD. '
        FROM @gw_parsed AS p
        WHERE p.cat NOT IN (N'COMPLETION', N'RELIABILITY', N'SPEED', N'WORKLOAD');

        /* Invalid weights */
        SELECT @errors = @errors + N'@GradeWeights: invalid weight ''' + p.val_str + N''' for ' + p.cat + N'. Must be a non-negative integer. '
        FROM @gw_parsed AS p
        WHERE p.cat IN (N'COMPLETION', N'RELIABILITY', N'SPEED', N'WORKLOAD')
        AND   (TRY_CONVERT(integer, p.val_str) IS NULL OR TRY_CONVERT(integer, p.val_str) < 0);

        /* Apply valid weights (ISNULL preserves defaults for unmentioned categories) */
        SELECT
            @weight_completion  = ISNULL(MAX(CASE WHEN p.cat = N'COMPLETION'  THEN CONVERT(decimal(5, 2), CONVERT(integer, p.val_str)) END), @weight_completion),
            @weight_reliability = ISNULL(MAX(CASE WHEN p.cat = N'RELIABILITY' THEN CONVERT(decimal(5, 2), CONVERT(integer, p.val_str)) END), @weight_reliability),
            @weight_speed       = ISNULL(MAX(CASE WHEN p.cat = N'SPEED'       THEN CONVERT(decimal(5, 2), CONVERT(integer, p.val_str)) END), @weight_speed),
            @weight_workload    = ISNULL(MAX(CASE WHEN p.cat = N'WORKLOAD'    THEN CONVERT(decimal(5, 2), CONVERT(integer, p.val_str)) END), @weight_workload)
        FROM @gw_parsed AS p
        WHERE p.cat IN (N'COMPLETION', N'RELIABILITY', N'SPEED', N'WORKLOAD')
        AND   TRY_CONVERT(integer, p.val_str) IS NOT NULL
        AND   TRY_CONVERT(integer, p.val_str) >= 0;
    END;

    /* Apply IGNORE -> weight=0, weight=0 -> IGNORE (they are equivalent) */
    IF @override_completion  = 'X' SET @weight_completion  = 0;
    IF @override_reliability = 'X' SET @weight_reliability = 0;
    IF @override_speed       = 'X' SET @weight_speed       = 0;
    IF @override_workload    = 'X' SET @weight_workload    = 0;
    IF @weight_completion  = 0 AND @override_completion  IS NULL SET @override_completion  = 'X';
    IF @weight_reliability = 0 AND @override_reliability IS NULL SET @override_reliability = 'X';
    IF @weight_speed       = 0 AND @override_speed       IS NULL SET @override_speed       = 'X';
    IF @weight_workload    = 0 AND @override_workload    IS NULL SET @override_workload    = 'X';

    /* Normalize weights to sum to 1.0 */
    DECLARE @weight_sum decimal(10, 2) = @weight_completion + @weight_reliability + @weight_speed + @weight_workload;

    IF @has_overrides = 1 AND @weight_sum = 0
        SET @errors = @errors + N'All categories are IGNOREd or have weight 0 -- cannot compute OVERALL score. ';

    IF @weight_sum > 0
    BEGIN
        SET @weight_completion  = @weight_completion  / @weight_sum;
        SET @weight_reliability = @weight_reliability / @weight_sum;
        SET @weight_speed       = @weight_speed       / @weight_sum;
        SET @weight_workload    = @weight_workload    / @weight_sum;
    END;

    IF @errors <> N''
    BEGIN
        RAISERROR(N'Parameter validation failed: %s', 16, 1, @errors) WITH NOWAIT;
        RETURN;
    END;

    /*
    ============================================================================
    VALIDATE COMMANDLOG EXISTS
    ============================================================================
    */
    DECLARE
        @commandlog_ref nvarchar(500),
        @commandlog_db sysname = ISNULL(@CommandLogDatabase, DB_NAME()),
        @sql nvarchar(max),
        @commandlog_exists bit = 0;

    SET @commandlog_ref = QUOTENAME(@commandlog_db) + N'.dbo.CommandLog';

    SET @sql = N'
        IF OBJECT_ID(N''' + REPLACE(@commandlog_ref, N'''', N'''''') + N''', N''U'') IS NOT NULL
            SET @exists = 1;
        ELSE
            SET @exists = 0;
    ';

    EXECUTE sys.sp_executesql
        @sql,
        N'@exists bit OUTPUT',
        @exists = @commandlog_exists OUTPUT;

    IF @commandlog_exists = 0
    BEGIN
        RAISERROR(N'CommandLog table not found at %s. Verify @CommandLogDatabase parameter.', 16, 1, @commandlog_ref) WITH NOWAIT;
        RETURN;
    END;

    DECLARE @expert_int integer = CONVERT(integer, @ExpertMode);

    /* #236: @SingleResultSet=1 auto-promotes @ExpertMode=1 so automation always gets RS 1-13.
       Also forces @SkipHistory=1 because INSERT...EXEC callers cannot write to persistent tables
       (SQL Server nested transaction limitation). */
    IF @SingleResultSet = 1
    BEGIN
        IF @ExpertMode = 0
        BEGIN
            SET @ExpertMode = 1;
            SET @expert_int = 1;
            RAISERROR(N'Note: @SingleResultSet=1 auto-enabled @ExpertMode=1 for stable ResultSetID contract (1-13).', 10, 1) WITH NOWAIT;
        END;

        IF @SkipHistory = 0
        BEGIN
            SET @SkipHistory = 1;
            RAISERROR(N'Note: @SingleResultSet=1 auto-enabled @SkipHistory=1 (INSERT...EXEC cannot write persistent tables).', 10, 1) WITH NOWAIT;
        END;
    END;

    RAISERROR(N'sp_StatUpdate_Diag v%s', 10, 1, @procedure_version) WITH NOWAIT;
    RAISERROR(N'CommandLog: %s', 10, 1, @commandlog_ref) WITH NOWAIT;
    RAISERROR(N'Analysis window: %i days', 10, 1, @DaysBack) WITH NOWAIT;
    DECLARE @obfuscate_int integer = CONVERT(integer, @Obfuscate);
    RAISERROR(N'Obfuscate: %i', 10, 1, @obfuscate_int) WITH NOWAIT;
    RAISERROR(N'ExpertMode: %i', 10, 1, @expert_int) WITH NOWAIT;

    IF @has_overrides = 1
    BEGIN
        DECLARE @override_msg nvarchar(500) = N'Grade overrides active:';
        IF @override_completion  IS NOT NULL SET @override_msg = @override_msg + N' COMPLETION=' + CASE @override_completion  WHEN 'X' THEN N'IGNORE' ELSE @override_completion  END;
        IF @override_reliability IS NOT NULL SET @override_msg = @override_msg + N' RELIABILITY=' + CASE @override_reliability WHEN 'X' THEN N'IGNORE' ELSE @override_reliability END;
        IF @override_speed       IS NOT NULL SET @override_msg = @override_msg + N' SPEED=' + CASE @override_speed       WHEN 'X' THEN N'IGNORE' ELSE @override_speed       END;
        IF @override_workload    IS NOT NULL SET @override_msg = @override_msg + N' WORKLOAD=' + CASE @override_workload    WHEN 'X' THEN N'IGNORE' ELSE @override_workload    END;
        RAISERROR(@override_msg, 10, 1) WITH NOWAIT;

        DECLARE @weight_msg nvarchar(500) = N'Effective weights: COMPLETION='
            + CONVERT(nvarchar(10), CONVERT(integer, @weight_completion * 100))
            + N', RELIABILITY=' + CONVERT(nvarchar(10), CONVERT(integer, @weight_reliability * 100))
            + N', SPEED=' + CONVERT(nvarchar(10), CONVERT(integer, @weight_speed * 100))
            + N', WORKLOAD=' + CONVERT(nvarchar(10), CONVERT(integer, @weight_workload * 100))
            + N' (sum=100)';
        RAISERROR(@weight_msg, 10, 1) WITH NOWAIT;
    END;

    IF @Debug = 1
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        RAISERROR(N'', 10, 1) WITH NOWAIT;
        RAISERROR(N'DEBUG: === Effective Parameters ===', 10, 1) WITH NOWAIT;
        RAISERROR(N'DEBUG: @DaysBack=%i  @LongRunningMinutes=%i  @FailureThreshold=%i', 10, 1, @DaysBack, @LongRunningMinutes, @FailureThreshold) WITH NOWAIT;
        RAISERROR(N'DEBUG: @TimeLimitExhaustionPct=%i  @ThroughputWindowDays=%i  @TopN=%i', 10, 1, @TimeLimitExhaustionPct, @ThroughputWindowDays, @TopN) WITH NOWAIT;

        DECLARE @debug_efficacy_days integer = ISNULL(@EfficacyDaysBack, @DaysBack);
        DECLARE @debug_efficacy_detail integer = ISNULL(@EfficacyDetailDays, 14);
        RAISERROR(N'DEBUG: @EfficacyDaysBack=%i (resolved)  @EfficacyDetailDays=%i (resolved)', 10, 1, @debug_efficacy_days, @debug_efficacy_detail) WITH NOWAIT;

        DECLARE @debug_expert integer = CONVERT(integer, @ExpertMode);
        DECLARE @debug_skip integer = CONVERT(integer, @SkipHistory);
        DECLARE @debug_single integer = CONVERT(integer, @SingleResultSet);
        DECLARE @debug_obf integer = CONVERT(integer, @Obfuscate);
        RAISERROR(N'DEBUG: @ExpertMode=%i  @SkipHistory=%i  @SingleResultSet=%i  @Obfuscate=%i', 10, 1, @debug_expert, @debug_skip, @debug_single, @debug_obf) WITH NOWAIT;

        DECLARE @debug_w_comp integer = CONVERT(integer, @weight_completion * 100);
        DECLARE @debug_w_rel  integer = CONVERT(integer, @weight_reliability * 100);
        DECLARE @debug_w_spd  integer = CONVERT(integer, @weight_speed * 100);
        DECLARE @debug_w_wl   integer = CONVERT(integer, @weight_workload * 100);
        RAISERROR(N'DEBUG: Weights: COMPLETION=%i%%  RELIABILITY=%i%%  SPEED=%i%%  WORKLOAD=%i%%',
            10, 1, @debug_w_comp, @debug_w_rel, @debug_w_spd, @debug_w_wl) WITH NOWAIT;
        RAISERROR(N'DEBUG: Initialization complete (%i ms)', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
        RAISERROR(N'', 10, 1) WITH NOWAIT;
    END;

    /* BUG-07: orphan threshold now a named constant (was hardcoded 60 minutes).
       Default 2880 = 48 hours, matching sp_StatUpdate @OrphanedRunThresholdHours default.
       A run still in progress (no END record) is only classified as orphaned once this
       threshold has elapsed; runs started more recently are excluded to avoid false C1 alerts. */
    DECLARE @OrphanedRunThresholdMinutes integer = 2880;

    /*
    ============================================================================
    PERSISTENT HISTORY TABLE (incremental -- skip XML re-parsing on repeat runs)

    Inspired by sp_Blitz / sp_PressureDetector baseline tables. The first run
    parses all CommandLog XML. Subsequent runs only parse new rows (ID > max
    previously cached), then merge into the persistent table. This cuts repeat
    execution time dramatically on servers with large CommandLog tables.

    Table lives in the same database as CommandLog (so it travels with backups).
    Opt out with @SkipHistory = 1 for ephemeral/test scenarios.
    ============================================================================
    */
    DECLARE
        @history_ref nvarchar(500),
        @history_exists bit = 0,
        @history_max_id integer = 0,
        @history_max_run_start datetime2(3) = NULL;

    SET @history_ref = QUOTENAME(@commandlog_db) + N'.dbo.StatUpdateDiagHistory';

    IF @SkipHistory = 0
    BEGIN
        /* Check if history table exists */
        SET @sql = N'
            IF OBJECT_ID(N''' + REPLACE(@history_ref, N'''', N'''''') + N''', N''U'') IS NOT NULL
                SET @exists = 1;
            ELSE
                SET @exists = 0;
        ';

        EXECUTE sys.sp_executesql
            @sql,
            N'@exists bit OUTPUT',
            @exists = @history_exists OUTPUT;

        /* Auto-create if missing */
        IF @history_exists = 0
        BEGIN
            SET @sql = N'
                CREATE TABLE ' + @history_ref + N'
                (
                    SnapshotID      integer         IDENTITY(1,1) NOT NULL,
                    CapturedAt      datetime2(3)    NOT NULL DEFAULT SYSDATETIME(),
                    MaxCommandLogID integer         NOT NULL,
                    RunLabel        nvarchar(100)   NOT NULL,
                    StartTime       datetime2(3)    NOT NULL,
                    HealthScore     integer         NULL,
                    OverallGrade    char(1)         NULL,
                    CompletionPct   decimal(5,1)    NULL,
                    AvgSecPerStat   decimal(10,1)   NULL,
                    WorkloadCoveragePct decimal(5,1) NULL,
                    HighCpuFirstQuartilePct decimal(5,1) NULL,
                    MinutesToHighCpuComplete decimal(10,1) NULL,
                    StatsFound      integer         NULL,
                    StatsProcessed  integer         NULL,
                    StatsFailed     integer         NULL,
                    StopReason      nvarchar(50)    NULL,
                    DurationSeconds integer         NULL,
                    IsQSRun         bit             NOT NULL DEFAULT 0,
                    DiagVersion     varchar(20)     NOT NULL,
                    /* 9axc: StartTime-based watermark for purge/archive robustness */
                    MaxStartTime    datetime2(3)    NULL,

                    CONSTRAINT PK_StatUpdateDiagHistory PRIMARY KEY CLUSTERED (SnapshotID) WITH (DATA_COMPRESSION = PAGE),
                    INDEX IX_StatUpdateDiagHistory_RunLabel UNIQUE NONCLUSTERED (RunLabel) WITH (DATA_COMPRESSION = PAGE)
                );
            ';

            EXECUTE sys.sp_executesql @sql;
            RAISERROR(N'  Created persistent history table: %s', 10, 1, @history_ref) WITH NOWAIT;
            SET @history_exists = 1;
        END
        ELSE
        BEGIN
            /* gh-472: Auto-upgrade existing StatUpdateDiagHistory tables from older diag versions.
               COL_LENGTH returns NULL when column missing.  Each ALTER gated independently so
               partial upgrades resume cleanly. */
            SET @sql = N'
                IF COL_LENGTH(''' + @history_ref + N''', ''HealthScore'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD HealthScore integer NULL;
                IF COL_LENGTH(''' + @history_ref + N''', ''OverallGrade'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD OverallGrade char(1) NULL;
                IF COL_LENGTH(''' + @history_ref + N''', ''CompletionPct'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD CompletionPct decimal(5,1) NULL;
                IF COL_LENGTH(''' + @history_ref + N''', ''AvgSecPerStat'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD AvgSecPerStat decimal(10,1) NULL;
                IF COL_LENGTH(''' + @history_ref + N''', ''WorkloadCoveragePct'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD WorkloadCoveragePct decimal(5,1) NULL;
                IF COL_LENGTH(''' + @history_ref + N''', ''HighCpuFirstQuartilePct'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD HighCpuFirstQuartilePct decimal(5,1) NULL;
                IF COL_LENGTH(''' + @history_ref + N''', ''MinutesToHighCpuComplete'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD MinutesToHighCpuComplete decimal(10,1) NULL;
                /* 9axc: MaxStartTime for StartTime-based watermark (purge/archive-resistant) */
                IF COL_LENGTH(''' + @history_ref + N''', ''MaxStartTime'') IS NULL
                    ALTER TABLE ' + @history_ref + N' ADD MaxStartTime datetime2(3) NULL;
            ';
            EXECUTE sys.sp_executesql @sql;

            /* 9axc: Read watermark -- prefer MaxStartTime (robust to ID gaps from purge/archive);
               fall back to MaxCommandLogID only when MaxStartTime IS NULL (pre-9axc history rows). */
            SET @sql = N'
                SELECT @max_id    = ISNULL(MAX(MaxCommandLogID), 0),
                       @max_start = MAX(MaxStartTime)   /* 9axc: NULL on pre-9axc rows; checked below */
                FROM ' + @history_ref + N';
            ';

            EXECUTE sys.sp_executesql
                @sql,
                N'@max_id integer OUTPUT, @max_start datetime2(3) OUTPUT',
                @max_id = @history_max_id OUTPUT,
                @max_start = @history_max_run_start OUTPUT;

            DECLARE @history_row_count integer;
            SET @sql = N'SELECT @cnt = COUNT_BIG(*) FROM ' + @history_ref + N';';
            EXECUTE sys.sp_executesql @sql, N'@cnt integer OUTPUT', @cnt = @history_row_count OUTPUT;

            /* Watermark gap detection: if CommandLog was archived/truncated, watermark
               may exceed current max ID, permanently skipping new data (#232) */
            DECLARE @cl_max_id integer;
            SET @sql = N'SELECT @mx = ISNULL(MAX(ID), 0) FROM ' + @commandlog_ref + N';';
            EXECUTE sys.sp_executesql @sql, N'@mx integer OUTPUT', @mx = @cl_max_id OUTPUT;

            IF @cl_max_id > 0 AND @history_max_id > @cl_max_id
            BEGIN
                RAISERROR(N'  WARNING: History watermark (%i) exceeds CommandLog max ID (%i). Resetting watermark -- CommandLog may have been archived.', 10, 1,
                    @history_max_id, @cl_max_id) WITH NOWAIT;
                SET @history_max_id = 0;    /* #240: reset to 0, not @cl_max_id -- NOT EXISTS dedup guard prevents duplicates */
            END;

            RAISERROR(N'  History table: %s (%i snapshots, watermark ID %i)', 10, 1,
                @history_ref, @history_row_count, @history_max_id) WITH NOWAIT;
        END;
    END
    ELSE
    BEGIN
        RAISERROR(N'  History: skipped (@SkipHistory = 1)', 10, 1) WITH NOWAIT;
    END;

    /*
    ============================================================================
    PERSISTENT STAT CACHE TABLE (avoids re-parsing CommandLog XML on every run)

    Caches the parsed #stat_updates data (extracted XML fields as typed columns).
    Watermark-based: only parse new CommandLog rows (ID > max cached).
    Same database as CommandLog (travels with backups). Opt-out: @SkipHistory=1.
    ============================================================================
    */
    DECLARE
        @cache_ref nvarchar(500),
        @cache_exists bit = 0,
        @cache_watermark integer = 0;

    SET @cache_ref = QUOTENAME(@commandlog_db) + N'.dbo.StatUpdateDiagCache';

    IF @SkipHistory = 0
    BEGIN
        /* Check if cache table exists */
        SET @sql = N'
            IF OBJECT_ID(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''U'') IS NOT NULL
                SET @exists = 1;
            ELSE
                SET @exists = 0;
        ';

        EXECUTE sys.sp_executesql
            @sql,
            N'@exists bit OUTPUT',
            @exists = @cache_exists OUTPUT;

        /* Auto-create if missing */
        IF @cache_exists = 0
        BEGIN
            SET @sql = N'
                CREATE TABLE ' + @cache_ref + N'
                (
                    CommandLogID        integer         NOT NULL,
                    RunLabel            nvarchar(100)   NULL,
                    DatabaseName        sysname         NULL,
                    SchemaName          sysname         NULL,
                    ObjectName          sysname         NULL,
                    StatisticsName      sysname         NULL,
                    StartTime           datetime2(3)    NOT NULL,
                    EndTime             datetime2(3)    NULL,
                    DurationMs          integer         NULL,
                    ErrorNumber         integer         NULL,
                    ErrorMessage        nvarchar(3900)  NULL,
                    ModificationCounter bigint          NULL,
                    RowCount_           bigint          NULL,
                    PageCount           bigint          NULL,
                    SizeMB              integer         NULL,
                    DaysStale           integer         NULL,
                    QualifyReason       nvarchar(100)   NULL,
                    HasNorecompute      bit             NULL,
                    IsHeap              bit             NULL,
                    AutoCreated         bit             NULL,
                    QSPlanCount         integer         NULL,
                    QSTotalExecutions   bigint          NULL,
                    QSTotalCpuMs        bigint          NULL,
                    QSTotalMemoryGrantKB bigint         NULL,
                    QSTotalTempdbPages  bigint          NULL,
                    EffectiveSamplePct  integer         NULL,
                    SampleSource        nvarchar(50)    NULL,
                    HasFilter           bit             NULL,
                    FilteredDriftRatio  float           NULL,
                    IsIncremental       bit             NULL,
                    ProcessingPosition  integer         NULL,
                    ObjectId            integer         NULL,
                    StatsId             integer         NULL,
                    /* sw82: keep the CREATE path in lockstep with the upgrade ALTERs below --
                       the auto-create test drops this table, so a CREATE missing columns
                       breaks the very next cache write (caught 2026-07-02). */
                    IsCritical          bit             NULL,
                    CriticalSampleOverride bit          NULL,

                    CONSTRAINT PK_StatUpdateDiagCache PRIMARY KEY CLUSTERED (CommandLogID)
                        WITH (DATA_COMPRESSION = PAGE)
                );
            ';

            EXECUTE sys.sp_executesql @sql;
            RAISERROR(N'  Created persistent cache table: %s', 10, 1, @cache_ref) WITH NOWAIT;
            SET @cache_exists = 1;
        END
        ELSE
        BEGIN
            /* Check for new columns that may have been added in later versions */
            DECLARE @col_check_sql nvarchar(max);
            SET @col_check_sql = N'
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''ProcessingPosition'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD ProcessingPosition integer NULL;
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''ObjectId'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD ObjectId integer NULL;
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''StatsId'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD StatsId integer NULL;
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''QSTotalMemoryGrantKB'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD QSTotalMemoryGrantKB bigint NULL;
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''QSTotalTempdbPages'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD QSTotalTempdbPages bigint NULL;
                /* sw82: IsCritical / CriticalSampleOverride added in this batch */
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''IsCritical'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD IsCritical bit NULL;
                IF COL_LENGTH(N''' + REPLACE(@cache_ref, N'''', N'''''') + N''', N''CriticalSampleOverride'') IS NULL
                    ALTER TABLE ' + @cache_ref + N' ADD CriticalSampleOverride bit NULL;
            ';
            EXECUTE sys.sp_executesql @col_check_sql;

            /* Get watermark: max CommandLogID already cached */
            SET @sql = N'SELECT @wm = ISNULL(MAX(CommandLogID), 0) FROM ' + @cache_ref + N';';
            EXECUTE sys.sp_executesql @sql, N'@wm integer OUTPUT', @wm = @cache_watermark OUTPUT;

            /* Watermark gap detection: same as history table (#232) */
            DECLARE @cl_max_id_cache integer;
            SET @sql = N'SELECT @mx = ISNULL(MAX(ID), 0) FROM ' + @commandlog_ref + N';';
            EXECUTE sys.sp_executesql @sql, N'@mx integer OUTPUT', @mx = @cl_max_id_cache OUTPUT;

            IF @cl_max_id_cache > 0 AND @cache_watermark > @cl_max_id_cache
            BEGIN
                RAISERROR(N'  WARNING: Cache watermark (%i) exceeds CommandLog max ID (%i). Resetting -- CommandLog may have been archived.', 10, 1,
                    @cache_watermark, @cl_max_id_cache) WITH NOWAIT;
                SET @cache_watermark = 0;    /* #312: reset to 0, not @cl_max_id_cache -- NOT EXISTS dedup guard prevents duplicates */
            END;

            RAISERROR(N'  Cache table: %s (watermark ID %i)', 10, 1, @cache_ref, @cache_watermark) WITH NOWAIT;
        END;
    END;

    RAISERROR(N'', 10, 1) WITH NOWAIT;

    /*
    ============================================================================
    TEMP TABLES
    ============================================================================
    */

    /* Defensive cleanup: if a prior call errored mid-execution, temp tables
       with named constraints (PK_stat_updates, PK_recommendations) survive
       in the session and block the next CREATE TABLE. */
    DROP TABLE IF EXISTS #runs;
    DROP TABLE IF EXISTS #stat_updates;
    DROP TABLE IF EXISTS #recommendations;
    DROP TABLE IF EXISTS #qs_efficacy;
    DROP TABLE IF EXISTS #executive_dashboard;

    /* Run pairs: START/END matched by RunLabel */
    CREATE TABLE #runs
    (
        RunLabel nvarchar(100) NOT NULL,
        StartTime datetime2(3) NOT NULL,
        EndTime datetime2(3) NULL,
        DurationSeconds integer NULL,
        StopReason nvarchar(50) NULL,
        StatsFound integer NULL,
        StatsProcessed integer NULL,
        StatsSucceeded integer NULL,
        StatsFailed integer NULL,
        StatsRemaining integer NULL,
        /* Parameters from START record */
        [Version] nvarchar(20) NULL,
        [Databases] nvarchar(max) NULL,
        TimeLimit integer NULL,
        ModificationThreshold bigint NULL,
        TieredThresholds nvarchar(10) NULL,
        ThresholdLogic nvarchar(10) NULL,
        SortOrder nvarchar(50) NULL,
        QueryStorePriority nvarchar(1) NULL,
        StatisticsSample integer NULL,
        StatsInParallel nvarchar(1) NULL,
        Preset nvarchar(30) NULL,
        LongRunningThresholdMinutes integer NULL,
        LongRunningSamplePercent integer NULL,
        /* GroupByJoinPattern removed (v3 no-op -- element absent from v3 START XML; xmxs) */
        FilteredStatsMode nvarchar(10) NULL,
        BatchLimit integer NULL,
        FailFast bit NULL,
        /* Mop-up pass (v2.24+, from END record) */
        MopUpTriggered bit NULL,
        MopUpFound integer NULL,
        MopUpProcessed integer NULL,
        /* END Summary fields added in this batch (70hh, 1h2l) */
        StatsToctou integer NULL,               /* Summary/StatsToctou  -- count of TOCTOU_SKIP catches per run (v3.5.9+) */
        QSEnrichmentSkipped bit NULL,           /* Summary/QSEnrichmentSkipped -- 1 when QS phase was skipped (v3+) */
        /* Recurring-warning support (t8lj) */
        WarningsCodes nvarchar(max) NULL,       /* Summary/WarningsCodes -- pipe-delimited code tokens (v3.5.9+) */
        /* sw82: CriticalTables parameters (v3.5.0+); NULL on older rows (absent element) */
        CriticalTables nvarchar(max) NULL,      /* Parameters/CriticalTables -- LIKE patterns for priority-boosted tables */
        CriticalSamplePercent tinyint NULL,     /* Parameters/CriticalSamplePercent -- FULLSCAN override sample rate */
        CriticalTablesFirst nvarchar(1) NULL,   /* Parameters/CriticalTablesFirst -- Y/N: critical tables processed before others */
        /* sw82: element-presence flags for parameters consumed by checks (9ufm) */
        HasFullParamsLog bit NOT NULL DEFAULT 0,      /* 9ufm: 1 when the run's sp_StatUpdate version is >= 2.15
                                                          (full parameter logging) -- absent param element then means
                                                          genuinely NULL, so param-history checks may reason on absence.
                                                          0 = pre-2.15 run: excluded from param reasoning. */
        /* Computed */
        IsKilled bit NOT NULL DEFAULT 0,
        TotalGB decimal(10, 2) NULL /* sum of PageCount * 8KB for succeeded stats in this run */
        /*
        v2026.04.20.1: PK constraint removed from table definition.  The
        INSERT below LEFT JOINs START -> END on RunLabel, which can produce
        multiple rows per label when CommandLog has duplicate STARTs (same-
        second retries) or multiple ENDs for a single RunLabel (orphan-
        cleanup KILLED record + a real END from gh-425).  Dedup runs a few
        lines below; uniqueness is re-established via a unique index after
        dedup so downstream joins still benefit from the index.
        */
    );

    /* Individual stat updates */
    CREATE TABLE #stat_updates
    (
        ID integer NOT NULL,
        RunLabel nvarchar(100) NULL,
        DatabaseName sysname NULL,
        SchemaName sysname NULL,
        ObjectName sysname NULL,
        StatisticsName sysname NULL,
        StartTime datetime2(3) NOT NULL,
        EndTime datetime2(3) NULL,
        DurationMs integer NULL,
        ErrorNumber integer NULL,
        ErrorMessage nvarchar(3900) NULL,
        ModificationCounter bigint NULL,
        RowCount_ bigint NULL,
        PageCount bigint NULL,
        SizeMB integer NULL,
        DaysStale integer NULL,
        QualifyReason nvarchar(100) NULL,
        HasNorecompute bit NULL,
        IsHeap bit NULL,
        AutoCreated bit NULL,
        QSPlanCount integer NULL,
        QSTotalExecutions bigint NULL,
        QSTotalCpuMs bigint NULL,
        QSTotalMemoryGrantKB bigint NULL,   /* #368: from ExtendedInfo v2.34+ */
        QSTotalTempdbPages bigint NULL,     /* #368: from ExtendedInfo v2.34+ */
        EffectiveSamplePct integer NULL,
        SampleSource nvarchar(50) NULL,
        HasFilter bit NULL,
        FilteredDriftRatio float NULL,
        IsIncremental bit NULL,
        ProcessingPosition integer NULL,
        ObjectId integer NULL,           /* #268: from ExtendedInfo v2.20+ */
        StatsId integer NULL,            /* #268: from ExtendedInfo v2.20+ */
        /* sw82: CriticalTables per-stat markers (v3.5.0+); NULL on older rows */
        IsCritical bit NULL,                /* ExtendedInfo/IsCritical -- 1 when stat matched a CriticalTables pattern */
        CriticalSampleOverride bit NULL,    /* ExtendedInfo/CriticalSampleOverride -- 1 when per-table sample override was applied */
        /* 70hh: skip-row flag -- 1 when Command begins 'SKIPPED:' or ErrorMessage begins 'TOCTOU_SKIP'.
           Rows with IsSkip=1 are excluded from duration/appearance/success aggregates. */
        IsSkip bit NOT NULL DEFAULT 0,

        CONSTRAINT PK_stat_updates PRIMARY KEY NONCLUSTERED (ID)
    );

    /* Recommendations output */
    CREATE TABLE #recommendations
    (
        FindingID integer IDENTITY(1, 1) NOT NULL,
        Severity nvarchar(10) NOT NULL,
        Category nvarchar(50) NOT NULL,
        Finding nvarchar(500) NOT NULL,
        Evidence nvarchar(2000) NULL,
        Recommendation nvarchar(2000) NULL,
        /* sp_StatUpdate-6x80: widened from nvarchar(1000) to accommodate
           @CriticalTables hint appended by I10 RECOMMENDED_CONFIG */
        ExampleCall nvarchar(2000) NULL,
        SortPriority integer NOT NULL DEFAULT 50,

        CONSTRAINT PK_recommendations PRIMARY KEY CLUSTERED (FindingID)
    );

    /* Obfuscation mapping (populated only when @Obfuscate = 1) */
    CREATE TABLE #obfuscation_map
    (
        ObjectType nvarchar(20) NOT NULL,
        OriginalName nvarchar(256) NOT NULL,
        ObfuscatedName nvarchar(50) NOT NULL
    );

    /* Executive Dashboard (always populated, always returned as RS 1) */
    CREATE TABLE #executive_dashboard
    (
        Category        nvarchar(30)    NOT NULL,
        Grade           char(1)         NOT NULL,
        Score           integer         NOT NULL,
        Headline        nvarchar(500)   NOT NULL,
        Detail          nvarchar(2000)  NULL,
        Trend           nvarchar(20)    NULL,
        SortOrder       integer         NOT NULL
    );

    /* Single result set accumulator (populated only when @SingleResultSet = 1) */
    CREATE TABLE #single_rs
    (
        SingleRsID      int             IDENTITY(1,1) NOT NULL PRIMARY KEY,
        ResultSetID     int             NOT NULL,
        ResultSetName   nvarchar(100)   NOT NULL,
        RowNum          int             NOT NULL,
        RowData         nvarchar(max)   NULL
    );

    /*
    ============================================================================
    DATA EXTRACTION: Populate #runs from START/END pairs
    ============================================================================
    */
    RAISERROR(N'Extracting run data...', 10, 1) WITH NOWAIT;

    SET @sql = N'
    INSERT INTO #runs
    (
        RunLabel, StartTime, EndTime, DurationSeconds, StopReason,
        StatsFound, StatsProcessed, StatsSucceeded, StatsFailed, StatsRemaining,
        [Version], [Databases], TimeLimit, ModificationThreshold, TieredThresholds,
        ThresholdLogic, SortOrder, QueryStorePriority, StatisticsSample,
        StatsInParallel, Preset, LongRunningThresholdMinutes, LongRunningSamplePercent,
        FilteredStatsMode, BatchLimit, FailFast,
        MopUpTriggered, MopUpFound, MopUpProcessed,
        StatsToctou, QSEnrichmentSkipped, WarningsCodes,
        CriticalTables, CriticalSamplePercent, CriticalTablesFirst,
        HasFullParamsLog,
        IsKilled
    )
    SELECT
        run_label           = ISNULL(s.ExtendedInfo.value(N''(Parameters/RunLabel)[1]'', N''nvarchar(100)''),
                                     N''legacy_'' + CONVERT(nvarchar(20), s.ID)),
        start_time          = s.StartTime,
        end_time            = e.EndTime,
        duration_seconds    = DATEDIFF(SECOND, s.StartTime, e.EndTime),
        stop_reason         = e.ExtendedInfo.value(N''(Summary/StopReason)[1]'', N''nvarchar(50)''),
        stats_found         = e.ExtendedInfo.value(N''(Summary/StatsFound)[1]'', N''int''),
        stats_processed     = e.ExtendedInfo.value(N''(Summary/StatsProcessed)[1]'', N''int''),
        stats_succeeded     = e.ExtendedInfo.value(N''(Summary/StatsSucceeded)[1]'', N''int''),
        stats_failed        = e.ExtendedInfo.value(N''(Summary/StatsFailed)[1]'', N''int''),
        stats_remaining     = e.ExtendedInfo.value(N''(Summary/StatsRemaining)[1]'', N''int'')
    ';

    SET @sql = @sql + N'
      , [version]           = s.ExtendedInfo.value(N''(Parameters/Version)[1]'', N''nvarchar(20)''),
        [databases]         = s.ExtendedInfo.value(N''(Parameters/Databases)[1]'', N''nvarchar(max)''),
        time_limit          = s.ExtendedInfo.value(N''(Parameters/TimeLimit)[1]'', N''int''),
        mod_threshold       = s.ExtendedInfo.value(N''(Parameters/ModificationThreshold)[1]'', N''bigint''),
        tiered_thresholds   = s.ExtendedInfo.value(N''(Parameters/TieredThresholds)[1]'', N''nvarchar(10)''),
        threshold_logic     = s.ExtendedInfo.value(N''(Parameters/ThresholdLogic)[1]'', N''nvarchar(10)''),
        sort_order          = s.ExtendedInfo.value(N''(Parameters/SortOrder)[1]'', N''nvarchar(50)''),
        /* #390: v2 writes Y/N (nvarchar), v3 writes 1/0 (bit).  Normalize at extraction. */
        qs_priority         = CASE s.ExtendedInfo.value(N''(Parameters/QueryStorePriority)[1]'', N''nvarchar(5)'')
                                  WHEN N''Y'' THEN N''Y'' WHEN N''1'' THEN N''Y''
                                  WHEN N''N'' THEN N''N'' WHEN N''0'' THEN N''N''
                                  ELSE NULL
                              END,
        stat_sample         = s.ExtendedInfo.value(N''(Parameters/StatisticsSample)[1]'', N''int''),
        parallel            = s.ExtendedInfo.value(N''(Parameters/StatsInParallel)[1]'', N''nvarchar(1)''),
        preset              = s.ExtendedInfo.value(N''(Parameters/Preset)[1]'', N''nvarchar(30)''),
        long_run_min        = s.ExtendedInfo.value(N''(Parameters/LongRunningThresholdMinutes)[1]'', N''int''),
        long_run_pct        = s.ExtendedInfo.value(N''(Parameters/LongRunningSamplePercent)[1]'', N''int''),
        /* GroupByJoinPattern extraction removed (xmxs): element absent in v3 START XML; variable was never consumed */
        filtered_mode       = s.ExtendedInfo.value(N''(Parameters/FilteredStatsMode)[1]'', N''nvarchar(10)''),
        batch_limit         = s.ExtendedInfo.value(N''(Parameters/BatchLimit)[1]'', N''int''),
        fail_fast           = s.ExtendedInfo.value(N''(Parameters/FailFast)[1]'', N''bit''),
        mop_up_triggered    = e.ExtendedInfo.value(N''(Summary/MopUpTriggered)[1]'', N''bit''),
        mop_up_found        = e.ExtendedInfo.value(N''(Summary/MopUpFound)[1]'', N''int''),
        mop_up_processed    = e.ExtendedInfo.value(N''(Summary/MopUpProcessed)[1]'', N''int''),
        /* 70hh: TOCTOU skip count from END Summary XML (v3.5.9+); NULL on older rows */
        stats_toctou        = e.ExtendedInfo.value(N''(Summary/StatsToctou)[1]'', N''int''),
        /* 1h2l: QSEnrichmentSkipped from END Summary XML; NULL on older rows (absent element) */
        qs_enrichment_skipped = e.ExtendedInfo.value(N''(Summary/QSEnrichmentSkipped)[1]'', N''bit''),
        /* t8lj: pipe-delimited warning code tokens from END Summary XML (v3.5.9+); NULL on older rows */
        warnings_codes      = e.ExtendedInfo.value(N''(Summary/WarningsCodes)[1]'', N''nvarchar(max)''),
        /* sw82: CriticalTables params from START XML (v3.5.0+); NULL on older rows */
        critical_tables         = s.ExtendedInfo.value(N''(Parameters/CriticalTables)[1]'', N''nvarchar(max)''),
        critical_sample_pct     = s.ExtendedInfo.value(N''(Parameters/CriticalSamplePercent)[1]'', N''tinyint''),
        critical_tables_first   = s.ExtendedInfo.value(N''(Parameters/CriticalTablesFirst)[1]'', N''nvarchar(1)''),
        /* 9ufm: version-derived full-logging flag.  Per-element .exist() gating is WRONG here:
           FOR XML omits NULL-valued params, so an absent element is exactly the signal the
           param checks detect (TimeLimit absent = genuinely unlimited) -- gating on element
           presence would permanently suppress those checks.  Full parameter logging shipped
           in v2.15 (Mar 2026), so runs from >= 2.15 log every non-NULL public param and
           absence there means NULL; older runs are excluded from param reasoning. */
        has_full_params_log = CONVERT(bit, CASE
            WHEN TRY_CONVERT(int, LEFT(vx.ver, NULLIF(CHARINDEX(N''.'', vx.ver), 0) - 1)) > 2 THEN 1
            WHEN TRY_CONVERT(int, LEFT(vx.ver, NULLIF(CHARINDEX(N''.'', vx.ver), 0) - 1)) = 2
             AND TRY_CONVERT(int, SUBSTRING(vx.ver, CHARINDEX(N''.'', vx.ver) + 1,
                    CASE WHEN CHARINDEX(N''.'', vx.ver, CHARINDEX(N''.'', vx.ver) + 1) = 0
                         THEN 10
                         ELSE CHARINDEX(N''.'', vx.ver, CHARINDEX(N''.'', vx.ver) + 1) - CHARINDEX(N''.'', vx.ver) - 1
                    END)) >= 15 THEN 1
            ELSE 0
        END),
        is_killed           = CASE
                                  WHEN e.ID IS NULL THEN 1
                                  WHEN e.ExtendedInfo.value(N''(Summary/StopReason)[1]'', N''nvarchar(50)'') = N''KILLED'' THEN 1
                                  ELSE 0
                              END
    FROM ' + @commandlog_ref + N' AS s
    LEFT JOIN ' + @commandlog_ref + N' AS e
        ON  e.CommandType = N''SP_STATUPDATE_END''
        AND e.ExtendedInfo.value(N''(Summary/RunLabel)[1]'', N''nvarchar(100)'') =
            s.ExtendedInfo.value(N''(Parameters/RunLabel)[1]'', N''nvarchar(100)'')
    CROSS APPLY (SELECT ver = s.ExtendedInfo.value(N''(Parameters/Version)[1]'', N''nvarchar(30)'')) AS vx
    WHERE s.CommandType = N''SP_STATUPDATE_START''
    AND   s.StartTime >= DATEADD(DAY, -@days_back, GETDATE())
    AND   NOT (e.ID IS NULL AND DATEDIFF(MINUTE, s.StartTime, GETDATE()) < @orphan_minutes);
    ';

    EXECUTE sys.sp_executesql
        @sql,
        N'@days_back integer, @orphan_minutes integer',
        @days_back = @DaysBack,
        @orphan_minutes = @OrphanedRunThresholdMinutes;

    /* #216: Dedup -- keep only the most recent START per RunLabel.
       sp_StatUpdate-772k: IsKilled ASC tiebreaker so a real END (IsKilled = 0)
       always wins over a synthetic KILLED orphan-cleanup END (IsKilled = 1)
       for the same RunLabel.  The prior v2026.04.20.1 EndTime DESC ordering
       could pick the newer synthetic KILLED row, falsely flagging completed
       parallel runs as killed. */
    WITH dupes AS (
        SELECT *, ROW_NUMBER() OVER (
                      PARTITION BY RunLabel
                      ORDER BY StartTime DESC, IsKilled ASC, EndTime DESC
                  ) AS rn
        FROM #runs
    )
    DELETE FROM dupes WHERE rn > 1;

    /* v2026.04.20.1: unique index replaces PK_runs (now enforced post-dedup). */
    IF NOT EXISTS (SELECT 1 FROM tempdb.sys.indexes
                   WHERE object_id = OBJECT_ID(N'tempdb..#runs')
                     AND name = N'UX_runs_RunLabel')
        CREATE UNIQUE NONCLUSTERED INDEX UX_runs_RunLabel ON #runs (RunLabel);

    DECLARE @run_count integer = (SELECT COUNT_BIG(*) FROM #runs);
    DECLARE @killed_count integer = (SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 1);

    RAISERROR(N'  Runs found: %i (killed: %i)', 10, 1, @run_count, @killed_count) WITH NOWAIT;

    IF @Debug = 1
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        DECLARE @debug_min_start nvarchar(30) = CONVERT(nvarchar(30), (SELECT MIN(StartTime) FROM #runs), 120);
        DECLARE @debug_max_start nvarchar(30) = CONVERT(nvarchar(30), (SELECT MAX(StartTime) FROM #runs), 120);
        DECLARE @debug_legacy_count integer = (SELECT COUNT_BIG(*) FROM #runs WHERE RunLabel LIKE N'legacy_%');
        RAISERROR(N'DEBUG: #runs date range: %s to %s', 10, 1, @debug_min_start, @debug_max_start) WITH NOWAIT;
        IF @debug_legacy_count > 0
            RAISERROR(N'DEBUG: #runs with synthetic legacy labels: %i (pre-RunLabel CommandLog entries)', 10, 1, @debug_legacy_count) WITH NOWAIT;
        RAISERROR(N'DEBUG: Run extraction complete (%i ms)', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
    END;

    /*
    ============================================================================
    DATA EXTRACTION: Populate #stat_updates from UPDATE_STATISTICS entries
    Uses cache table when available (@SkipHistory=0) to avoid re-parsing XML.
    ============================================================================
    */
    RAISERROR(N'Extracting stat update data...', 10, 1) WITH NOWAIT;

    IF @SkipHistory = 0 AND @cache_exists = 1
    BEGIN
        /* Step 1: Populate cache with new rows (ID > watermark) */
        /* CONVERT(nvarchar(max), ...) first operand: without it, sub-4000-char literal
           pieces make every intermediate concat nvarchar(4000) and the assembled batch
           silently TRUNCATES at 4000 chars (caught 2026-07-02: the direct-path batch
           lost its WHERE tail and failed 'Incorrect syntax near AND'). */
        SET @sql = CONVERT(nvarchar(max), N'') + N'
        INSERT INTO ' + @cache_ref + N'
        (
            CommandLogID, RunLabel, DatabaseName, SchemaName, ObjectName, StatisticsName,
            StartTime, EndTime, DurationMs, ErrorNumber, ErrorMessage,
            ModificationCounter, RowCount_, PageCount, SizeMB, DaysStale,
            QualifyReason, HasNorecompute, IsHeap, AutoCreated,
            QSPlanCount, QSTotalExecutions, QSTotalCpuMs,
            QSTotalMemoryGrantKB, QSTotalTempdbPages,
            EffectiveSamplePct, SampleSource, HasFilter, FilteredDriftRatio, IsIncremental,
            ProcessingPosition, ObjectId, StatsId,
            IsCritical, CriticalSampleOverride
        )
        SELECT
            c.ID,
            c.ExtendedInfo.value(N''(ExtendedInfo/RunLabel)[1]'', N''nvarchar(100)''),
            c.DatabaseName, c.SchemaName, c.ObjectName,
            ISNULL(c.StatisticsName, c.IndexName),
            c.StartTime, c.EndTime,
            DATEDIFF(MILLISECOND, c.StartTime, c.EndTime),
            c.ErrorNumber, c.ErrorMessage,
            c.ExtendedInfo.value(N''(ExtendedInfo/ModificationCounter)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/RowCount)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/PageCount)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/SizeMB)[1]'', N''int''),
            c.ExtendedInfo.value(N''(ExtendedInfo/DaysStale)[1]'', N''int''),
            c.ExtendedInfo.value(N''(ExtendedInfo/QualifyReason)[1]'', N''nvarchar(100)''),
            c.ExtendedInfo.value(N''(ExtendedInfo/HasNorecompute)[1]'', N''bit''),
            c.ExtendedInfo.value(N''(ExtendedInfo/IsHeap)[1]'', N''bit''),
            c.ExtendedInfo.value(N''(ExtendedInfo/AutoCreated)[1]'', N''bit''),
            c.ExtendedInfo.value(N''(ExtendedInfo/QSPlanCount)[1]'', N''int''),
            c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalExecutions)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalCpuMs)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalMemoryGrantKB)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalTempdbPages)[1]'', N''bigint''),
            c.ExtendedInfo.value(N''(ExtendedInfo/EffectiveSamplePct)[1]'', N''int''),
            c.ExtendedInfo.value(N''(ExtendedInfo/SampleSource)[1]'', N''nvarchar(50)''),
            c.ExtendedInfo.value(N''(ExtendedInfo/HasFilter)[1]'', N''bit''),
            c.ExtendedInfo.value(N''(ExtendedInfo/FilteredDriftRatio)[1]'', N''float''),
            c.ExtendedInfo.value(N''(ExtendedInfo/IsIncremental)[1]'', N''bit''),
            c.ExtendedInfo.value(N''(ExtendedInfo/ProcessingPosition)[1]'', N''int''),
            c.ExtendedInfo.value(N''(ExtendedInfo/ObjectId)[1]'', N''int''),
            c.ExtendedInfo.value(N''(ExtendedInfo/StatsId)[1]'', N''int''),
            /* sw82: IsCritical + CriticalSampleOverride from per-stat ExtendedInfo (v3.5.0+) */
            c.ExtendedInfo.value(N''(ExtendedInfo/IsCritical)[1]'', N''bit''),
            c.ExtendedInfo.value(N''(ExtendedInfo/CriticalSampleOverride)[1]'', N''bit'')
        FROM ' + @commandlog_ref + N' AS c
        WHERE c.CommandType = N''UPDATE_STATISTICS''
        AND   c.ID > @watermark
        /* 70hh: exclude skip markers -- Command begins SKIPPED: (pre-check path)
                 or ErrorMessage begins TOCTOU_SKIP (CATCH-path v3.5.9+).
                 These carry 0ms duration and pollute duration/appearance/top-table aggregates. */
        AND   NOT (c.Command LIKE N''SKIPPED:%'' OR ISNULL(c.ErrorMessage, N'''') LIKE N''TOCTOU_SKIP%'');
        ';

        DECLARE @cache_new_rows integer;
        EXECUTE sys.sp_executesql @sql, N'@watermark integer', @watermark = @cache_watermark;
        SET @cache_new_rows = @@ROWCOUNT;

        IF @cache_new_rows > 0
            RAISERROR(N'  Cached %i new CommandLog rows', 10, 1, @cache_new_rows) WITH NOWAIT;

        /* Step 2: Read from cache (fast typed column reads, no XML parsing) */
        SET @sql = CONVERT(nvarchar(max), N'') + N'   /* max-typed first operand -- see Step 1 note */
        INSERT INTO #stat_updates
        (
            ID, RunLabel, DatabaseName, SchemaName, ObjectName, StatisticsName,
            StartTime, EndTime, DurationMs, ErrorNumber, ErrorMessage,
            ModificationCounter, RowCount_, PageCount, SizeMB, DaysStale,
            QualifyReason, HasNorecompute, IsHeap, AutoCreated,
            QSPlanCount, QSTotalExecutions, QSTotalCpuMs,
            QSTotalMemoryGrantKB, QSTotalTempdbPages,
            EffectiveSamplePct, SampleSource, HasFilter, FilteredDriftRatio, IsIncremental,
            ProcessingPosition, ObjectId, StatsId,
            IsCritical, CriticalSampleOverride
        )
        SELECT
            ca.CommandLogID, ca.RunLabel, ca.DatabaseName, ca.SchemaName, ca.ObjectName, ca.StatisticsName,
            ca.StartTime, ca.EndTime, ca.DurationMs, ca.ErrorNumber, ca.ErrorMessage,
            ca.ModificationCounter, ca.RowCount_, ca.PageCount, ca.SizeMB, ca.DaysStale,
            ca.QualifyReason, ca.HasNorecompute, ca.IsHeap, ca.AutoCreated,
            ca.QSPlanCount, ca.QSTotalExecutions, ca.QSTotalCpuMs,
            ca.QSTotalMemoryGrantKB, ca.QSTotalTempdbPages,
            ca.EffectiveSamplePct, ca.SampleSource, ca.HasFilter, ca.FilteredDriftRatio, ca.IsIncremental,
            ca.ProcessingPosition, ca.ObjectId, ca.StatsId,
            /* sw82: read from cache when present; NULL when cache rows predate sw82 (column upgrade handles this) */
            ca.IsCritical, ca.CriticalSampleOverride
        FROM ' + @cache_ref + N' AS ca
        WHERE ca.StartTime >= DATEADD(DAY, -@days_back, GETDATE());
        ';

        EXECUTE sys.sp_executesql @sql, N'@days_back integer', @days_back = @DaysBack;

        RAISERROR(N'  (loaded from cache)', 10, 1) WITH NOWAIT;
    END
    ELSE
    BEGIN
        /* Direct XML extraction (no cache available or @SkipHistory=1) */
        SET @sql = CONVERT(nvarchar(max), N'') + N'   /* max-typed first operand -- see cache Step 1 note */
        INSERT INTO #stat_updates
        (
            ID, RunLabel, DatabaseName, SchemaName, ObjectName, StatisticsName,
            StartTime, EndTime, DurationMs, ErrorNumber, ErrorMessage,
            ModificationCounter, RowCount_, PageCount, SizeMB, DaysStale,
            QualifyReason, HasNorecompute, IsHeap, AutoCreated,
            QSPlanCount, QSTotalExecutions, QSTotalCpuMs,
            QSTotalMemoryGrantKB, QSTotalTempdbPages,
            EffectiveSamplePct, SampleSource, HasFilter, FilteredDriftRatio, IsIncremental,
            ProcessingPosition, ObjectId, StatsId,
            IsCritical, CriticalSampleOverride
        )
        SELECT
            id                  = c.ID,
            run_label           = c.ExtendedInfo.value(N''(ExtendedInfo/RunLabel)[1]'', N''nvarchar(100)''),
            database_name       = c.DatabaseName,
            schema_name         = c.SchemaName,
            object_name         = c.ObjectName,
            statistics_name     = ISNULL(c.StatisticsName, c.IndexName),
            start_time          = c.StartTime,
            end_time            = c.EndTime,
            duration_ms         = DATEDIFF(MILLISECOND, c.StartTime, c.EndTime),
            error_number        = c.ErrorNumber,
            error_message       = c.ErrorMessage,
            mod_counter         = c.ExtendedInfo.value(N''(ExtendedInfo/ModificationCounter)[1]'', N''bigint''),
            row_count           = c.ExtendedInfo.value(N''(ExtendedInfo/RowCount)[1]'', N''bigint''),
            page_count          = c.ExtendedInfo.value(N''(ExtendedInfo/PageCount)[1]'', N''bigint''),
            size_mb             = c.ExtendedInfo.value(N''(ExtendedInfo/SizeMB)[1]'', N''int''),
            days_stale          = c.ExtendedInfo.value(N''(ExtendedInfo/DaysStale)[1]'', N''int''),
            qualify_reason      = c.ExtendedInfo.value(N''(ExtendedInfo/QualifyReason)[1]'', N''nvarchar(100)''),
            has_norecompute     = c.ExtendedInfo.value(N''(ExtendedInfo/HasNorecompute)[1]'', N''bit''),
            is_heap             = c.ExtendedInfo.value(N''(ExtendedInfo/IsHeap)[1]'', N''bit''),
            auto_created        = c.ExtendedInfo.value(N''(ExtendedInfo/AutoCreated)[1]'', N''bit''),
            qs_plan_count       = c.ExtendedInfo.value(N''(ExtendedInfo/QSPlanCount)[1]'', N''int''),
            qs_total_executions = c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalExecutions)[1]'', N''bigint''),
            qs_total_cpu_ms     = c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalCpuMs)[1]'', N''bigint''),
            qs_mem_grant_kb     = c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalMemoryGrantKB)[1]'', N''bigint''),
            qs_tempdb_pages     = c.ExtendedInfo.value(N''(ExtendedInfo/QSTotalTempdbPages)[1]'', N''bigint''),
            effective_sample    = c.ExtendedInfo.value(N''(ExtendedInfo/EffectiveSamplePct)[1]'', N''int''),
            sample_source       = c.ExtendedInfo.value(N''(ExtendedInfo/SampleSource)[1]'', N''nvarchar(50)''),
            has_filter          = c.ExtendedInfo.value(N''(ExtendedInfo/HasFilter)[1]'', N''bit''),
            filtered_drift      = c.ExtendedInfo.value(N''(ExtendedInfo/FilteredDriftRatio)[1]'', N''float''),
            is_incremental      = c.ExtendedInfo.value(N''(ExtendedInfo/IsIncremental)[1]'', N''bit''),
            processing_position = c.ExtendedInfo.value(N''(ExtendedInfo/ProcessingPosition)[1]'', N''int''),
            object_id           = c.ExtendedInfo.value(N''(ExtendedInfo/ObjectId)[1]'', N''int''),
            stats_id            = c.ExtendedInfo.value(N''(ExtendedInfo/StatsId)[1]'', N''int''),
            /* sw82: IsCritical + CriticalSampleOverride from per-stat ExtendedInfo (v3.5.0+) */
            is_critical              = c.ExtendedInfo.value(N''(ExtendedInfo/IsCritical)[1]'', N''bit''),
            critical_sample_override = c.ExtendedInfo.value(N''(ExtendedInfo/CriticalSampleOverride)[1]'', N''bit'')
        FROM ' + @commandlog_ref + N' AS c
        WHERE c.CommandType = N''UPDATE_STATISTICS''
        AND   c.StartTime >= DATEADD(DAY, -@days_back, GETDATE())
        /* 70hh: exclude skip markers (same filter as cache path) */
        AND   NOT (c.Command LIKE N''SKIPPED:%'' OR ISNULL(c.ErrorMessage, N'''') LIKE N''TOCTOU_SKIP%'');
        ';

        EXECUTE sys.sp_executesql
            @sql,
            N'@days_back integer',
            @days_back = @DaysBack;
    END;

    /* 70hh: IsSkip is always 0 at this point (skip rows excluded at ingestion).
       @stat_update_count = real updates only; skip rows never enter #stat_updates. */
    DECLARE @stat_update_count integer = (SELECT COUNT_BIG(*) FROM #stat_updates);

    RAISERROR(N'  Stat updates found: %i (skip rows excluded at ingestion -- 70hh)', 10, 1, @stat_update_count) WITH NOWAIT;

    IF @Debug = 1
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        DECLARE @debug_failed_stats integer = (SELECT COUNT_BIG(*) FROM #stat_updates WHERE ErrorNumber > 0);
        DECLARE @debug_null_runlabel integer = (SELECT COUNT_BIG(*) FROM #stat_updates WHERE RunLabel IS NULL);
        DECLARE @debug_distinct_dbs integer = (SELECT COUNT(DISTINCT DatabaseName) FROM #stat_updates);
        DECLARE @debug_distinct_tables integer = (SELECT COUNT(DISTINCT DatabaseName + N'.' + SchemaName + N'.' + ObjectName) FROM #stat_updates);
        RAISERROR(N'DEBUG: #stat_updates: %i failed, %i NULL RunLabel, %i databases, %i distinct tables', 10, 1,
            @debug_failed_stats, @debug_null_runlabel, @debug_distinct_dbs, @debug_distinct_tables) WITH NOWAIT;
        RAISERROR(N'DEBUG: Stat extraction complete (%i ms)', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
    END;

    RAISERROR(N'', 10, 1) WITH NOWAIT;

    /*
    ============================================================================
    HANDLE EMPTY DATA
    ============================================================================
    */
    IF @run_count = 0 AND @stat_update_count = 0
    BEGIN
        RAISERROR(N'No sp_StatUpdate data found in CommandLog for the last %i days.', 10, 1, @DaysBack) WITH NOWAIT;

        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        VALUES
        (
            N'INFO',
            N'NO_DATA',
            N'No sp_StatUpdate entries found in CommandLog',
            N'Analysis window: ' + CONVERT(nvarchar(10), @DaysBack) + N' days. CommandLog: ' + @commandlog_ref,
            N'Run sp_StatUpdate with @LogToTable = N''Y'' (default) to populate CommandLog, then re-run this diagnostic.',
            N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @LogToTable = N''Y'';',
            99
        );

        /* w5p2 / gh-532: the main-path I8 DataStatus finding lives after this early
           return, so emit its UNAVAILABLE form here too -- RS13 consumers get the
           same machine-readable status whether CommandLog is sparse or empty. */
        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        VALUES
        (
            N'INFO',
            N'QS_PERFORMANCE_TREND',
            N'No Query Store CPU data found in any run. RS 13 (QS Performance Correlation) will be empty.'
                + N' [DataStatus: UNAVAILABLE; QSCpuRuns: 0; TrackedStats: 0]',
            N'0 of 0 runs contained Query Store CPU metrics. Ensure QS prioritization is configured (@QueryStore = N''CPU'' in v3) and Query Store is enabled/READ_WRITE.',
            N'Enable QS prioritization: EXEC sp_StatUpdate @QueryStore = N''CPU''.',
            N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @QueryStore = N''CPU'';',
            100
        );

        /* Return result sets in expected format */
        IF @SingleResultSet = 0
        BEGIN
            /* RS 1: Executive Dashboard (empty state) */
            SELECT Category = N'OVERALL', Grade = 'F', Score = 0, Headline = N'No sp_StatUpdate data found in CommandLog.', Detail = N'Run sp_StatUpdate first, then re-run this diagnostic.', Trend = CONVERT(nvarchar(20), N'N/A') WHERE 1 = 1
            UNION ALL
            SELECT N'COMPLETION', 'F', 0, N'No data to evaluate.', NULL, NULL WHERE 1 = 0
            UNION ALL
            SELECT N'RELIABILITY', 'F', 0, N'No data to evaluate.', NULL, NULL WHERE 1 = 0
            UNION ALL
            SELECT N'SPEED', 'F', 0, N'No data to evaluate.', NULL, NULL WHERE 1 = 0
            UNION ALL
            SELECT N'WORKLOAD FOCUS', 'F', 0, N'No data to evaluate.', NULL, NULL WHERE 1 = 0;
            /* RS 2: Recommendations */
            SELECT Severity, Category, Finding, Evidence, Recommendation, ExampleCall,
                Summary = N'[' + Severity + N'] ' + Finding
                    + CASE WHEN Recommendation IS NOT NULL THEN N' -- ' + LEFT(Recommendation, 200) ELSE N'' END
                    + CASE WHEN ExampleCall IS NOT NULL THEN N' Fix: ' + ExampleCall ELSE N'' END
            FROM #recommendations ORDER BY SortPriority, FindingID;
            IF @ExpertMode = 1
            BEGIN
                /* RS 3-12 empty schemas for ExpertMode -- must match production column lists */
                SELECT TotalRuns = CONVERT(bigint, 0), CompletedRuns = CONVERT(bigint, 0), KilledRuns = CONVERT(bigint, 0), CompletionPct = CONVERT(decimal(5,1), 0), TimeLimitedRuns = CONVERT(bigint, 0), NaturalEndRuns = CONVERT(bigint, 0), AvgDurationSec = CONVERT(bigint, NULL), AvgStatsProcessed = CONVERT(bigint, NULL), AvgStatsRemaining = CONVERT(bigint, NULL), TotalStatUpdates = CONVERT(bigint, 0), TotalFailedUpdates = CONVERT(bigint, 0), AnalysisWindowDays = CONVERT(int, @DaysBack), StopReasonDistribution = CONVERT(nvarchar(max), NULL), HealthScore = CONVERT(int, NULL), QSRunCount = CONVERT(bigint, 0), AvgWorkloadCoveragePct = CONVERT(decimal(5,1), NULL), LatestHighCpuFirstQuartilePct = CONVERT(decimal(5,1), NULL), AvgTotalGB = CONVERT(decimal(10,2), NULL), AvgGBPerMin = CONVERT(decimal(10,2), NULL), ReplicaRole = CONVERT(nvarchar(20), NULL);
                SELECT * FROM #runs WHERE 1 = 0;
                SELECT * FROM #stat_updates WHERE 1 = 0;
                SELECT * FROM #stat_updates WHERE 1 = 0;
                SELECT * FROM #stat_updates WHERE 1 = 0;
                SELECT * FROM #runs WHERE 1 = 0;
                IF @Obfuscate = 1 SELECT * FROM #obfuscation_map;
                /* RS 10-12 empty schemas */
                SELECT WeekStart = CONVERT(date, NULL), WeekLabel = CONVERT(nvarchar(5), NULL), RunCount = CONVERT(bigint, NULL), SortStrategy = CONVERT(nvarchar(20), NULL), HighCpuFirstQuartilePct = CONVERT(decimal(5,1), NULL), AvgMinutesToHighCpu = CONVERT(decimal(10,1), NULL), WorkloadCoveragePct = CONVERT(decimal(5,1), NULL), CompletionPct = CONVERT(decimal(5,1), NULL), AvgSecPerStat = CONVERT(decimal(10,1), NULL), AvgGBPerMin = CONVERT(decimal(10,2), NULL), TrendDirection = CONVERT(nvarchar(20), NULL), Top5ConcentrationPct = CONVERT(decimal(5,1), NULL) WHERE 1 = 0;
                SELECT RunLabel = CONVERT(nvarchar(100), NULL), StartTime = CONVERT(datetime2(3), NULL), SortStrategy = CONVERT(nvarchar(20), NULL), StatsFound = CONVERT(int, NULL), StatsProcessed = CONVERT(int, NULL), CompletionPct = CONVERT(decimal(5,1), NULL), HighCpuInFirstQuartilePct = CONVERT(decimal(5,1), NULL), MinutesToHighCpuComplete = CONVERT(decimal(10,1), NULL), WorkloadCoveragePct = CONVERT(decimal(5,1), NULL), AvgSecPerStat = CONVERT(decimal(10,1), NULL), StopReason = CONVERT(nvarchar(50), NULL), DeltaVsPrior = CONVERT(nvarchar(100), NULL) WHERE 1 = 0;
                SELECT WorkloadRank = CONVERT(bigint, NULL), DatabaseName = CONVERT(sysname, NULL), SchemaName = CONVERT(sysname, NULL), TableName = CONVERT(sysname, NULL), StatisticsName = CONVERT(sysname, NULL), ProcessingPosition = CONVERT(int, NULL), TotalQueryCpuMs = CONVERT(bigint, NULL), TotalExecutions = CONVERT(bigint, NULL), PlanCount = CONVERT(int, NULL), UpdateDurationMs = CONVERT(int, NULL), QualifyReason = CONVERT(nvarchar(100), NULL), WorkloadRankPct = CONVERT(decimal(5,1), NULL), CumulativeCpuPct = CONVERT(decimal(5,1), NULL) WHERE 1 = 0;
                /* RS 13: w5p2 / gh-532 -- sentinel row (not an empty stub) so callers can
                   distinguish 'no QS data' from 'no correlation found'.  Mirrors the
                   main-path UNAVAILABLE sentinel column-for-column. */
                SELECT
                    DatabaseName            = N'[NO DATA]',
                    SchemaName              = N'[NO DATA]',
                    TableName               = N'[NO DATA]',
                    StatisticsName          = CONVERT(nvarchar(max), N'No QS CPU data captured in any run within the analysis window. '
                        + N'Enable Query Store and configure sp_StatUpdate with @QueryStore = N''CPU''. '
                        + N'ALTER DATABASE [YourDb] SET QUERY_STORE = ON;'),
                    Appearances             = CONVERT(integer, NULL),
                    FirstRunDate            = CONVERT(datetime2(0), NULL),
                    LastRunDate             = CONVERT(datetime2(0), NULL),
                    FirstCpuMs              = CONVERT(bigint, NULL),
                    LastCpuMs               = CONVERT(bigint, NULL),
                    CpuChangePct            = CONVERT(decimal(10, 1), NULL),
                    FirstCpuPerExec         = CONVERT(decimal(10, 2), NULL),
                    LastCpuPerExec          = CONVERT(decimal(10, 2), NULL),
                    CpuPerExecChangePct     = CONVERT(decimal(10, 1), NULL),
                    CpuTrend                = CONVERT(nvarchar(30), NULL),
                    FirstExecs              = CONVERT(bigint, NULL),
                    LastExecs               = CONVERT(bigint, NULL),
                    FirstPlans              = CONVERT(integer, NULL),
                    LastPlans               = CONVERT(integer, NULL),
                    ForcedPlanCount         = CONVERT(integer, NULL),
                    PlanTrend               = CONVERT(nvarchar(50), NULL),
                    FirstMemoryGrantKB      = CONVERT(bigint, NULL),
                    LastMemoryGrantKB       = CONVERT(bigint, NULL),
                    MemoryGrantChangePct    = CONVERT(decimal(10, 1), NULL),
                    MemoryGrantTrend        = CONVERT(nvarchar(30), NULL),
                    FirstTempdbPages        = CONVERT(bigint, NULL),
                    LastTempdbPages         = CONVERT(bigint, NULL),
                    TempdbChangePct         = CONVERT(decimal(10, 1), NULL),
                    TempdbTrend             = CONVERT(nvarchar(30), NULL);
            END;
        END
        ELSE
        BEGIN
            /* Single result set mode: return Executive Dashboard + NO_DATA recommendation row */
            SELECT
                ResultSetID   = 1,
                ResultSetName = N'Executive Dashboard',
                RowNum        = 1,
                RowData       = (SELECT Category = N'OVERALL', Grade = 'F', Score = 0, Headline = N'No sp_StatUpdate data found in CommandLog.', Detail = N'Run sp_StatUpdate first.', Trend = N'N/A' FOR JSON PATH, WITHOUT_ARRAY_WRAPPER)
            UNION ALL
            SELECT
                ResultSetID   = 2,
                ResultSetName = N'Recommendations',
                RowNum        = 1,
                RowData       = (
                    SELECT
                        Severity       = r.Severity,
                        Category       = r.Category,
                        Finding        = r.Finding,
                        Evidence       = r.Evidence,
                        Recommendation = r.Recommendation,
                        ExampleCall    = r.ExampleCall
                    FROM #recommendations AS r
                    FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
                )
            FROM #recommendations;
        END;

        RETURN;
    END;

    /*
    ============================================================================
    OBFUSCATION PASS
    ============================================================================
    */
    IF @Obfuscate = 1
    BEGIN
        RAISERROR(N'Applying obfuscation...', 10, 1) WITH NOWAIT;

        /* Seed prefix: when @ObfuscationSeed is provided, prepend to all names before hashing */
        DECLARE @seed_prefix nvarchar(128) = ISNULL(@ObfuscationSeed, N'');

        /* Snapshot distinct names BEFORE obfuscating */
        INSERT INTO #obfuscation_map (ObjectType, OriginalName, ObfuscatedName)
        SELECT DISTINCT
            object_type = N'Database',
            original_name = su.DatabaseName,
            obfuscated_name = N'DB_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.DatabaseName), 2), 6)
        FROM #stat_updates AS su
        WHERE su.DatabaseName IS NOT NULL
        UNION
        SELECT DISTINCT
            N'Schema',
            su.SchemaName,
            N'SCH_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.SchemaName), 2), 4)
        FROM #stat_updates AS su
        WHERE su.SchemaName IS NOT NULL
        UNION
        /* BUG-08 fix: hash uses fully-qualified name (DB.Schema.Table) to prevent cross-DB collision.
           OriginalName stored as qualified name for disambiguation in RS8. */
        SELECT DISTINCT
            N'Table',
            su.DatabaseName + N'.' + su.SchemaName + N'.' + su.ObjectName,
            N'TBL_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.DatabaseName + N'.' + su.SchemaName + N'.' + su.ObjectName), 2), 6)
        FROM #stat_updates AS su
        WHERE su.ObjectName IS NOT NULL
        UNION
        SELECT DISTINCT
            N'Statistic',
            su.StatisticsName,
            CASE
                WHEN su.StatisticsName LIKE N'_WA_Sys_%' THEN N'_WA_Sys_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                WHEN su.StatisticsName LIKE N'PK_%'       THEN N'PK_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                WHEN su.StatisticsName LIKE N'IX_%'       THEN N'IX_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                WHEN su.StatisticsName LIKE N'UQ_%'       THEN N'UQ_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                ELSE N'STAT_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
            END
        FROM #stat_updates AS su
        WHERE su.StatisticsName IS NOT NULL;

        /* Also snapshot databases from #runs.
           BUG-09: Known keywords (USER_DATABASES, SYSTEM_DATABASES, ALL_DATABASES) are left
           unobfuscated because they contain no sensitive names. For comma-separated lists,
           the entire string is hashed as one unit -- individual database names within the list
           cannot be reverse-mapped to their per-stat-update obfuscated counterparts. This is
           a known limitation; the obfuscation map entry for such runs is marked "(multi-DB list)". */
        INSERT INTO #obfuscation_map (ObjectType, OriginalName, ObfuscatedName)
        SELECT DISTINCT
            N'RunDatabase',
            r.[Databases],
            N'DB_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + r.[Databases]), 2), 6)
        FROM #runs AS r
        WHERE r.[Databases] IS NOT NULL
        AND   r.[Databases] NOT IN (N'USER_DATABASES', N'SYSTEM_DATABASES', N'ALL_DATABASES', N'AVAILABILITY_GROUP_DATABASES')  /* BUG-09: leave keywords unobfuscated */
        AND   NOT EXISTS (SELECT 1 FROM #obfuscation_map AS m WHERE m.OriginalName = r.[Databases] AND m.ObjectType = N'Database');

        /* Apply obfuscation to #stat_updates */
        UPDATE su
        SET
            su.DatabaseName = N'DB_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.DatabaseName), 2), 6),
            su.SchemaName = N'SCH_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.SchemaName), 2), 4),
            /* BUG-08 fix: hash uses pre-update DatabaseName+SchemaName+ObjectName composite key;
               SQL Server evaluates all RHS before applying SET, so original values are used here. */
            su.ObjectName = N'TBL_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.DatabaseName + N'.' + su.SchemaName + N'.' + su.ObjectName), 2), 6),
            su.StatisticsName = CASE
                WHEN su.StatisticsName LIKE N'_WA_Sys_%' THEN N'_WA_Sys_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                WHEN su.StatisticsName LIKE N'PK_%'       THEN N'PK_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                WHEN su.StatisticsName LIKE N'IX_%'       THEN N'IX_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                WHEN su.StatisticsName LIKE N'UQ_%'       THEN N'UQ_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
                ELSE N'STAT_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.StatisticsName), 2), 6)
            END
        FROM #stat_updates AS su;

        /* Obfuscate #runs.Databases -- skip known keywords (BUG-09: they contain no sensitive names) */
        UPDATE r
        SET r.[Databases] = N'DB_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + r.[Databases]), 2), 6)
        FROM #runs AS r
        WHERE r.[Databases] IS NOT NULL
        AND   r.[Databases] NOT IN (N'USER_DATABASES', N'SYSTEM_DATABASES', N'ALL_DATABASES', N'AVAILABILITY_GROUP_DATABASES');

        /* Obfuscate RunLabels (contain server names) */
        UPDATE r
        SET r.RunLabel = N'RUN_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + r.RunLabel), 2), 8)
        FROM #runs AS r;

        UPDATE su
        SET su.RunLabel = N'RUN_' + RIGHT(CONVERT(varchar(8), HASHBYTES('MD5', @seed_prefix + su.RunLabel), 2), 8)
        FROM #stat_updates AS su
        WHERE su.RunLabel IS NOT NULL;

        DECLARE @obfuscation_count integer = (SELECT COUNT_BIG(*) FROM #obfuscation_map);
        RAISERROR(N'  Obfuscated %i mapping entries', 10, 1, @obfuscation_count) WITH NOWAIT;

        /* Persist obfuscation map to table if requested */
        IF @ObfuscationMapTable IS NOT NULL
        BEGIN
            /* Build safe table reference from PARSENAME to prevent SQL injection.
               Supports 1-part (dbo assumed), 2-part (schema.table), or 3-part (db.schema.table). */
            DECLARE
                @map_part1 sysname = PARSENAME(@ObfuscationMapTable, 1),  /* table */
                @map_part2 sysname = PARSENAME(@ObfuscationMapTable, 2),  /* schema */
                @map_part3 sysname = PARSENAME(@ObfuscationMapTable, 3),  /* database */
                @map_safe_name nvarchar(500);

            IF @map_part1 IS NULL
            BEGIN
                RAISERROR(N'ERROR: @ObfuscationMapTable has invalid table name: %s', 16, 1, @ObfuscationMapTable) WITH NOWAIT;
            END
            ELSE
            BEGIN
                SET @map_safe_name = ISNULL(QUOTENAME(@map_part3) + N'.', N'')
                    + ISNULL(QUOTENAME(@map_part2) + N'.', N'')
                    + QUOTENAME(@map_part1);

                DECLARE @map_sql nvarchar(max);

                SET @map_sql = N'
                    IF OBJECT_ID(' + QUOTENAME(@ObfuscationMapTable, '''') + N') IS NULL
                    BEGIN
                        CREATE TABLE ' + @map_safe_name + N' (
                            ObjectType     nvarchar(20)   NOT NULL,
                            OriginalName   nvarchar(256)  NOT NULL,
                            ObfuscatedName nvarchar(50)   NOT NULL,
                            CapturedAt     datetime2      NOT NULL DEFAULT SYSDATETIME()
                        );
                    END;

                    INSERT INTO ' + @map_safe_name + N' (ObjectType, OriginalName, ObfuscatedName)
                    SELECT m.ObjectType, m.OriginalName, m.ObfuscatedName
                    FROM #obfuscation_map AS m
                    WHERE NOT EXISTS (
                        SELECT 1 FROM ' + @map_safe_name + N' AS t
                        WHERE t.OriginalName = m.OriginalName
                        AND   t.ObjectType   = m.ObjectType
                    );';

                BEGIN TRY
                    EXECUTE sp_executesql @map_sql;

                    SET @map_safe_name = N'  Obfuscation map saved to ' + @map_safe_name;
                    RAISERROR(@map_safe_name, 10, 1) WITH NOWAIT;
                END TRY
                BEGIN CATCH
                    /* INSERT...EXEC context prevents writes to persistent tables.
                       This is expected when caller does INSERT INTO #t EXEC sp_StatUpdate_Diag @SingleResultSet=1. */
                    RAISERROR(N'  WARNING: Could not write to @ObfuscationMapTable (INSERT...EXEC context). Run without INSERT...EXEC to persist the map.', 10, 1) WITH NOWAIT;
                END CATCH;

                RAISERROR(N'', 10, 1) WITH NOWAIT;
                RAISERROR(N'=== Decode obfuscated tokens ===', 10, 1) WITH NOWAIT;
                RAISERROR(N'SELECT ObjectType, OriginalName, ObfuscatedName', 10, 1) WITH NOWAIT;
                RAISERROR(N'FROM %s WHERE ObfuscatedName = N''<paste_token_here>'';', 10, 1, @ObfuscationMapTable) WITH NOWAIT;
            END;
        END;

        RAISERROR(N'', 10, 1) WITH NOWAIT;
    END;

    IF @Debug = 1
    BEGIN
        RAISERROR(N'DEBUG: #runs sample (top 5)', 10, 1) WITH NOWAIT;
        SELECT TOP (5) * FROM #runs ORDER BY StartTime DESC;

        RAISERROR(N'DEBUG: #stat_updates sample (top 5)', 10, 1) WITH NOWAIT;
        SELECT TOP (5) * FROM #stat_updates ORDER BY StartTime DESC;
    END;

    /*
    ============================================================================
    FORCED PLAN INVENTORY (#292): Lightweight cross-database lookup for forced plans
    on objects appearing in QS correlation data. Feeds RS 13 ForcedPlanCount column,
    I8 forced-plan-at-risk recommendation, and enhanced PlanTrend labels.
    ============================================================================
    */
    CREATE TABLE #forced_plans
    (
        DatabaseName sysname NOT NULL,
        ObjectName sysname NOT NULL,
        ForcedPlanCount integer NOT NULL DEFAULT 0,
        CONSTRAINT PK_forced_plans PRIMARY KEY CLUSTERED (DatabaseName, ObjectName)
    );

    BEGIN TRY
        DECLARE
            @fp_db sysname,
            @fp_sql nvarchar(max);

        DECLARE fp_cursor CURSOR LOCAL FAST_FORWARD FOR
            SELECT DISTINCT su.DatabaseName
            FROM #stat_updates AS su
            WHERE su.QSTotalCpuMs IS NOT NULL
            AND   su.QSTotalCpuMs > 0;

        OPEN fp_cursor;
        FETCH NEXT FROM fp_cursor INTO @fp_db;

        WHILE @@FETCH_STATUS = 0
        BEGIN
            /* Query each database's QS catalog for forced plans on objects in our data set.
               Joins query_store_plan -> query_store_query -> sys.objects to map plan->object_id.
               Skip if database doesn't exist (common with test data or obfuscated names).
               TRY/CATCH per-database: if QS is disabled or DB is inaccessible, skip silently. */
            IF DB_ID(@fp_db) IS NOT NULL
            BEGIN
            SET @fp_sql = N'
                BEGIN TRY
                    INSERT INTO #forced_plans (DatabaseName, ObjectName, ForcedPlanCount)
                    SELECT
                        @db_name,
                        o.name,
                        COUNT_BIG(*)
                    FROM ' + QUOTENAME(@fp_db) + N'.sys.query_store_plan AS qsp
                    INNER JOIN ' + QUOTENAME(@fp_db) + N'.sys.query_store_query AS qsq
                        ON qsq.query_id = qsp.query_id
                    INNER JOIN ' + QUOTENAME(@fp_db) + N'.sys.objects AS o
                        ON o.object_id = qsq.object_id
                    WHERE qsp.is_forced_plan = 1
                    AND   o.name IN (SELECT DISTINCT su2.ObjectName FROM #stat_updates AS su2 WHERE su2.DatabaseName = @db_name AND su2.QSTotalCpuMs IS NOT NULL)
                    GROUP BY o.name;
                END TRY
                BEGIN CATCH
                    /* QS disabled, DB offline, permissions -- skip silently */
                END CATCH;';

            EXECUTE sys.sp_executesql @fp_sql, N'@db_name sysname', @db_name = @fp_db;

            IF @Debug = 1
            BEGIN
                DECLARE @fp_count_msg nvarchar(200) = N'  Forced plans in ' + @fp_db + N': '
                    + CONVERT(nvarchar(10), ISNULL((SELECT SUM(ForcedPlanCount) FROM #forced_plans WHERE DatabaseName = @fp_db), 0))
                    + N' across '
                    + CONVERT(nvarchar(10), (SELECT COUNT(*) FROM #forced_plans WHERE DatabaseName = @fp_db))
                    + N' object(s)';
                RAISERROR(@fp_count_msg, 10, 1) WITH NOWAIT;
            END;
            END; /* END IF DB_ID(@fp_db) IS NOT NULL */

            FETCH NEXT FROM fp_cursor INTO @fp_db;
        END;

        CLOSE fp_cursor;
        DEALLOCATE fp_cursor;
    END TRY
    BEGIN CATCH
        /* Graceful fallback: #forced_plans stays empty, RS 13 works without it */
        DECLARE @fp_error nvarchar(4000) = ERROR_MESSAGE();

        IF CURSOR_STATUS('local', 'fp_cursor') >= 0
        BEGIN
            CLOSE fp_cursor;
            DEALLOCATE fp_cursor;
        END;

        IF @Debug = 1
            RAISERROR(N'  Forced plan lookup failed (non-fatal): %s', 10, 1, @fp_error) WITH NOWAIT;
    END CATCH;

    /*
    ============================================================================
    WORKLOAD IMPACT STAGING (#255, #260, #259, #261, #263, #264, #265)
    Per-object workload metrics from QS data in #stat_updates.
    ============================================================================
    */
    CREATE TABLE #workload_impact
    (
        DatabaseName sysname NOT NULL,
        SchemaName sysname NOT NULL,
        ObjectName sysname NOT NULL,
        TotalCpuMs bigint NOT NULL DEFAULT 0,
        ImpactScore decimal(5, 2) NULL,     /* 0.00-1.00 percentile rank */
        CumulativePct decimal(5, 1) NULL,   /* running SUM / total */
        IsVolatile bit NOT NULL DEFAULT 0   /* #259: MAX/MIN QSTotalCpuMs > 10x across runs */
    );

    /* Populate from latest run per stat, grouped by object */
    ;WITH latest_stat_cpu AS
    (
        SELECT
            su.DatabaseName,
            su.SchemaName,
            su.ObjectName,
            su.StatisticsName,
            su.QSTotalCpuMs,
            rn = ROW_NUMBER() OVER (
                PARTITION BY
                    ISNULL(CONVERT(nvarchar(20), su.ObjectId), su.DatabaseName + N'.' + su.SchemaName + N'.' + su.ObjectName),
                    ISNULL(CONVERT(nvarchar(20), su.StatsId), su.StatisticsName)
                ORDER BY su.StartTime DESC
            )
        FROM #stat_updates AS su
        WHERE su.QSTotalCpuMs IS NOT NULL
        AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
    ),
    object_cpu AS
    (
        SELECT
            DatabaseName,
            SchemaName,
            ObjectName,
            TotalCpuMs = SUM(ISNULL(QSTotalCpuMs, 0))
        FROM latest_stat_cpu
        WHERE rn = 1
        GROUP BY DatabaseName, SchemaName, ObjectName
        HAVING SUM(ISNULL(QSTotalCpuMs, 0)) > 0
    )
    INSERT INTO #workload_impact (DatabaseName, SchemaName, ObjectName, TotalCpuMs, ImpactScore, CumulativePct)
    SELECT
        oc.DatabaseName,
        oc.SchemaName,
        oc.ObjectName,
        oc.TotalCpuMs,
        ImpactScore  = CONVERT(decimal(5, 2), PERCENT_RANK() OVER (ORDER BY oc.TotalCpuMs)),
        CumulativePct = CONVERT(decimal(5, 1), 100.0 *
            SUM(oc.TotalCpuMs) OVER (ORDER BY oc.TotalCpuMs DESC ROWS UNBOUNDED PRECEDING)
            / NULLIF(SUM(oc.TotalCpuMs) OVER (), 0))
    FROM object_cpu AS oc;

    /* #259: Mark volatile stats -- QSTotalCpuMs varies > 10x across runs */
    ;WITH stat_volatility AS
    (
        SELECT
            su.DatabaseName,
            su.SchemaName,
            su.ObjectName,
            IsVolatile = CASE
                WHEN MAX(su.QSTotalCpuMs) > 10 * NULLIF(MIN(su.QSTotalCpuMs), 0) THEN 1
                ELSE 0
            END
        FROM #stat_updates AS su
        WHERE su.QSTotalCpuMs IS NOT NULL
        AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName
        HAVING COUNT(DISTINCT su.RunLabel) >= 2
    )
    UPDATE wi
    SET wi.IsVolatile = sv.IsVolatile
    FROM #workload_impact AS wi
    INNER JOIN stat_volatility AS sv
        ON sv.DatabaseName = wi.DatabaseName
        AND sv.SchemaName  = wi.SchemaName
        AND sv.ObjectName  = wi.ObjectName
    WHERE sv.IsVolatile = 1;

    DECLARE @workload_impact_count integer = (SELECT COUNT_BIG(*) FROM #workload_impact);
    IF @Debug = 1
        RAISERROR(N'  Workload impact: %i objects with QS data', 10, 1, @workload_impact_count) WITH NOWAIT;

    /* Compute per-run data volume from stat-level page counts (PageCount * 8KB).
       Fallback: aggregate from per-stat ExtendedInfo when summary TotalPagesProcessed is absent (pre-v2.24 runs). */
    UPDATE r
    SET r.TotalGB = COALESCE(
        su_vol.total_gb,
        CONVERT(decimal(10, 2), 0)
    )
    FROM #runs AS r
    LEFT JOIN (
        SELECT
            su.RunLabel,
            total_gb = CONVERT(decimal(10, 2), SUM(ISNULL(su.PageCount, 0)) * 8.0 / 1024.0 / 1024.0)
        FROM #stat_updates AS su
        WHERE su.ErrorNumber = 0
        GROUP BY su.RunLabel
    ) AS su_vol ON su_vol.RunLabel = r.RunLabel
    WHERE r.IsKilled = 0;

    /*
    ============================================================================
    DIAGNOSTIC CHECKS
    ============================================================================
    */
    RAISERROR(N'Running diagnostic checks...', 10, 1) WITH NOWAIT;

    /* ======================================================================
       C1: KILLED RUNS (START without matching END)
       ====================================================================== */
    IF EXISTS (SELECT 1 FROM #runs WHERE IsKilled = 1)
    BEGIN
        /* v2026.04.20.2: cap Evidence to the 10 most recent run dates so we do
           not overflow the nvarchar(2000) column when 90+ killed runs exist. */
        DECLARE @c1_killed_total int = (SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 1);

        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        SELECT
            N'CRITICAL',
            N'KILLED_RUNS',
            N'Found ' + CONVERT(nvarchar(10), @c1_killed_total) + N' killed run(s) in the last '
                + CONVERT(nvarchar(10), @DaysBack) + N' days',
            CASE WHEN @c1_killed_total > 10
                 THEN N'Run dates (10 most recent of ' + CONVERT(nvarchar(10), @c1_killed_total) + N'): '
                 ELSE N'Run dates: '
            END
                + STRING_AGG(CONVERT(nvarchar(20), x.StartTime, 120), N', ')
                    WITHIN GROUP (ORDER BY x.StartTime DESC),
            N'Killed runs leave orphaned START markers and can indicate: '
                + N'(1) SQL Agent job killed or timed out, '
                + N'(2) Server restart during maintenance, '
                + N'(3) Manual cancellation. '
                + N'Orphan cleanup runs automatically in v3. On v2, set @CleanupOrphanedRuns = N''Y'' (default in v1.9+). '
                + N'Review SQL Agent job history for stop events. '
                + N'Consider adjusting @TimeLimit to complete within your maintenance window.',
            N'EXECUTE dbo.sp_StatUpdate @Preset = N''NIGHTLY'', @Databases = N''USER_DATABASES'', @TimeLimit = 3600;',
            10
        FROM
        (
            SELECT TOP (10) r.StartTime
            FROM #runs AS r
            WHERE r.IsKilled = 1
            ORDER BY r.StartTime DESC
        ) AS x;

        RAISERROR(N'  [CRITICAL] C1: Killed runs detected', 10, 1) WITH NOWAIT;
    END;

    /* ======================================================================
       C2: REPEATED FAILURES (same stat failing consistently)
       ====================================================================== */
    INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
    SELECT
        N'CRITICAL',
        N'REPEATED_FAILURES',
        N'Statistic fails consistently: ' + su.DatabaseName + N'.'
            + su.SchemaName + N'.' + su.ObjectName + N'.' + su.StatisticsName,
        N'Failed in ' + CONVERT(nvarchar(10), COUNT(DISTINCT su.RunLabel))
            + N' run(s). Errors: ' + (
                SELECT STRING_AGG(err_num, N', ')
                FROM (SELECT DISTINCT CONVERT(nvarchar(20), su2.ErrorNumber) AS err_num
                      FROM #stat_updates AS su2
                      WHERE su2.ErrorNumber > 0
                      AND   su2.DatabaseName = su.DatabaseName
                      AND   su2.SchemaName = su.SchemaName
                      AND   su2.ObjectName = su.ObjectName
                      AND   su2.StatisticsName = su.StatisticsName) AS distinct_errors
            ),
        N'Investigate the specific error. Common causes: '
            + N'lock contention (Error 1222 - use @LockTimeout), '
            + N'schema changes mid-maintenance, '
            + N'or corrupt statistics (DROP + CREATE). '
            + N'Most common error: ' + LEFT(MAX(su.ErrorMessage), 200),
        N'EXECUTE dbo.sp_StatUpdate @LockTimeout = 30, @FailFast = 0;',
        10
    FROM #stat_updates AS su
    WHERE su.ErrorNumber > 0
    GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
    HAVING COUNT(DISTINCT su.RunLabel) >= @FailureThreshold;

    IF @@ROWCOUNT > 0
        RAISERROR(N'  [CRITICAL] C2: Repeated failures detected', 10, 1) WITH NOWAIT;

    /* ======================================================================
       C3: TIME LIMIT EXHAUSTION
       c53 fix: suppress false positives when all workers used StatsInParallel='Y'
       and the aggregate queue was fully processed (SUM(StatsRemaining)=0).  In
       that state individual workers exiting with TIME_LIMIT or PARALLEL_COMPLETE
       are not a real backlog signal -- the logical run completed.
       @parallel_aggregate_done is reused by W3 and the COMPLETION grade (via
       @w3_parallel_complete) so the same semantics apply across all three checks.
       ====================================================================== */
    /* c53: all-parallel deployment + zero aggregate remaining = logical run completed.
       Set once here; W3 and COMPLETION grade reuse via @w3_parallel_complete. */
    DECLARE @parallel_aggregate_done bit = 0;
    IF NOT EXISTS (SELECT 1 FROM #runs WHERE IsKilled = 0 AND ISNULL(StatsInParallel, N'N') <> N'Y')
    AND EXISTS    (SELECT 1 FROM #runs WHERE IsKilled = 0)
    AND (SELECT SUM(ISNULL(StatsRemaining, 0)) FROM #runs WHERE IsKilled = 0) = 0
        SET @parallel_aggregate_done = 1;

    DECLARE
        @total_completed_runs integer = (SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 0),
        /* e5x fix: also count COMPLETED runs with StatsRemaining>0 -- these are functionally
           time-limited even though they ended with StopReason=COMPLETED (ran out of budget
           before all qualifying stats were processed). */
        @time_limit_runs integer = (
            /* gh-473: Filter by IsKilled=0 to match @total_completed_runs denominator.
               Without this, killed runs counted in numerator but not denominator inflated the pct. */
            SELECT COUNT_BIG(*) FROM #runs
            WHERE IsKilled = 0
            AND   (StopReason = N'TIME_LIMIT'
                OR (StopReason = N'COMPLETED' AND ISNULL(StatsRemaining, 0) > 0))
        ),
        /* BUG-12: use latest run's TimeLimit for the recommendation, not MAX across all TIME_LIMIT runs.
           Using MAX of historical TIME_LIMIT runs could recommend an extreme value from a one-off test run. */
        @latest_timelimit_sec integer = (SELECT TOP 1 TimeLimit FROM #runs WHERE IsKilled = 0 ORDER BY StartTime DESC);

    IF @parallel_aggregate_done = 0
    AND @total_completed_runs > 0
    AND @time_limit_runs * 100.0 / @total_completed_runs >= @TimeLimitExhaustionPct
    BEGIN
        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        SELECT
            N'CRITICAL',
            N'TIME_LIMIT_EXHAUSTION',
            CONVERT(nvarchar(10), @time_limit_runs) + N' of '
                + CONVERT(nvarchar(10), @total_completed_runs) + N' completed runs hit TIME_LIMIT ('
                + CONVERT(nvarchar(10), CONVERT(integer, @time_limit_runs * 100.0 / @total_completed_runs)) + N'%)',
            N'Average stats remaining when time-limited: ' + CONVERT(nvarchar(10), AVG(r.StatsRemaining))
                /* BUG-12 fix: show latest run's TimeLimit instead of AVG across TIME_LIMIT runs */
                + N'. Current time limit (latest run): ' + ISNULL(CONVERT(nvarchar(10), @latest_timelimit_sec), N'NULL') + N' seconds ('
                + ISNULL(CONVERT(nvarchar(10), @latest_timelimit_sec / 60), N'NULL') + N' minutes)'
                /* #265: Append workload impact context when QS data available */
                + ISNULL((
                    SELECT N'. ' + CONVERT(nvarchar(10), COUNT_BIG(*))
                        + N' of top-10 workload stats were not reached before time limit'
                    FROM #workload_impact AS wi
                    WHERE wi.ImpactScore >= 0.90
                    AND   NOT EXISTS (
                        SELECT 1 FROM #stat_updates AS su_c3
                        WHERE su_c3.DatabaseName = wi.DatabaseName
                        AND   su_c3.SchemaName   = wi.SchemaName
                        AND   su_c3.ObjectName   = wi.ObjectName
                        AND   su_c3.RunLabel IN (SELECT r2.RunLabel FROM #runs AS r2 WHERE r2.StopReason = N'TIME_LIMIT')
                        AND   (su_c3.ErrorNumber = 0 OR su_c3.ErrorNumber IS NULL)
                    )
                    HAVING COUNT_BIG(*) > 0
                ), N''),
            N'Stats are consistently not finishing within the time limit. Options: '
                + N'(1) Increase @TimeLimit to ' + ISNULL(CONVERT(nvarchar(10), @latest_timelimit_sec * 2), N'<current_value_x2>') + N' seconds, '
                + N'(2) Enable @LongRunningThresholdMinutes to cap slow individual stats, '
                + N'(3) Raise @ModificationThreshold to reduce qualifying stats, '
                + N'(4) Use @Preset = N''NIGHTLY'' for balanced defaults.',
            N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @TimeLimit = '
                + ISNULL(CONVERT(nvarchar(10), @latest_timelimit_sec * 2), N'<current_value_x2>')
                + N', @LongRunningThresholdMinutes = 30;',
            15
        FROM #runs AS r
        WHERE r.StopReason = N'TIME_LIMIT'
           OR (r.StopReason = N'COMPLETED' AND ISNULL(r.StatsRemaining, 0) > 0);  /* e5x: COMPLETED with leftovers = functionally time-limited */

        RAISERROR(N'  [CRITICAL] C3: Time limit exhaustion detected', 10, 1) WITH NOWAIT;
    END;

    /* ======================================================================
       C4: DEGRADING THROUGHPUT
       ====================================================================== */
    /* #306: Compare only runs with same StatsInParallel mode to avoid false CRITICAL
       when switching between serial and parallel modes changes throughput characteristics */
    ;WITH throughput_windows AS
    (
        SELECT
            window_label = CASE
                WHEN r.StartTime >= DATEADD(DAY, -@ThroughputWindowDays, GETDATE()) THEN N'RECENT'
                ELSE N'PRIOR'
            END,
            parallel_mode = ISNULL(r.StatsInParallel, N'N'),
            avg_sec_per_stat = CASE
                WHEN r.StatsProcessed > 0
                THEN r.DurationSeconds * 1.0 / r.StatsProcessed
                ELSE NULL
            END,
            gb_per_min = CASE
                WHEN r.DurationSeconds > 0 AND r.TotalGB IS NOT NULL
                THEN CONVERT(decimal(10, 2), r.TotalGB / (r.DurationSeconds / 60.0))
                ELSE NULL
            END
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.StatsProcessed > 0
    ),
    window_avgs AS
    (
        SELECT
            window_label,
            parallel_mode,
            avg_sec = AVG(avg_sec_per_stat),
            avg_gb_min = AVG(gb_per_min),
            run_count = COUNT_BIG(*)
        FROM throughput_windows
        GROUP BY window_label, parallel_mode
    )
    INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
    SELECT
        /* If modes differ between recent/prior windows, downgrade to INFO */
        CASE WHEN recent_w.parallel_mode = prior_w.parallel_mode THEN N'CRITICAL' ELSE N'INFO' END,
        N'DEGRADING_THROUGHPUT',
        CASE WHEN recent_w.parallel_mode = prior_w.parallel_mode
            THEN N'Throughput degraded: recent avg ' + CONVERT(nvarchar(20), CONVERT(decimal(10, 1), recent_w.avg_sec))
                + N' sec/stat vs. prior ' + CONVERT(nvarchar(20), CONVERT(decimal(10, 1), prior_w.avg_sec))
                + N' sec/stat (' + CONVERT(nvarchar(20), CONVERT(bigint, CASE WHEN recent_w.avg_sec / prior_w.avg_sec > 1000 THEN 99900 ELSE (recent_w.avg_sec / prior_w.avg_sec - 1) * 100 END))
                + N'% slower)'
            ELSE N'Throughput changed but parallelism mode also changed (StatsInParallel: '
                + prior_w.parallel_mode + N' -> ' + recent_w.parallel_mode
                + N'). Recent avg ' + CONVERT(nvarchar(20), CONVERT(decimal(10, 1), recent_w.avg_sec))
                + N' sec/stat vs. prior ' + CONVERT(nvarchar(20), CONVERT(decimal(10, 1), prior_w.avg_sec))
                + N' sec/stat -- not directly comparable.'
        END,
        N'Recent window: ' + CONVERT(nvarchar(10), recent_w.run_count) + N' runs averaging '
            + CONVERT(nvarchar(20), CONVERT(decimal(10, 1), recent_w.avg_sec)) + N' sec/stat'
            + CASE WHEN recent_w.avg_gb_min IS NOT NULL THEN N' (' + CONVERT(nvarchar(20), recent_w.avg_gb_min) + N' GB/min)' ELSE N'' END
            + N' (StatsInParallel=' + recent_w.parallel_mode + N'). '
            + N'Prior window: ' + CONVERT(nvarchar(10), prior_w.run_count) + N' runs averaging '
            + CONVERT(nvarchar(20), CONVERT(decimal(10, 1), prior_w.avg_sec)) + N' sec/stat'
            + CASE WHEN prior_w.avg_gb_min IS NOT NULL THEN N' (' + CONVERT(nvarchar(20), prior_w.avg_gb_min) + N' GB/min)' ELSE N'' END
            + N' (StatsInParallel=' + prior_w.parallel_mode + N'). '
            + N'Comparison window: ' + CONVERT(nvarchar(10), @ThroughputWindowDays) + N' days.',
        N'Possible causes: (1) Table growth increasing update cost, '
            + N'(2) I/O subsystem degradation, '
            + N'(3) Concurrent workload pressure, '
            + N'(4) Sample rate too high for growing tables. '
            + N'Consider: @StatsInParallel for throughput, '
            + N'@LongRunningThresholdMinutes to cap outliers, '
            + N'or investigate storage performance.',
        N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @StatsInParallel = N''Y'', @LongRunningThresholdMinutes = 15;',
        20
    FROM window_avgs AS recent_w
    CROSS JOIN window_avgs AS prior_w
    WHERE recent_w.window_label = N'RECENT'
    AND   prior_w.window_label = N'PRIOR'
    AND   prior_w.avg_sec > 0
    AND   recent_w.avg_sec > prior_w.avg_sec * 1.5
    AND   prior_w.run_count >= 2
    AND   recent_w.run_count >= 1
    /* gh-479: Strict parallel-mode parity -- only compare within the same StatsInParallel mode.
       Cross-mode comparison was producing misleading 'INFO' rows that looked like throughput
       degradation but reflected only a parallel/serial mode switch. */
    AND   recent_w.parallel_mode = prior_w.parallel_mode;

    IF @@ROWCOUNT > 0
        RAISERROR(N'  [CRITICAL] C4: Degrading throughput detected', 10, 1) WITH NOWAIT;

    /* ======================================================================
       C6: SILENT NO-OP RUN (sp_StatUpdate-kzx0)
       Validated against the sp_StatUpdate-v31y zombie-queue incident: a
       drained parallel queue whose leadership could not be re-claimed made
       every new worker join, claim nothing, and exit PARALLEL_COMPLETE with
       StatsFound > 0 and StatsProcessed = 0 -- maintenance silently stopped
       while every run self-reported success.

       Signature: non-killed run, normal-completion StopReason, StatsFound > 0,
       StatsProcessed = 0, AND no evidence anyone else did the work:
         (a) no overlapping non-killed run with StatsProcessed > 0 (healthy
             late joiners overlap the busy workers that drained the queue), and
         (b) no sp_StatUpdate UPDATE_STATISTICS activity (RunLabel-tagged rows)
             overlapping the run window -- covers in-flight workers whose END
             row does not exist yet at analysis time.
       Windows are padded +/- 5 minutes; unfinished stat rows are bounded to
       60 minutes so ancient killed-run rows cannot mask detection.
       3j5l guard: runs whose window group genuinely drained the queue
       (any overlapping worker processed > 0, or own StatsProcessed > 0) are
       never flagged -- no regression of the parallel grade-A fix.
       ====================================================================== */
    DECLARE @c6_silent_noop bit = 0;
    DECLARE @c6_count integer = 0;

    SELECT @c6_count = COUNT_BIG(*)
    FROM #runs AS r
    WHERE r.IsKilled = 0
    AND   r.StopReason IN (N'PARALLEL_COMPLETE', N'COMPLETED', N'NATURAL_END')
    AND   r.StatsFound > 0
    AND   ISNULL(r.StatsProcessed, 0) = 0
    AND   NOT EXISTS
          (
              SELECT 1
              FROM #runs AS r2
              WHERE r2.RunLabel <> r.RunLabel
              AND   r2.IsKilled = 0
              AND   ISNULL(r2.StatsProcessed, 0) > 0
              AND   r2.StartTime <= DATEADD(MINUTE, 5, ISNULL(r.EndTime, r.StartTime))
              AND   ISNULL(r2.EndTime, DATEADD(SECOND, ISNULL(r2.TimeLimit, 18000), r2.StartTime)) >= DATEADD(MINUTE, -5, r.StartTime)
          )
    AND   NOT EXISTS
          (
              SELECT 1
              FROM #stat_updates AS su
              WHERE su.RunLabel IS NOT NULL
              AND   su.StartTime <= DATEADD(MINUTE, 5, ISNULL(r.EndTime, r.StartTime))
              AND   ISNULL(su.EndTime, DATEADD(MINUTE, 60, su.StartTime)) >= DATEADD(MINUTE, -5, r.StartTime)
          );

    IF @c6_count > 0
    BEGIN
        SET @c6_silent_noop = 1;

        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        SELECT
            N'CRITICAL',
            N'SILENT_NOOP_RUN',
            CONVERT(nvarchar(10), @c6_count) + N' run(s) self-reported normal completion but processed 0 of their qualifying statistics',
            CASE WHEN @c6_count > 10
                 THEN N'Runs (10 most recent of ' + CONVERT(nvarchar(10), @c6_count) + N'): '
                 ELSE N'Runs: '
            END
                + STRING_AGG(
                      CONVERT(nvarchar(20), x.StartTime, 120) + N' (' + x.StopReason
                      + N', found ' + CONVERT(nvarchar(10), x.StatsFound) + N', processed 0)',
                      N'; ')
                      WITHIN GROUP (ORDER BY x.StartTime DESC),
            N'Statistics maintenance is silently NOT happening -- these runs found work, '
                + N'processed none of it, and no other worker in the same window did either. '
                + N'Known cause: zombied parallel queue leadership (fixed in sp_StatUpdate 3.5.7) -- '
                + N'a drained queue whose leader SessionID was recycled refused re-claim, so every '
                + N'new worker joined, claimed nothing, and exited PARALLEL_COMPLETE. '
                + N'(1) Upgrade sp_StatUpdate to 3.5.7+. '
                + N'(2) Inspect dbo.Queue / dbo.QueueStatistic for rows referencing dead sessions. '
                + N'(3) If stale, clear the queue state so the next run claims leadership fresh.',
            N'SELECT q.QueueID, q.SessionID, q.QueueStartTime, qs.DatabaseName, qs.ObjectName, qs.SessionID, qs.TableStartTime, qs.TableEndTime FROM dbo.Queue AS q LEFT JOIN dbo.QueueStatistic AS qs ON qs.QueueID = q.QueueID WHERE q.ObjectName = N''sp_StatUpdate'';',
            5
        FROM
        (
            SELECT TOP (10)
                r.StartTime,
                r.StopReason,
                r.StatsFound
            FROM #runs AS r
            WHERE r.IsKilled = 0
            AND   r.StopReason IN (N'PARALLEL_COMPLETE', N'COMPLETED', N'NATURAL_END')
            AND   r.StatsFound > 0
            AND   ISNULL(r.StatsProcessed, 0) = 0
            AND   NOT EXISTS
                  (
                      SELECT 1
                      FROM #runs AS r2
                      WHERE r2.RunLabel <> r.RunLabel
                      AND   r2.IsKilled = 0
                      AND   ISNULL(r2.StatsProcessed, 0) > 0
                      AND   r2.StartTime <= DATEADD(MINUTE, 5, ISNULL(r.EndTime, r.StartTime))
                      AND   ISNULL(r2.EndTime, DATEADD(SECOND, ISNULL(r2.TimeLimit, 18000), r2.StartTime)) >= DATEADD(MINUTE, -5, r.StartTime)
                  )
            AND   NOT EXISTS
                  (
                      SELECT 1
                      FROM #stat_updates AS su
                      WHERE su.RunLabel IS NOT NULL
                      AND   su.StartTime <= DATEADD(MINUTE, 5, ISNULL(r.EndTime, r.StartTime))
                      AND   ISNULL(su.EndTime, DATEADD(MINUTE, 60, su.StartTime)) >= DATEADD(MINUTE, -5, r.StartTime)
                  )
            ORDER BY r.StartTime DESC
        ) AS x;

        RAISERROR(N'  [CRITICAL] C6: Silent no-op run(s) detected (%i)', 10, 1, @c6_count) WITH NOWAIT;
    END;

    /* ======================================================================
       W1: SUBOPTIMAL PARAMETERS (checks against most recent run)
       ====================================================================== */
    DECLARE @latest_run_label nvarchar(100) = (SELECT TOP (1) RunLabel FROM #runs ORDER BY StartTime DESC);

    IF @latest_run_label IS NOT NULL
    BEGIN
        DECLARE
            @latest_tiered nvarchar(10),
            @latest_time_limit integer,
            @latest_mod_threshold bigint,
            @latest_qs_priority nvarchar(1),
            @latest_parallel nvarchar(1),
            @latest_preset nvarchar(30),
            @latest_long_run_min integer,
            /* @latest_group_join removed (xmxs): GroupByJoinPattern has no v3 equivalent */
            @latest_sort_order nvarchar(50),
            @latest_first_time_fullscan_cap_rows bigint,  /* 8gws: I4 detection for v3.5.4+ param */
            @latest_critical_tables nvarchar(max),        /* 8gws: I4 detection for v3.5.0+ param */
            @latest_abort_on_integrity bit,               /* 8gws: I4 detection for v3.5.9+ param */
            /* 9ufm: element-presence flags from #runs for the most recent run */
            @latest_has_full_params_log bit = 0;

        SELECT
            @latest_tiered = TieredThresholds,
            @latest_time_limit = TimeLimit,
            @latest_mod_threshold = ModificationThreshold,
            @latest_qs_priority = QueryStorePriority,
            @latest_parallel = StatsInParallel,
            @latest_preset = Preset,
            @latest_long_run_min = LongRunningThresholdMinutes,
            /* GroupByJoinPattern no longer read from #runs (xmxs) */
            @latest_sort_order = SortOrder,
            /* 9ufm: element-presence flags */
            @latest_has_full_params_log         = HasFullParamsLog
        FROM #runs
        WHERE RunLabel = @latest_run_label;

        /* W1a: TieredThresholds disabled
           9ufm gate: skip when the Parameters element is absent (pre-v2 run); a NULL
           TieredThresholds value from an absent element is not evidence of misconfiguration. */
        IF @latest_tiered IN (N'0', N'False')
        AND @latest_has_full_params_log = 1   /* 9ufm: version-gated */
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'WARNING', N'SUBOPTIMAL_PARAMS',
                N'TieredThresholds is disabled',
                N'Fixed modification threshold of ' + ISNULL(CONVERT(nvarchar(20), @latest_mod_threshold), N'NULL') + N' applied uniformly to all table sizes (tiered thresholds disabled).',
                N'Tiered thresholds adapt the modification threshold based on table size (small tables need fewer mods to justify an update). This is especially important for mixed workloads with tables ranging from hundreds to millions of rows. In v3, tiered thresholds are always active -- upgrade to v3 or set @TieredThresholds = 1 on v2.',
                N'EXECUTE dbo.sp_StatUpdate @Preset = N''NIGHTLY'', @Databases = N''USER_DATABASES''; /* v3 -- tiered thresholds always on */',
                30
            );
        END;

        /* W1b: No TimeLimit
           9ufm gate: skip when the TimeLimit element is absent (pre-v2 run or was never logged).
           An absent element produces NULL just like an explicitly set NULL; only fire when
           the element was present and its value is NULL. */
        IF @latest_time_limit IS NULL
        AND @latest_has_full_params_log = 1   /* 9ufm: version-gated */
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'WARNING', N'SUBOPTIMAL_PARAMS',
                N'No time limit configured (@TimeLimit = NULL)',
                N'Without a time limit, statistics maintenance can run indefinitely and conflict with business hours.',
                N'Set @TimeLimit to a value appropriate for your maintenance window. Common values: 3600 (1 hour), 7200 (2 hours), 18000 (5 hours).',
                N'EXECUTE dbo.sp_StatUpdate @TimeLimit = 3600;',
                30
            );
        END;

        /* W1c: No adaptive sampling when long-running stats exist */
        IF @latest_long_run_min IS NULL
        AND EXISTS (
            SELECT 1 FROM #stat_updates
            WHERE DurationMs > @LongRunningMinutes * 60 * 1000
            AND   ErrorNumber = 0
        )
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'WARNING', N'SUBOPTIMAL_PARAMS',
                N'Long-running stats exist but adaptive sampling is not enabled',
                N'@LongRunningThresholdMinutes is NULL, but stats exceeding ' + CONVERT(nvarchar(10), @LongRunningMinutes) + N' minutes were found. These can dominate maintenance time.',
                N'Enable adaptive sampling to automatically use a lower sample rate for historically slow stats.',
                N'EXECUTE dbo.sp_StatUpdate @LongRunningThresholdMinutes = ' + CONVERT(nvarchar(10), @LongRunningMinutes) + N', @LongRunningSamplePercent = 10;',
                30
            );
        END;
    END;

    /* W1d: Runs complete early but @MopUpPass not enabled */
    IF EXISTS (
            SELECT 1
            FROM #runs AS r
            WHERE r.StopReason IN (N'COMPLETED', N'NATURAL_END', N'PARALLEL_COMPLETE')
            AND   r.TimeLimit IS NOT NULL
            AND   r.DurationSeconds IS NOT NULL
            AND   r.DurationSeconds < r.TimeLimit * 0.5 /* used less than half the time budget */
            AND   ISNULL(r.MopUpTriggered, 0) = 0
            AND   r.StatsInParallel = N'N'
        )
        AND NOT EXISTS (
            SELECT 1 FROM #runs
            WHERE ISNULL(MopUpTriggered, 0) = 1
        )
        BEGIN
            DECLARE
                @w1d_avg_pct int,
                @w1d_count int;

            SELECT
                @w1d_avg_pct = AVG(CASE WHEN r.TimeLimit > 0 THEN r.DurationSeconds * 100 / r.TimeLimit ELSE NULL END),
                @w1d_count = COUNT(*)
            FROM #runs AS r
            WHERE r.StopReason IN (N'COMPLETED', N'NATURAL_END', N'PARALLEL_COMPLETE')
            AND   r.TimeLimit IS NOT NULL
            AND   r.DurationSeconds IS NOT NULL
            AND   r.DurationSeconds < r.TimeLimit * 0.5
            AND   ISNULL(r.MopUpTriggered, 0) = 0
            AND   r.StatsInParallel = N'N';

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO', N'UNUSED_FEATURES',
                N'Runs complete early -- mop-up pass could use remaining time',
                CONVERT(nvarchar(10), @w1d_count) + N' run(s) completed using only ~' + CONVERT(nvarchar(10), @w1d_avg_pct) + N'% of the time budget.  The remaining time is wasted.',
                N'@MopUpPass = N''Y'' enables a second broad sweep after the priority pass finishes, catching any stat with modification_counter > 0 that did not qualify under tiered thresholds.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @TimeLimit = 7200, @MopUpPass = N''Y'', @MopUpMinRemainingSeconds = 120;',
                50
            );
        END;

    /* ======================================================================
       W2: LONG-RUNNING INDIVIDUAL STATS
       ====================================================================== */
    /* #266: Escalate to CRITICAL when long-running stat is also high-impact (top-10 by CPU) */
    INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
    SELECT TOP (@TopN)
        CASE WHEN MAX(wi.ImpactScore) >= 0.90 THEN N'CRITICAL' ELSE N'WARNING' END,
        N'LONG_RUNNING_STATS',
        N'Stat consistently slow: ' + su.DatabaseName + N'.'
            + su.SchemaName + N'.' + su.ObjectName + N'.' + su.StatisticsName,  /* BUG-03 fix: was missing SchemaName */
        N'Avg duration: ' + CONVERT(nvarchar(20), CONVERT(decimal(10,1), AVG(su.DurationMs) / 1000.0))
            + N' sec across ' + CONVERT(nvarchar(20), COUNT_BIG(*))
            + N' updates. Max size: ' + CONVERT(nvarchar(20), MAX(ISNULL(su.SizeMB, 0))) + N' MB'
            + N'. Avg rows: ' + CONVERT(nvarchar(20), AVG(su.RowCount_))
            + CASE WHEN MAX(wi.ImpactScore) >= 0.90
                THEN N'. HIGH IMPACT: workload rank top ' + CONVERT(nvarchar(10), CONVERT(int, (1.0 - ISNULL(MAX(wi.ImpactScore), 0)) * 100)) + N'%'
                ELSE N''
            END,
        N'Enable adaptive sampling: stats that historically exceed a threshold get a reduced sample rate automatically.',
        N'EXECUTE dbo.sp_StatUpdate @LongRunningThresholdMinutes = '
            + CONVERT(nvarchar(10), @LongRunningMinutes)
            + N', @LongRunningSamplePercent = 10;',
        CASE WHEN MAX(wi.ImpactScore) >= 0.90 THEN 12 ELSE 35 END  /* #266: CRITICAL sorts before WARNING */
    FROM #stat_updates AS su
    LEFT JOIN #workload_impact AS wi
        ON wi.DatabaseName = su.DatabaseName
        AND wi.SchemaName  = su.SchemaName
        AND wi.ObjectName  = su.ObjectName
    WHERE su.ErrorNumber = 0
    AND   su.DurationMs > @LongRunningMinutes * 60 * 1000
    GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
    HAVING COUNT_BIG(*) >= 2
    ORDER BY AVG(su.DurationMs) DESC;

    IF @@ROWCOUNT > 0
        RAISERROR(N'  [WARNING] W2: Long-running stats detected', 10, 1) WITH NOWAIT;

    /* ======================================================================
       W3: STALE-STATS BACKLOG
       p1n fix: in parallel mode each worker reports per-worker StatsRemaining
       (stats the coordinator assigned to other workers), which looks like a
       backlog but is not.  Suppress W3 when all non-killed runs end with
       PARALLEL_COMPLETE and the aggregate StatsRemaining across all workers
       is 0 (the work was fully distributed and completed).
       ====================================================================== */
    /* p1n: check whether every non-killed run completed via parallel coordination.
       c53: also set when @parallel_aggregate_done=1 (all workers used StatsInParallel='Y'
       and aggregate remaining=0, regardless of individual StopReason values). */
    DECLARE @w3_parallel_complete bit = 0;
    IF NOT EXISTS (
        SELECT 1 FROM #runs
        WHERE IsKilled = 0
        AND   StopReason <> N'PARALLEL_COMPLETE'
    )
    AND (SELECT SUM(ISNULL(StatsRemaining, 0)) FROM #runs WHERE IsKilled = 0) = 0
        SET @w3_parallel_complete = 1;
    /* c53: second path -- all-parallel with zero aggregate remaining, even when some
       workers exited via TIME_LIMIT (not PARALLEL_COMPLETE). */
    IF @w3_parallel_complete = 0 AND @parallel_aggregate_done = 1
        SET @w3_parallel_complete = 1;
    /* kzx0: C6 SILENT_NOOP_RUN un-suppresses W3 -- PARALLEL_COMPLETE cannot be
       trusted when a run in the window found work and nobody processed any of
       it.  Also closes the COMPLETION grade-A fast path (which reuses this
       flag) for zombie joiners that report StatsRemaining = 0 from an empty
       skip-discovery temp table. */
    IF @c6_silent_noop = 1
        SET @w3_parallel_complete = 0;

    IF @w3_parallel_complete = 0
    AND EXISTS (
        SELECT 1
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.StatsRemaining > 0
        AND   r.StatsFound > 0
        GROUP BY r.RunLabel
        HAVING AVG(r.StatsRemaining * 1.0 / NULLIF(r.StatsFound, 0)) > 0.5
    )
    BEGIN
        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        SELECT
            N'WARNING',
            N'STALE_BACKLOG',
            N'Persistent backlog: avg ' + CONVERT(nvarchar(10), AVG(r.StatsRemaining))
                + N' stats remaining per run',
            N'Average found/processed/remaining: '
                + CONVERT(nvarchar(10), AVG(r.StatsFound)) + N'/'
                + CONVERT(nvarchar(10), AVG(r.StatsProcessed)) + N'/'
                + CONVERT(nvarchar(10), AVG(r.StatsRemaining))
                + N'. Over ' + CONVERT(nvarchar(10), COUNT_BIG(*)) + N' runs.',
            N'Stats qualify faster than they can be processed. Options: '
                + N'(1) Increase @TimeLimit, '
                + N'(2) Enable @StatsInParallel = N''Y'' for parallel processing, '
                + N'(3) Raise @ModificationThreshold to reduce qualifying stats, '
                + N'(4) Use @Preset = N''NIGHTLY'' for balanced defaults.',
            N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @TimeLimit = 7200, @StatsInParallel = N''Y'';',
            25
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.StatsRemaining > 0
        AND   r.StatsFound > 0
        AND   r.StatsRemaining * 1.0 / NULLIF(r.StatsFound, 0) > 0.5;  /* BUG-04 fix: match EXISTS guard -- only include runs with >50% remaining */

        RAISERROR(N'  [WARNING] W3: Stale-stats backlog detected', 10, 1) WITH NOWAIT;
    END;

    /* ======================================================================
       W4: OVERLAPPING RUNS
       vws fix: suppress when BOTH overlapping runs have StatsInParallel='Y'.
       Two-schedule parallel patterns (e.g., 20:15 + 23:00 Agent jobs) are
       intentional -- each worker joins the same coordinator queue and divides
       the work. Only fire when at least one run is serial, which indicates an
       unintentional schedule overlap with no queue coordination.
       ====================================================================== */
    INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
    SELECT
        N'WARNING',
        N'OVERLAPPING_RUNS',
        N'Overlapping runs detected: ' + r1.RunLabel + N' and ' + r2.RunLabel,
        N'Run 1 started ' + CONVERT(nvarchar(20), r1.StartTime, 120)
            + N', Run 2 started ' + CONVERT(nvarchar(20), r2.StartTime, 120)
            + N' (' + CONVERT(nvarchar(10), DATEDIFF(MINUTE, r1.StartTime, r2.StartTime))
            + N' minutes apart)',
        N'Multiple concurrent sp_StatUpdate runs can cause lock contention and duplicate work. '
            + N'Check SQL Agent job schedules for overlapping maintenance windows. '
            + N'If intentional, ensure @StatsInParallel = N''Y'' is used for coordinated parallel processing.',
        N'/* Review Agent job schedules for conflicts */',
        40
    FROM #runs AS r1
    INNER JOIN #runs AS r2
        ON  r2.StartTime > r1.StartTime
        AND r2.StartTime < ISNULL(r1.EndTime, DATEADD(SECOND, ISNULL(r1.TimeLimit, 18000), r1.StartTime))
        AND r2.RunLabel <> r1.RunLabel
    WHERE r1.IsKilled = 0
      AND r2.IsKilled = 0
      /* vws fix: skip intentional parallel pairs -- both workers use the coordinator queue */
      AND NOT (ISNULL(r1.StatsInParallel, N'N') = N'Y' AND ISNULL(r2.StatsInParallel, N'N') = N'Y');

    IF @@ROWCOUNT > 0
        RAISERROR(N'  [WARNING] W4: Overlapping runs detected', 10, 1) WITH NOWAIT;

    /* ======================================================================
       W5: QUERY STORE NOT EFFECTIVE
       ====================================================================== */
    IF EXISTS (SELECT 1 FROM #runs WHERE QueryStorePriority = N'Y')
    BEGIN
        DECLARE @w5_qs_runs integer = (SELECT COUNT_BIG(*) FROM #runs WHERE QueryStorePriority = N'Y');
        DECLARE @w5_qs_data_runs integer = (
            SELECT COUNT(DISTINCT su.RunLabel)
            FROM #stat_updates AS su
            WHERE su.QSPlanCount IS NOT NULL /* 0 = enrichment ran (no match), >0 = matched; NULL = skipped */
        );

        /* 1h2l: QSEnrichmentSkipped direct signal from END Summary XML (v3+ only).
           When present, use as the authoritative skip indicator.  Inference via
           QSPlanCount/QSTotalCpuMs stays as fallback for older rows where the element
           is absent (QSEnrichmentSkipped IS NULL). */
        DECLARE @w5_enrichment_skipped_runs integer = (
            SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 0 AND QSEnrichmentSkipped = 1
        );
        DECLARE @w5_enrichment_element_present bit = (
            SELECT CASE WHEN COUNT(*) > 0 THEN CONVERT(bit, 1) ELSE CONVERT(bit, 0) END
            FROM #runs WHERE IsKilled = 0 AND QSEnrichmentSkipped IS NOT NULL
        );

        /* sp_StatUpdate-6x80: detect whether ALL QS-priority runs are parallel.
           In parallel mode, ProcessingPosition is a per-worker counter (not a
           global rank), so the absence of per-stat QS data in stat updates does
           NOT reliably signal that QS enrichment failed -- it may simply mean
           the per-stat ExtendedInfo rows aren't tagged with QSPlanCount in a
           way that crosses workers.  Check whether any stat updates carry actual
           CPU data (QSTotalCpuMs > 0) as the definitive "QS enrichment worked"
           signal regardless of QSPlanCount NULL/0 ambiguity. */
        DECLARE @w5_all_parallel bit = (
            SELECT CASE
                WHEN COUNT(*) > 0
                 AND SUM(CASE WHEN ISNULL(r.StatsInParallel, N'N') = N'Y' THEN 1 ELSE 0 END) = COUNT(*)
                THEN CONVERT(bit, 1) ELSE CONVERT(bit, 0) END
            FROM #runs AS r
            WHERE r.IsKilled = 0 AND r.QueryStorePriority = N'Y'
        );
        /* QS CPU data present = enrichment actually ran and matched at least one stat */
        DECLARE @w5_qs_cpu_present bit = (
            SELECT CASE WHEN SUM(ISNULL(su.QSTotalCpuMs, 0)) > 0
                        THEN CONVERT(bit, 1) ELSE CONVERT(bit, 0) END
            FROM #stat_updates AS su
        );

        /* 1h2l: Primary signal -- when QSEnrichmentSkipped element is present in END rows
           AND indicates skipping in ALL non-killed QS-priority runs, treat as definitive skip.
           Inference (QSPlanCount/CPU) is fallback when element is absent (old rows). */
        DECLARE @w5_definitive_skipped bit = 0;
        IF @w5_enrichment_element_present = 1
            AND @w5_enrichment_skipped_runs = (SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 0 AND QueryStorePriority = N'Y')
            SET @w5_definitive_skipped = 1;

        IF @w5_definitive_skipped = 1 OR @w5_qs_data_runs = 0
        BEGIN
            /* sp_StatUpdate-6x80: when all QS-priority runs are parallel AND QS
               CPU data was observed in stat updates, the zero-QSPlanCount signal
               is unreliable (parallel per-worker position counters mask global
               rank).  Emit a softer INFO note and do NOT insert QS_NOT_EFFECTIVE
               so that I10 does not revert @SortOrder on a false premise. */
            IF @w5_all_parallel = 1 AND @w5_qs_cpu_present = 1
            BEGIN
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES
                (
                    N'INFO', N'QS_PARALLEL_UNRELIABLE',
                    N'QS plan-count data absent in parallel mode -- unreliable signal',
                    N'QS prioritization is configured and QS CPU data WAS captured (QSTotalCpuMs > 0 in stat updates). '
                        + N'However, QSPlanCount IS NULL for all stat updates, which in parallel mode may reflect '
                        + N'per-worker ExtendedInfo tagging rather than true QS enrichment failure. '
                        + N'The mhje fix (v3.5.4) corrected TablePriority ordering so QS-top stats are processed '
                        + N'first in parallel mode.  Monitor QS efficacy (RS 10/11) over the next few runs.',
                    N'No action required if RS 10 QS efficacy trend shows IMPROVING or STABLE. '
                        + N'If truly no QS data is collected, verify QS is READ_WRITE: '
                        + N'SELECT actual_state_desc FROM sys.database_query_store_options.',
                    NULL,
                    40
                );
                RAISERROR(N'  [INFO] W5: QS data absent in parallel mode -- possible artifact, not firing WARNING', 10, 1) WITH NOWAIT;
            END
            ELSE
            BEGIN
                /* Original W5: QS enabled but zero data (non-parallel or no CPU data) */
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES
                (
                    N'WARNING', N'QS_NOT_EFFECTIVE',
                    N'Query Store priority enabled but no QS data captured in stat updates',
                    N'QS prioritization was configured (@QueryStore in v3, @QueryStorePriority in v2) but QS enrichment did not run in any stat updates (QSPlanCount IS NULL in all). '
                        + N'This typically means Query Store is disabled, read-only, purged, or has no recent runtime stats.',
                    N'Verify Query Store is enabled and in READ_WRITE mode on target databases: '
                        + N'SELECT name, is_query_store_on FROM sys.databases. '
                        + N'If QS is intentionally disabled, set @QueryStore = NULL (v3) to avoid unnecessary overhead. '
                        /* #278: capture mode guidance */
                        + N'Also verify CAPTURE_MODE is AUTO or CUSTOM, not ALL (SELECT actual_state_desc, query_capture_mode_desc FROM sys.database_query_store_options).',
                    N'/* Check: SELECT name, is_query_store_on FROM sys.databases WHERE state_desc = N''ONLINE''; */',
                    35
                );
                RAISERROR(N'  [WARNING] W5: Query Store not effective', 10, 1) WITH NOWAIT;
            END;
        END
        ELSE IF @w5_qs_data_runs < @w5_qs_runs
            AND @w5_qs_data_runs * 100.0 / @w5_qs_runs BETWEEN 10 AND 90
        BEGIN
            /* #274: Partial QS data -- may have transitioned to READ_ONLY */
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'WARNING', N'QS_NOT_EFFECTIVE',
                N'QS enrichment ran in only ' + CONVERT(nvarchar(10), @w5_qs_data_runs)
                    + N' of ' + CONVERT(nvarchar(10), @w5_qs_runs) + N' QS-priority runs',
                N'QS prioritization was configured across ' + CONVERT(nvarchar(10), @w5_qs_runs)
                    + N' runs, but QS enrichment only executed in ' + CONVERT(nvarchar(10), @w5_qs_data_runs)
                    + N'.  Query Store may have transitioned to READ_ONLY or had no recent runtime stats in some runs.',
                N'Check QS status: SELECT actual_state_desc, query_capture_mode_desc, current_storage_size_mb, max_storage_size_mb FROM sys.database_query_store_options. '
                    + N'If space pressure caused READ_ONLY transition, increase max_storage_size_mb or enable SIZE_BASED_CLEANUP_MODE.',
                N'ALTER DATABASE [YourDB] SET QUERY_STORE (MAX_STORAGE_SIZE_MB = 2048);',
                35
            );
            RAISERROR(N'  [WARNING] W5: Partial QS data -- possible READ_ONLY transition', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W6: EXCESSIVE OVERHEAD -- discovery/checks consuming disproportionate time
       Wall clock time vs. actual UPDATE STATISTICS time.
       When overhead > 40% of wall clock, parameter changes may be adding cost.
       ====================================================================== */
    IF @stat_update_count > 0
    BEGIN
        DECLARE
            @w6_overhead_runs int = 0,
            @w6_worst_pct decimal(5,1) = 0,
            @w6_worst_label nvarchar(100) = N'',
            @w6_detail nvarchar(2000) = N'';

        ;WITH run_overhead AS
        (
            SELECT
                r.RunLabel,
                r.DurationSeconds,
                r.StatsProcessed,
                stat_seconds = CONVERT(decimal(10,1), ISNULL(su_agg.TotalStatMs, 0) / 1000.0),
                /* gh-478: Clamp to [0, 100].  DurationMs sums can exceed wall-clock when stats run
                   in overlapping transactions or when clock skew occurs across workers, producing
                   negative overhead percentages. */
                overhead_pct = CASE
                    WHEN r.DurationSeconds > 0
                    THEN CASE
                        WHEN (1.0 - ISNULL(su_agg.TotalStatMs, 0) / 1000.0 / r.DurationSeconds) * 100 < 0 THEN CONVERT(decimal(5,1), 0)
                        WHEN (1.0 - ISNULL(su_agg.TotalStatMs, 0) / 1000.0 / r.DurationSeconds) * 100 > 100 THEN CONVERT(decimal(5,1), 100)
                        ELSE CONVERT(decimal(5,1), (1.0 - ISNULL(su_agg.TotalStatMs, 0) / 1000.0 / r.DurationSeconds) * 100)
                    END
                    ELSE 0
                END
            FROM #runs AS r
            LEFT JOIN
            (
                SELECT
                    su.RunLabel,
                    TotalStatMs = SUM(ISNULL(su.DurationMs, 0))
                FROM #stat_updates AS su
                WHERE su.EndTime IS NOT NULL
                GROUP BY su.RunLabel
            ) AS su_agg ON su_agg.RunLabel = r.RunLabel
            WHERE r.IsKilled = 0
            AND   r.DurationSeconds > 10  /* skip trivial runs */
            AND   r.StatsProcessed >= 5   /* need enough stats for meaningful ratio */
        )
        SELECT
            @w6_overhead_runs = COUNT(*),
            @w6_worst_pct = MAX(ro.overhead_pct)
        FROM run_overhead AS ro
        WHERE ro.overhead_pct > 40;

        /* Get the label of the worst-overhead run */
        IF @w6_overhead_runs > 0
        BEGIN
            ;WITH run_overhead2 AS
            (
                SELECT
                    r.RunLabel,
                    /* gh-478: Clamp to [0, 100] (see primary run_overhead CTE above). */
                    overhead_pct = CASE
                        WHEN r.DurationSeconds > 0
                        THEN CASE
                            WHEN (1.0 - ISNULL(su_agg.TotalStatMs, 0) / 1000.0 / r.DurationSeconds) * 100 < 0 THEN CONVERT(decimal(5,1), 0)
                            WHEN (1.0 - ISNULL(su_agg.TotalStatMs, 0) / 1000.0 / r.DurationSeconds) * 100 > 100 THEN CONVERT(decimal(5,1), 100)
                            ELSE CONVERT(decimal(5,1), (1.0 - ISNULL(su_agg.TotalStatMs, 0) / 1000.0 / r.DurationSeconds) * 100)
                        END
                        ELSE 0
                    END
                FROM #runs AS r
                LEFT JOIN
                (
                    SELECT su.RunLabel, TotalStatMs = SUM(ISNULL(su.DurationMs, 0))
                    FROM #stat_updates AS su WHERE su.EndTime IS NOT NULL GROUP BY su.RunLabel
                ) AS su_agg ON su_agg.RunLabel = r.RunLabel
                WHERE r.IsKilled = 0 AND r.DurationSeconds > 10 AND r.StatsProcessed >= 5
            )
            SELECT TOP (1) @w6_worst_label = ro2.RunLabel
            FROM run_overhead2 AS ro2
            ORDER BY ro2.overhead_pct DESC;
        END;

        IF @w6_overhead_runs > 0
        BEGIN
            SET @w6_detail =
                CONVERT(nvarchar(10), @w6_overhead_runs) + N' run(s) spent >40% of wall-clock time on overhead (discovery, environment checks, per-stat validations) '
                + N'rather than actual UPDATE STATISTICS. Worst: ' + @w6_worst_label
                + N' at ' + CONVERT(nvarchar(10), @w6_worst_pct) + N'% overhead.';

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'WARNING', N'EXCESSIVE_OVERHEAD',
                N'Discovery and environment checks consuming disproportionate time vs actual stat updates',
                @w6_detail,
                N'Review recent parameter changes -- features like @QueryStore (CPU/DURATION/READS) and extended discovery options add overhead. '
                    + N'Reduce @CommandLogRetentionDays, or check whether CommandLog table needs a StartTime index. '
                    + N'If SQL Server is under memory pressure (check sys.dm_os_memory_brokers, sys.dm_os_process_memory), high overhead may indicate page cache eviction during stat scans.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @Debug = 1; /* Review per-phase timing in debug output */',
                33
            );

            DECLARE @w6_msg nvarchar(500) =
                N'  [WARNING] W6: Excessive overhead -- ' + CONVERT(nvarchar(10), @w6_overhead_runs)
                + N' run(s) with >40%% overhead (worst: ' + @w6_worst_label
                + N' at ' + CONVERT(nvarchar(10), @w6_worst_pct) + N'%%)';
            RAISERROR(@w6_msg, 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W7: HIGH_IMPACT_STATS_DEPRIORITIZED (#263)
       Top CPU stats processed late (high ProcessingPosition).
       ====================================================================== */
    IF @workload_impact_count > 0
    BEGIN
        DECLARE @w7_deprioritized_count integer;
        DECLARE @w7_evidence nvarchar(2000);

        /* Pre-compute median processing position */
        DECLARE @w7_median_position decimal(10, 1);
        SELECT TOP (1) @w7_median_position = pos_median
        FROM (
            SELECT pos_median = PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY su2.ProcessingPosition) OVER ()
            FROM #stat_updates AS su2
            WHERE su2.ProcessingPosition IS NOT NULL
            AND   (su2.ErrorNumber = 0 OR su2.ErrorNumber IS NULL)
        ) AS pm;

        ;WITH top_cpu_stats AS
        (
            SELECT TOP (10)
                su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName,
                avg_position = AVG(CONVERT(decimal(10, 1), su.ProcessingPosition))
            FROM #stat_updates AS su
            INNER JOIN #workload_impact AS wi
                ON wi.DatabaseName = su.DatabaseName
                AND wi.SchemaName  = su.SchemaName
                AND wi.ObjectName  = su.ObjectName
            WHERE wi.ImpactScore >= 0.90
            AND   su.ProcessingPosition IS NOT NULL
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
            GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
            ORDER BY MAX(wi.TotalCpuMs) DESC
        )
        SELECT @w7_deprioritized_count = SUM(CASE WHEN tcs.avg_position > ISNULL(@w7_median_position, 0) THEN 1 ELSE 0 END)
        FROM top_cpu_stats AS tcs;

        IF ISNULL(@w7_deprioritized_count, 0) > 0
        BEGIN
            SET @w7_evidence = STUFF((
                SELECT TOP (5) N', ' + tcs.StatisticsName + N' (avg pos ' + CONVERT(nvarchar(10), CONVERT(int, tcs.avg_position)) + N')'
                FROM (
                    SELECT TOP (10)
                        su.StatisticsName,
                        avg_position = AVG(CONVERT(decimal(10, 1), su.ProcessingPosition))
                    FROM #stat_updates AS su
                    INNER JOIN #workload_impact AS wi
                        ON wi.DatabaseName = su.DatabaseName
                        AND wi.SchemaName  = su.SchemaName
                        AND wi.ObjectName  = su.ObjectName
                    WHERE wi.ImpactScore >= 0.90
                    AND   su.ProcessingPosition IS NOT NULL
                    AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
                    GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                    ORDER BY MAX(wi.TotalCpuMs) DESC
                ) AS tcs
                /* gh-476: Use @w7_median_position (ISNULL 0) to match the outer @w7_deprioritized_count
                   threshold.  Hard-coded > 5 caused evidence to be empty while @w7_deprioritized_count
                   was > 0, producing the "(details unavailable)" path. */
                WHERE tcs.avg_position > ISNULL(@w7_median_position, 0)
                ORDER BY tcs.avg_position DESC
                FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N'');

            IF @w7_evidence IS NOT NULL
            BEGIN
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES (
                    N'WARNING',
                    N'HIGH_IMPACT_STATS_DEPRIORITIZED',
                    N'High-workload statistics processed late in maintenance window',
                    N'Top CPU stats with high processing positions: ' + @w7_evidence,
                    N'Enable Query Store-based prioritization to process high-impact stats first.',
                    N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @QueryStore = N''CPU'', @SortOrder = N''QUERY_STORE'';',
                    36
                );

                RAISERROR(N'  [WARNING] W7: High-impact stats deprioritized', 10, 1) WITH NOWAIT;
            END;
        END;
    END;

    /* ======================================================================
       I9: WORKLOAD_CONCENTRATION (#264)
       Leadership-friendly: "Top N stats drive X% of measured query CPU"
       ====================================================================== */
    IF @workload_impact_count >= 5
    BEGIN
        DECLARE @i9_top_n integer;
        DECLARE @i9_pct decimal(5, 1);

        /* Find how many objects it takes to reach 80% of total CPU */
        SELECT TOP (1) @i9_top_n = rn, @i9_pct = CumulativePct
        FROM (
            SELECT
                rn = ROW_NUMBER() OVER (ORDER BY wi.TotalCpuMs DESC),
                wi.CumulativePct
            FROM #workload_impact AS wi
        ) AS ranked
        WHERE ranked.CumulativePct >= 80.0
        ORDER BY ranked.rn;

        IF @i9_top_n IS NOT NULL
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'INFO',
                N'WORKLOAD_CONCENTRATION',
                N'Top ' + CONVERT(nvarchar(10), @i9_top_n) + N' table(s) drive '
                    + CONVERT(nvarchar(10), @i9_pct) + N'% of measured query CPU',
                N'Out of ' + CONVERT(nvarchar(10), @workload_impact_count) + N' objects with Query Store data, '
                    + CONVERT(nvarchar(10), @i9_top_n) + N' account for '
                    + CONVERT(nvarchar(10), @i9_pct) + N'% of total CPU. '
                    + N'Concentrating statistics maintenance on these tables maximizes performance impact.',
                N'Use @QueryStore = N''CPU'' (v3) to automatically prioritize these high-impact tables.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @QueryStore = N''CPU'';',
                74
            );

            RAISERROR(N'  [INFO] I9: Workload concentration identified', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W8: MOP-UP INEFFECTIVENESS (#347)
       Mop-up consistently finds 0 stats -- discovery overhead with no benefit.
       ====================================================================== */
    BEGIN
        DECLARE @w8_mop_runs integer = 0;
        DECLARE @w8_mop_empty integer = 0;

        SELECT
            @w8_mop_runs = COUNT(*),
            @w8_mop_empty = SUM(CASE WHEN ISNULL(r.MopUpFound, 0) = 0 THEN 1 ELSE 0 END)
        FROM #runs AS r
        WHERE r.MopUpTriggered = 1
        AND   r.IsKilled = 0;

        IF @w8_mop_runs >= 3 AND @w8_mop_empty * 1.0 / @w8_mop_runs >= 0.80
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'WARNING',
                N'MOPUP_INEFFECTIVE',
                CONVERT(nvarchar(10), @w8_mop_empty) + N' of ' + CONVERT(nvarchar(10), @w8_mop_runs)
                    + N' mop-up passes found 0 qualifying stats',
                N'Mop-up adds discovery overhead on every run with no additional coverage.  '
                    + N'This typically means the priority pass already covers all qualifying stats, '
                    + N'or thresholds are too aggressive for the mop-up window.',
                N'Disable @MopUpPass or lower @ModificationThreshold so the priority pass catches more stats.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @MopUpPass = N''N'';',
                50
            );

            RAISERROR(N'  [WARNING] W8: Mop-up ineffective', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W9: LOCK TIMEOUT INEFFECTIVENESS (#348)
       Same stat hits lock timeout across multiple runs.
       ====================================================================== */
    BEGIN
        DECLARE @w9_persistent_count integer;
        DECLARE @w9_evidence nvarchar(2000);

        ;WITH lock_timeouts AS
        (
            SELECT
                su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName,
                run_count = COUNT(DISTINCT su.RunLabel)
            FROM #stat_updates AS su
            WHERE su.ErrorNumber = 1222
            GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
            HAVING COUNT(DISTINCT su.RunLabel) >= 3
        )
        SELECT @w9_persistent_count = COUNT(*)
        FROM lock_timeouts;

        IF ISNULL(@w9_persistent_count, 0) > 0
        BEGIN
            SET @w9_evidence = STUFF((
                SELECT TOP (5) N', ' + lt.SchemaName + N'.' + lt.ObjectName + N'.' + lt.StatisticsName
                    + N' (' + CONVERT(nvarchar(10), lt.run_count) + N' runs)'
                FROM (
                    SELECT
                        su.SchemaName, su.ObjectName, su.StatisticsName,
                        run_count = COUNT(DISTINCT su.RunLabel)
                    FROM #stat_updates AS su
                    WHERE su.ErrorNumber = 1222
                    GROUP BY su.SchemaName, su.ObjectName, su.StatisticsName
                    HAVING COUNT(DISTINCT su.RunLabel) >= 3
                ) AS lt
                ORDER BY lt.run_count DESC
                FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N'');

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'WARNING',
                N'LOCK_TIMEOUT_INEFFECTIVE',
                CONVERT(nvarchar(10), @w9_persistent_count) + N' stat(s) persistently blocked across 3+ runs',
                N'Persistent lock timeout victims: ' + @w9_evidence,
                N'Increase @LockTimeout, reschedule to off-peak, or enable @StatsInParallel (workers retry faster).',
                NULL,
                50
            );

            RAISERROR(N'  [WARNING] W9: Persistent lock timeout victims', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       I11: FAILURE CAUSE CLUSTERING (#346)
       Cluster failures by ErrorNumber to identify dominant root cause.
       ====================================================================== */
    BEGIN
        DECLARE @i11_total_failures integer;
        DECLARE @i11_top_error integer;
        DECLARE @i11_top_count integer;
        DECLARE @i11_top_pct decimal(5, 1);
        DECLARE @i11_distinct_errors integer;
        DECLARE @i11_evidence nvarchar(2000);

        SELECT @i11_total_failures = COUNT(*)
        FROM #stat_updates
        WHERE ErrorNumber IS NOT NULL AND ErrorNumber <> 0;

        IF @i11_total_failures >= 5
        BEGIN
            SELECT TOP (1)
                @i11_top_error = ErrorNumber,
                @i11_top_count = COUNT(*),
                @i11_top_pct = COUNT(*) * 100.0 / @i11_total_failures
            FROM #stat_updates
            WHERE ErrorNumber IS NOT NULL AND ErrorNumber <> 0
            GROUP BY ErrorNumber
            ORDER BY COUNT(*) DESC;

            SELECT @i11_distinct_errors = COUNT(DISTINCT ErrorNumber)
            FROM #stat_updates
            WHERE ErrorNumber IS NOT NULL AND ErrorNumber <> 0;

            IF @i11_top_pct >= 60.0
            BEGIN
                SET @i11_evidence = CONVERT(nvarchar(10), @i11_distinct_errors) + N' distinct error(s) across '
                    + CONVERT(nvarchar(10), @i11_total_failures) + N' failures.  Error '
                    + CONVERT(nvarchar(10), @i11_top_error) + N' accounts for '
                    + CONVERT(nvarchar(10), @i11_top_count) + N' of '
                    + CONVERT(nvarchar(10), @i11_total_failures) + N' ('
                    + CONVERT(nvarchar(10), CONVERT(int, @i11_top_pct)) + N'%).  '
                    + CASE @i11_top_error
                        WHEN 1222 THEN N'Focus: lock contention -- increase @LockTimeout, enable @StatsInParallel, or reschedule to off-peak.'
                        WHEN 8152 THEN N'Focus: string truncation -- check extended property or statistic name lengths.'
                        WHEN 1205 THEN N'Focus: deadlocks -- verify no concurrent index rebuilds or large transactions.'
                        ELSE N'Focus: investigate error ' + CONVERT(nvarchar(10), @i11_top_error) + N' root cause.'
                    END;

                /* cq4 fix: escalate from INFO to WARNING when C2 REPEATED_FAILURES is also
                   active and this error code explains >80% of all failures.  The combination
                   means the same stat is failing consistently AND one error dominates -- a
                   clear, actionable root cause that warrants WARNING visibility. */
                DECLARE @i11_severity nvarchar(10) = N'INFO';
                DECLARE @i11_sort integer = 70;
                IF @i11_top_pct >= 80.0
                AND EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'REPEATED_FAILURES')
                BEGIN
                    SET @i11_severity = N'WARNING';
                    SET @i11_sort = 22;     /* sort near W-group findings */
                END;

                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES (
                    @i11_severity,
                    N'FAILURE_CLUSTERING',
                    N'Dominant failure cause: Error ' + CONVERT(nvarchar(10), @i11_top_error) + N' ('
                        + CONVERT(nvarchar(10), CONVERT(int, @i11_top_pct)) + N'% of failures)',
                    @i11_evidence,
                    N'Address the dominant error code to resolve the majority of failures.',
                    NULL,
                    @i11_sort
                );

                IF @i11_severity = N'WARNING'
                    RAISERROR(N'  [WARNING] I11: Failure cause clustering escalated to WARNING (C2 active + dominant error)', 10, 1) WITH NOWAIT;
                ELSE
                    RAISERROR(N'  [INFO] I11: Failure cause clustering identified', 10, 1) WITH NOWAIT;
            END;
        END;
    END;

    /* ======================================================================
       W10: PARAMETER CHURN (#350)
       Key parameters changing frequently indicates reactive tuning.
       ====================================================================== */
    BEGIN
        DECLARE @w10_run_count integer = (SELECT COUNT(*) FROM #runs WHERE IsKilled = 0);

        IF @w10_run_count >= 5
        BEGIN
            DECLARE @w10_changes integer = 0;
            DECLARE @w10_evidence nvarchar(2000) = N'';

            /* Count distinct values for key parameters */
            DECLARE @w10_tl_vals integer = (SELECT COUNT(DISTINCT TimeLimit) FROM #runs WHERE IsKilled = 0 AND TimeLimit IS NOT NULL);
            DECLARE @w10_mt_vals integer = (SELECT COUNT(DISTINCT ModificationThreshold) FROM #runs WHERE IsKilled = 0 AND ModificationThreshold IS NOT NULL);
            DECLARE @w10_so_vals integer = (SELECT COUNT(DISTINCT SortOrder) FROM #runs WHERE IsKilled = 0 AND SortOrder IS NOT NULL);
            DECLARE @w10_qsp_vals integer = (SELECT COUNT(DISTINCT QueryStorePriority) FROM #runs WHERE IsKilled = 0 AND QueryStorePriority IS NOT NULL);

            IF @w10_tl_vals >= 3
            BEGIN
                SET @w10_changes += 1;
                SET @w10_evidence += N'@TimeLimit: ' + CONVERT(nvarchar(10), @w10_tl_vals) + N' distinct values. ';
            END;
            IF @w10_mt_vals >= 3
            BEGIN
                SET @w10_changes += 1;
                SET @w10_evidence += N'@ModificationThreshold: ' + CONVERT(nvarchar(10), @w10_mt_vals) + N' distinct values. ';
            END;
            IF @w10_so_vals >= 3
            BEGIN
                SET @w10_changes += 1;
                SET @w10_evidence += N'@SortOrder: ' + CONVERT(nvarchar(10), @w10_so_vals) + N' distinct values. ';
            END;
            IF @w10_qsp_vals >= 2 AND @w10_run_count >= 6
            BEGIN
                SET @w10_changes += 1;
                SET @w10_evidence += N'Query Store prioritization toggled (@QueryStore in v3, @QueryStorePriority in v2). ';
            END;

            IF @w10_changes >= 2
            BEGIN
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES (
                    N'WARNING',
                    N'PARAMETER_CHURN',
                    N'Parameter volatility: ' + CONVERT(nvarchar(10), @w10_changes) + N' key parameter(s) changed frequently across '
                        + CONVERT(nvarchar(10), @w10_run_count) + N' runs',
                    @w10_evidence + N'Trend metrics unreliable when configuration changes between runs.',
                    N'Stabilize parameters for 10+ runs before adjusting.  Use @Preset for consistent configurations.',
                    N'EXECUTE dbo.sp_StatUpdate @Preset = N''NIGHTLY'', @Databases = N''USER_DATABASES'';',
                    50
                );

                RAISERROR(N'  [WARNING] W10: Parameter churn detected', 10, 1) WITH NOWAIT;
            END;
        END;
    END;

    /* ======================================================================
       C5: SAMPLE RATE DEGRADATION (#345)
       Effective sample rate dropping silently across runs.
       ====================================================================== */
    BEGIN
        DECLARE @c5_degraded_count integer;
        DECLARE @c5_evidence nvarchar(2000);

        ;WITH sample_trends AS
        (
            SELECT
                su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName,
                avg_recent = AVG(CASE WHEN su.StartTime >= DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END),
                avg_prior  = AVG(CASE WHEN su.StartTime <  DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END),
                appearances = COUNT(*)
            FROM #stat_updates AS su
            WHERE su.EffectiveSamplePct IS NOT NULL
            AND   su.EffectiveSamplePct > 0
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
            GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
            HAVING COUNT(*) >= 4
            AND    AVG(CASE WHEN su.StartTime >= DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END) IS NOT NULL
            AND    AVG(CASE WHEN su.StartTime <  DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END) IS NOT NULL
        )
        SELECT @c5_degraded_count = COUNT(*)
        FROM sample_trends
        WHERE avg_recent < avg_prior * 0.5;

        IF ISNULL(@c5_degraded_count, 0) > 0
        BEGIN
            /* gh-477: GROUP BY includes Database/Schema/ObjectName so stats with the same name
               across different tables are not collapsed (e.g., _WA_Sys_... appears on many tables). */
            SET @c5_evidence = STUFF((
                SELECT TOP (5) N', ' + st.DatabaseName + N'.' + st.SchemaName + N'.' + st.ObjectName + N'.' + st.StatisticsName
                    + N' (avg ' + CONVERT(nvarchar(10), CONVERT(decimal(5, 1), st.avg_prior))
                    + N'% -> ' + CONVERT(nvarchar(10), CONVERT(decimal(5, 1), st.avg_recent)) + N'%)'
                FROM (
                    SELECT
                        su.DatabaseName,
                        su.SchemaName,
                        su.ObjectName,
                        su.StatisticsName,
                        avg_recent = AVG(CASE WHEN su.StartTime >= DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END),
                        avg_prior  = AVG(CASE WHEN su.StartTime <  DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END)
                    FROM #stat_updates AS su
                    WHERE su.EffectiveSamplePct IS NOT NULL AND su.EffectiveSamplePct > 0
                    AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
                    GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                    HAVING COUNT(*) >= 4
                    AND    AVG(CASE WHEN su.StartTime >= DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END) IS NOT NULL
                    AND    AVG(CASE WHEN su.StartTime <  DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 2), su.EffectiveSamplePct) END) IS NOT NULL
                ) AS st
                WHERE st.avg_recent < st.avg_prior * 0.5
                ORDER BY st.avg_prior / NULLIF(st.avg_recent, 0) DESC
                FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N'');

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'CRITICAL',
                N'SAMPLE_RATE_DEGRADATION',
                CONVERT(nvarchar(10), @c5_degraded_count) + N' stat(s) with sample rate dropped >50%',
                N'Sample rate degradation: ' + ISNULL(@c5_evidence, N'(details unavailable)'),
                N'Below ~1000 sampled rows, histogram resolution degrades.  Review @LongRunningSamplePercent or increase @TimeLimit.',
                NULL,
                20
            );

            RAISERROR(N'  [CRITICAL] C5: Sample rate degradation detected', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       I12: QS COVERAGE DRIFT (#349)
       QS plan count dropping week-over-week while QS priority enabled.
       ====================================================================== */
    BEGIN
        DECLARE @i12_recent_avg decimal(10, 1);
        DECLARE @i12_prior_avg decimal(10, 1);
        DECLARE @i12_pct_change decimal(10, 1);

        SELECT
            @i12_recent_avg = AVG(CASE WHEN su.StartTime >= DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 1), su.QSPlanCount) END),
            @i12_prior_avg  = AVG(CASE WHEN su.StartTime <  DATEADD(DAY, -@DaysBack / 2, SYSDATETIME()) THEN CONVERT(decimal(10, 1), su.QSPlanCount) END)
        FROM #stat_updates AS su
        INNER JOIN #runs AS r ON r.RunLabel = su.RunLabel
        WHERE r.QueryStorePriority = N'Y'
        AND   su.QSPlanCount IS NOT NULL
        AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL);

        IF @i12_prior_avg IS NOT NULL AND @i12_prior_avg > 0
        AND @i12_recent_avg IS NOT NULL
        BEGIN
            SET @i12_pct_change = (@i12_recent_avg - @i12_prior_avg) * 100.0 / @i12_prior_avg;

            IF @i12_pct_change <= -50.0
            BEGIN
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES (
                    N'INFO',
                    N'QS_COVERAGE_DRIFT',
                    N'Query Store data availability dropped '
                        + CONVERT(nvarchar(10), CONVERT(int, ABS(@i12_pct_change))) + N'%',
                    N'Avg plans/stat: ' + CONVERT(nvarchar(10), CONVERT(decimal(5, 1), @i12_prior_avg))
                        + N' (prior) -> ' + CONVERT(nvarchar(10), CONVERT(decimal(5, 1), @i12_recent_avg))
                        + N' (recent).  QS catalog may be cleared, CAPTURE_MODE changed, or storage full.',
                    N'Check: SELECT actual_state_desc, current_storage_size_mb, max_storage_size_mb FROM sys.database_query_store_options.',
                    NULL,
                    70
                );

                RAISERROR(N'  [INFO] I12: QS coverage drift detected', 10, 1) WITH NOWAIT;
            END;
        END;
    END;

    /* ======================================================================
       I13: PARALLEL OPPORTUNITY (#351)
       Serial runs completing well under TimeLimit.
       ====================================================================== */
    BEGIN
        DECLARE @i13_serial_count integer;
        DECLARE @i13_avg_usage_pct decimal(5, 1);

        SELECT
            @i13_serial_count = COUNT(*),
            @i13_avg_usage_pct = AVG(CASE WHEN r.TimeLimit > 0 THEN r.DurationSeconds * 100.0 / r.TimeLimit END)
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.StopReason = N'COMPLETED'
        AND   ISNULL(r.StatsInParallel, N'N') = N'N'
        AND   r.TimeLimit IS NOT NULL
        AND   r.TimeLimit > 0
        AND   r.DurationSeconds IS NOT NULL;

        IF @i13_serial_count >= 3 AND @i13_avg_usage_pct < 40.0
        BEGIN
            /* Only suggest if no overlapping run warnings (W4) */
            IF NOT EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'OVERLAPPING_RUNS')
            BEGIN
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES (
                    N'INFO',
                    N'PARALLEL_OPPORTUNITY',
                    CONVERT(nvarchar(10), @i13_serial_count) + N' serial run(s) completed using <'
                        + CONVERT(nvarchar(10), CONVERT(int, @i13_avg_usage_pct)) + N'% of time budget',
                    CONVERT(nvarchar(10), @i13_serial_count) + N' recent serial runs completed using avg '
                        + CONVERT(nvarchar(10), CONVERT(int, @i13_avg_usage_pct)) + N'% of @TimeLimit.  '
                        + N'@StatsInParallel=Y could reduce run time.',
                    N'Enable parallel mode to process stats concurrently and reduce wall-clock time.',
                    N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @StatsInParallel = N''Y'';',
                    70
                );

                RAISERROR(N'  [INFO] I13: Parallel opportunity detected', 10, 1) WITH NOWAIT;
            END;
        END;
    END;

    /* ======================================================================
       I14: MOP-UP MISSING PAGECOUNT (#342)
       Mop-up stats with NULL PageCount underestimate throughput (GBPerMin).
       ====================================================================== */
    BEGIN
        DECLARE @i14_null_pct decimal(5, 1);

        ;WITH mop_up_runs AS
        (
            SELECT r.RunLabel
            FROM #runs AS r
            WHERE r.MopUpTriggered = 1
            AND   r.IsKilled = 0
        )
        SELECT @i14_null_pct = CASE WHEN COUNT(*) > 0
            THEN SUM(CASE WHEN su.PageCount IS NULL THEN 1 ELSE 0 END) * 100.0 / COUNT(*)
            ELSE 0 END
        FROM #stat_updates AS su
        INNER JOIN mop_up_runs AS mr ON mr.RunLabel = su.RunLabel
        WHERE su.ErrorNumber = 0 OR su.ErrorNumber IS NULL;

        IF ISNULL(@i14_null_pct, 0) >= 20.0
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'INFO',
                N'MOPUP_MISSING_PAGECOUNT',
                CONVERT(nvarchar(10), CONVERT(int, @i14_null_pct)) + N'% of mop-up stats have NULL PageCount',
                N'Mop-up lazy discovery may not populate PageCount.  TotalGB and GBPerMin metrics may be underestimated on mop-up-heavy runs.  '
                    + N'C4 throughput comparisons should be interpreted with caution.',
                N'This is a known limitation of lazy per-table mop-up discovery.  Throughput metrics are most accurate for priority-pass stats.',
                NULL,
                75
            );

            RAISERROR(N'  [INFO] I14: Mop-up PageCount gaps detected', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W11: MOP-UP LOW YIELD
       Mop-up consistently processes <50% of the stats it discovers.
       Signals TimeLimit exhaustion during the mop-up window, or that
       @MopUpMinRemainingSeconds leaves too little runway to do real work.
       ====================================================================== */
    BEGIN
        DECLARE @w11_mop_runs integer = 0;
        DECLARE @w11_avg_yield decimal(5, 1);

        SELECT
            @w11_mop_runs   = COUNT(*),
            @w11_avg_yield  = AVG(CONVERT(decimal(5, 1), CONVERT(decimal(10, 4), MopUpProcessed) / NULLIF(MopUpFound, 0) * 100.0))
        FROM #runs
        WHERE MopUpTriggered = 1
        AND   MopUpFound > 0          /* exclude runs where mop-up found nothing (W8 territory) */
        AND   IsKilled = 0;

        IF @w11_mop_runs >= 3 AND ISNULL(@w11_avg_yield, 100.0) < 50.0
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'WARNING',
                N'MOPUP_LOW_YIELD',
                N'Mop-up pass unable to process most qualifying stats (avg '
                    + CONVERT(nvarchar(10), CONVERT(int, ISNULL(@w11_avg_yield, 0))) + N'% processed across '
                    + CONVERT(nvarchar(10), @w11_mop_runs) + N' runs)',
                N'Mop-up discovers qualifying stats but cannot finish them before the TimeLimit expires.  '
                    + N'Average yield: ' + CONVERT(nvarchar(10), CONVERT(int, ISNULL(@w11_avg_yield, 0)))
                    + N'%.  The mop-up window is too narrow relative to the number of qualifying stats.',
                N'Consider increasing @TimeLimit or lowering @MopUpMinRemainingSeconds to allow more runway.  '
                    + N'Alternatively, lower @ModificationThreshold so the priority pass captures these stats before mop-up.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @TimeLimit = 7200, @MopUpPass = N''Y'', @MopUpMinRemainingSeconds = 60;',
                45
            );

            DECLARE @w11_yield_int integer = CONVERT(integer, ISNULL(@w11_avg_yield, 0));
            RAISERROR(N'  [WARNING] W11: Mop-up low yield (avg %i%% processed)', 10, 1, @w11_yield_int) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W12: PRIORITY_PASS_EMPTY
       Priority pass contributes almost no stats (<5 on average across 3+ runs)
       while mop-up is doing the real work.  This means @ModificationThreshold
       or tiered thresholds are too high for the current workload -- the priority
       pass filters out nearly everything and leaves it all for mop-up.
       ====================================================================== */
    BEGIN
        DECLARE
            @w12_run_count   integer = 0,
            @w12_avg_priority decimal(10, 1),
            @w12_avg_mopup   decimal(10, 1),
            @w12_mopup_pct   decimal(5, 1),
            @w12_mod_thresh  bigint;

        SELECT
            @w12_run_count    = COUNT(*),
            /* gh-475: Clamp to 0 -- MopUpProcessed can exceed StatsProcessed when the priority
               pass crashed or restarted, producing a negative priority-pass count otherwise. */
            @w12_avg_priority = AVG(CONVERT(decimal(10, 1), CASE WHEN ISNULL(r.StatsProcessed, 0) - ISNULL(r.MopUpProcessed, 0) < 0 THEN 0 ELSE ISNULL(r.StatsProcessed, 0) - ISNULL(r.MopUpProcessed, 0) END)),
            @w12_avg_mopup    = AVG(CONVERT(decimal(10, 1), ISNULL(r.MopUpProcessed, 0))),
            @w12_mod_thresh   = MAX(r.ModificationThreshold)
        FROM #runs AS r
        WHERE r.MopUpTriggered = 1
        AND   r.IsKilled = 0;

        IF @w12_run_count >= 3
           AND ISNULL(@w12_avg_priority, 99) < 5
           AND ISNULL(@w12_avg_mopup, 0) > 0
        BEGIN
            SET @w12_mopup_pct = CASE
                WHEN (@w12_avg_priority + @w12_avg_mopup) > 0
                THEN CONVERT(decimal(5, 1), @w12_avg_mopup * 100.0 / (@w12_avg_priority + @w12_avg_mopup))
                ELSE 100.0
            END;

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'WARNING',
                N'PRIORITY_PASS_EMPTY',
                N'Priority pass finds almost no qualifying stats -- mop-up does '
                    + CONVERT(nvarchar(10), CONVERT(int, ISNULL(@w12_mopup_pct, 0))) + N'% of the work',
                N'Across ' + CONVERT(nvarchar(10), @w12_run_count) + N' mop-up runs, the priority pass averaged only '
                    + CONVERT(nvarchar(10), CONVERT(int, ISNULL(@w12_avg_priority, 0))) + N' stat(s) while mop-up averaged '
                    + CONVERT(nvarchar(10), CONVERT(int, ISNULL(@w12_avg_mopup, 0))) + N' stat(s).  '
                    + N'The modification threshold or tiered threshold settings are filtering out nearly all candidates '
                    + N'from the priority pass, leaving them for the broad mop-up sweep.  '
                    + CASE WHEN @w12_mod_thresh IS NOT NULL
                        THEN N'Current @ModificationThreshold: ' + CONVERT(nvarchar(20), @w12_mod_thresh) + N'.'
                        ELSE N'' END,
                N'Lower @ModificationThreshold so more stats qualify for the priority pass (with its workload-aware ordering), '
                    + N'rather than falling through to the unordered mop-up sweep.  '
                    + N'This ensures high-impact stats are prioritised when the time limit is hit.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @MopUpPass = N''Y'', @ModificationThreshold = '
                    + ISNULL(CONVERT(nvarchar(20), @w12_mod_thresh / 2), N'1000') + N';',
                42
            );

            DECLARE @w12_mopup_pct_int integer = CONVERT(integer, ISNULL(@w12_mopup_pct, 0));
            RAISERROR(N'  [WARNING] W12: Priority pass empty -- mop-up does %i%% of work', 10, 1, @w12_mopup_pct_int) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       I15: HEAP TIME BUDGET
       Heap tables (IsHeap = 1) account for >50% of total maintenance time.
       Signals that forwarding pointer overhead or full-table scans on heaps
       are consuming a disproportionate share of the maintenance window.
       ====================================================================== */
    BEGIN
        DECLARE @i15_total_duration_ms bigint;
        DECLARE @i15_heap_duration_ms bigint;
        DECLARE @i15_heap_pct decimal(5, 1);

        SELECT
            @i15_total_duration_ms = SUM(CASE WHEN su.DurationMs IS NOT NULL AND (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL) THEN su.DurationMs ELSE 0 END),
            @i15_heap_duration_ms  = SUM(CASE WHEN su.IsHeap = 1 AND su.DurationMs IS NOT NULL AND (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL) THEN su.DurationMs ELSE 0 END)
        FROM #stat_updates AS su;

        SET @i15_heap_pct = CASE WHEN ISNULL(@i15_total_duration_ms, 0) > 0
            THEN CONVERT(decimal(5, 1), @i15_heap_duration_ms * 100.0 / @i15_total_duration_ms)
            ELSE 0.0 END;

        IF @i15_heap_pct > 50.0
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'INFO',
                N'HEAP_TIME_BUDGET',
                N'Heap tables consume ' + CONVERT(nvarchar(10), CONVERT(int, @i15_heap_pct)) + N'% of total maintenance time',
                N'Heap table statistics require full-table scans without a clustered index seek, and forwarding pointers '
                    + N'on heaps accumulate over time causing increasingly expensive updates.  '
                    + CONVERT(nvarchar(10), CONVERT(int, @i15_heap_pct)) + N'% of maintenance duration is spent on heap stats.',
                N'Consider enabling @CollectHeapForwarding=Y to surface forwarding pointer counts, and schedule periodic '
                    + N'heap REBUILD (ALTER TABLE ... REBUILD) to remove forwarding pointers.  '
                    + N'Adding a clustered index eliminates the heap entirely.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @CollectHeapForwarding = N''Y'';',
                70
            );

            DECLARE @i15_heap_pct_int integer = CONVERT(integer, @i15_heap_pct);
            RAISERROR(N'  [INFO] I15: Heap tables dominate maintenance time (%i%%)', 10, 1, @i15_heap_pct_int) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W13: PERPETUALLY SKIPPED (gh-504)
       Stats present in discovery (SP_STATUPDATE_START StatsFound > 0) but
       absent from UPDATE_STATISTICS entries across N consecutive runs.
       These stats are never reached because the time limit expires first.
       Cross-references ProcessingPosition of the last processed stat per
       run against the queue depth to estimate how much more time is needed.
       ====================================================================== */
    BEGIN
        DECLARE @w13_min_consecutive int = 3;
        DECLARE @w13_skipped_count int = 0;
        DECLARE @w13_run_count int = 0;
        DECLARE @w13_avg_last_position int = 0;
        DECLARE @w13_avg_total int = 0;

        /* Count non-killed, time-limited runs */
        SELECT @w13_run_count = COUNT(*)
        FROM #runs
        WHERE IsKilled = 0
        AND   StopReason IN (N'TIME_LIMIT', N'NATURAL_END', N'COMPLETED');

        IF @w13_run_count >= @w13_min_consecutive
        BEGIN
            /* Find stats that appeared in discovery but were never updated.
               A stat is "perpetually skipped" if it appears in 0 UPDATE_STATISTICS
               entries across the most recent N completed runs, while those runs
               DID process other stats (StatsProcessed > 0). */
            ;WITH recent_runs AS (
                SELECT TOP (@w13_min_consecutive)
                    r.RunLabel,
                    r.StatsFound,
                    r.StatsProcessed,
                    r.StartTime
                FROM #runs AS r
                WHERE r.IsKilled = 0
                AND   r.StopReason IN (N'TIME_LIMIT', N'NATURAL_END', N'COMPLETED')
                AND   r.StatsProcessed > 0
                ORDER BY r.StartTime DESC
            ),
            updated_stats AS (
                SELECT DISTINCT
                    su.DatabaseName,
                    su.ObjectName,
                    su.StatisticsName
                FROM #stat_updates AS su
                INNER JOIN recent_runs AS rr
                    ON su.RunLabel = rr.RunLabel
                WHERE su.ErrorNumber = 0
                   OR su.ErrorNumber IS NULL
            ),
            /* Get the max ProcessingPosition per run to estimate queue depth */
            run_positions AS (
                SELECT
                    su.RunLabel,
                    MAX(su.ProcessingPosition) AS max_position
                FROM #stat_updates AS su
                INNER JOIN recent_runs AS rr
                    ON su.RunLabel = rr.RunLabel
                WHERE su.ProcessingPosition IS NOT NULL
                GROUP BY su.RunLabel
            )
            SELECT
                @w13_skipped_count = (
                    SELECT COUNT(DISTINCT su_all.DatabaseName + N'.' + su_all.ObjectName + N'.' + su_all.StatisticsName)
                    FROM #stat_updates AS su_all
                    WHERE NOT EXISTS (
                        SELECT 1 FROM updated_stats AS us
                        WHERE us.DatabaseName   = su_all.DatabaseName
                        AND   us.ObjectName     = su_all.ObjectName
                        AND   us.StatisticsName = su_all.StatisticsName
                    )
                ),
                @w13_avg_last_position = ISNULL((SELECT AVG(max_position) FROM run_positions), 0),
                @w13_avg_total = ISNULL((SELECT AVG(StatsFound) FROM recent_runs), 0);

            IF @w13_skipped_count > 0
            BEGIN
                INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
                VALUES (
                    N'WARNING',
                    N'PERPETUALLY_SKIPPED',
                    CONVERT(nvarchar(10), @w13_skipped_count) + N' stats never updated across '
                        + CONVERT(nvarchar(10), @w13_min_consecutive) + N' consecutive runs',
                    N'Discovery finds these stats but the time limit expires before they are reached.  '
                        + N'Average last position processed: ' + CONVERT(nvarchar(10), @w13_avg_last_position)
                        + N' of ' + CONVERT(nvarchar(10), @w13_avg_total) + N' discovered.  '
                        + N'Stats beyond position ' + CONVERT(nvarchar(10), @w13_avg_last_position) + N' are perpetually stale.',
                    N'Increase @TimeLimit to allow more stats to be processed, use @SortOrder=MODIFICATION_VELOCITY '
                        + N'to prioritize high-velocity stats, or lower @ModificationThreshold so fewer stats qualify.',
                    N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @SortOrder = N''MODIFICATION_VELOCITY'', @TimeLimit = 7200;',
                    40
                );

                RAISERROR(N'  [WARNING] W13: %d stats perpetually skipped across %d runs', 10, 1, @w13_skipped_count, @w13_min_consecutive) WITH NOWAIT;
            END;
        END;
    END;

    /* ======================================================================
       I4: UNUSED FEATURES
       ====================================================================== */
    IF @latest_run_label IS NOT NULL
    BEGIN
        /* 8gws: Extract newer v3 parameters from the most recent START record.
           These are not stored in #runs columns (added in v3.5.0/v3.5.4/v3.5.9)
           so we pull them directly from CommandLog XML here. */
        SET @sql = N'
        SELECT
            @ftfs = cl.ExtendedInfo.value(N''(Parameters/FirstTimeFullScanCapRows)[1]'', N''bigint''),
            @ct   = cl.ExtendedInfo.value(N''(Parameters/CriticalTables)[1]'', N''nvarchar(max)''),
            @aoi  = cl.ExtendedInfo.value(N''(Parameters/AbortOnIntegrityError)[1]'', N''bit'')
        FROM ' + @commandlog_ref + N' AS cl
        WHERE cl.CommandType = N''SP_STATUPDATE_START''
          AND cl.ExtendedInfo.value(N''(Parameters/RunLabel)[1]'', N''nvarchar(100)'') = @run_label;
        ';
        EXECUTE sys.sp_executesql
            @sql,
            N'@run_label nvarchar(100), @ftfs bigint OUTPUT, @ct nvarchar(max) OUTPUT, @aoi bit OUTPUT',
            @run_label = @latest_run_label,
            @ftfs = @latest_first_time_fullscan_cap_rows OUTPUT,
            @ct   = @latest_critical_tables OUTPUT,
            @aoi  = @latest_abort_on_integrity OUTPUT;

        /* I4a: No preset
           9ufm gate: only surface when the Parameters element exists AND the Preset element
           was explicitly present (even if NULL) -- absent element means this is a pre-preset
           run, not evidence the operator omitted the parameter. */
        IF @latest_preset IS NULL
        AND @latest_has_full_params_log = 1   /* 9ufm: version-gated */
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO', N'UNUSED_FEATURES',
                N'Presets not in use',
                N'@Preset is NULL. Presets provide tested parameter combinations for common scenarios.',
                N'Consider using presets for standardized configurations: NIGHTLY, WEEKLY_FULL, OLTP_LIGHT, WAREHOUSE.',
                N'EXECUTE dbo.sp_StatUpdate @Preset = N''NIGHTLY'', @Databases = N''USER_DATABASES'';',
                60
            );
        END;

        /* I4b: Long-running stats exist but adaptive not enabled (softer than W1c) */
        IF @latest_long_run_min IS NULL
        AND NOT EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'SUBOPTIMAL_PARAMS' AND Finding LIKE N'%adaptive%')
        AND @stat_update_count > 0
        AND EXISTS (SELECT 1 FROM #stat_updates WHERE DurationMs > 300000 AND ErrorNumber = 0) /* >5 min */
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO', N'UNUSED_FEATURES',
                N'Adaptive sampling available but not enabled',
                N'Some stats take >5 minutes. @LongRunningThresholdMinutes can automatically cap these with a lower sample rate.',
                N'Adaptive sampling uses CommandLog history to identify slow stats and apply reduced sampling.',
                N'EXECUTE dbo.sp_StatUpdate @LongRunningThresholdMinutes = 15, @LongRunningSamplePercent = 10;',
                65
            );
        END;

        /* 8gws -- I4c: @FirstTimeFullScanCapRows (v3.5.4) not in use.
           This parameter caps rows forced to FULLSCAN on first-time stat qualification,
           preventing runaway FULLSCAN on enormous tables when @StatisticsSample is NULL.
           9ufm gate: only surface when the element was present (v3.5.4+ run). */
        IF @latest_first_time_fullscan_cap_rows IS NULL
        AND @latest_has_full_params_log = 1   /* 9ufm: version-gated */
        AND @stat_update_count > 0
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO', N'UNUSED_FEATURES',
                N'@FirstTimeFullScanCapRows not configured (v3.5.4+)',
                N'@FirstTimeFullScanCapRows limits FULLSCAN on first-time stat qualification to tables below the cap. '
                    + N'Without it, fresh statistics on very large tables can trigger unbounded FULLSCAN operations.',
                N'Set @FirstTimeFullScanCapRows to the maximum table row count that should get FULLSCAN on first qualification. '
                    + N'Larger tables fall back to auto-sample. Recommended starting point: 10,000,000 rows.',
                N'EXECUTE dbo.sp_StatUpdate @FirstTimeFullScanCapRows = 10000000, @Databases = N''USER_DATABASES'';',
                67
            );
        END;

        /* 8gws -- I4d: @CriticalTables (v3.5.0) not in use.
           This parameter specifies table patterns that receive priority boost and
           per-table sample-rate override -- highly valuable for tables with known
           workload importance or lock-contention history.
           9ufm gate: only surface when the Parameters element has CriticalTables present;
           absent means pre-v3.5.0 run (parameter did not exist yet). */
        IF @latest_critical_tables IS NULL
        AND @latest_has_full_params_log = 1   /* 9ufm: version-gated */
        AND @stat_update_count > 0
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO', N'UNUSED_FEATURES',
                N'@CriticalTables not configured (v3.5.0+)',
                N'@CriticalTables accepts comma-separated table patterns (LIKE syntax) that receive a processing '
                    + N'priority boost and optional per-table FULLSCAN override. Particularly useful for tables '
                    + N'identified via W7 HIGH_IMPACT_STATS_DEPRIORITIZED or W9 LOCK_TIMEOUT_INEFFECTIVE.',
                N'Specify critical tables to ensure they are always updated early in the run, regardless of sort order.',
                N'EXECUTE dbo.sp_StatUpdate @CriticalTables = N''dbo.Orders,dbo.OrderItems'', @Databases = N''USER_DATABASES'';',
                68
            );
        END;

        /* 8gws -- I4e: @AbortOnIntegrityError (v3.5.9) -- recommend only when IO_CORRUPTION is visible.
           Do not surface this if there is no sign of IO errors in the run history.
           IO_CORRUPTION is visible in TWO places: StopReason (abort mode, @AbortOnIntegrityError = 1)
           OR the WarningsCodes element (continue mode, @AbortOnIntegrityError = 0 -- run completes
           with a benign StopReason and the code only lands in Summary/WarningsCodes). */
        IF @latest_abort_on_integrity IS NULL
        AND EXISTS
            (
                SELECT 1
                FROM #runs
                WHERE IsKilled = 0
                AND
                (
                       StopReason = N'IO_CORRUPTION'
                    OR WarningsCodes LIKE N'%IO_CORRUPTION%'
                )
            )
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO', N'UNUSED_FEATURES',
                N'@AbortOnIntegrityError not configured -- IO_CORRUPTION stop reason seen in history (v3.5.9+)',
                N'One or more runs stopped with StopReason=IO_CORRUPTION. @AbortOnIntegrityError=1 halts the run '
                    + N'immediately when a CHECKDB-style integrity error is detected during UPDATE STATISTICS, '
                    + N'preventing statistics from masking an underlying corruption. Investigate with DBCC CHECKDB.',
                N'Enable @AbortOnIntegrityError after investigating the corruption root cause with DBCC CHECKDB. '
                    + N'Fix the underlying storage issue before re-enabling statistics maintenance.',
                N'EXECUTE dbo.sp_StatUpdate @AbortOnIntegrityError = 1, @Databases = N''USER_DATABASES'';',
                50
            );
        END;
    END;

    /* ======================================================================
       I5: VERSION_HISTORY -- sp_StatUpdate versions used across analysis window
       ====================================================================== */
    IF @run_count > 0
    BEGIN
        DECLARE
            @i5_version_count integer,
            @i5_version_detail nvarchar(max);

        SET @i5_version_count = (SELECT COUNT(DISTINCT r.[Version]) FROM #runs AS r WHERE r.[Version] IS NOT NULL);

        SELECT @i5_version_detail = STRING_AGG(v.VersionInfo, N'; ') WITHIN GROUP (ORDER BY v.VersionInfo)
        FROM
        (
            SELECT
                VersionInfo = r.[Version] + N' (' + CONVERT(nvarchar(10), COUNT_BIG(*)) + N' runs)'
            FROM #runs AS r
            WHERE r.[Version] IS NOT NULL
            GROUP BY r.[Version]
        ) AS v;

        IF @i5_version_count >= 2
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'WARNING',
                N'VERSION_HISTORY',
                N'Version skew detected: ' + CONVERT(nvarchar(10), @i5_version_count) + N' different sp_StatUpdate versions in the analysis window.',
                @i5_version_detail,
                N'Standardize all servers and jobs on the latest version to ensure consistent behavior and bug fixes.',
                N'/* Deploy latest sp_StatUpdate.sql to all servers */',
                55
            );

            RAISERROR(N'  [WARNING] I5: %i versions detected (version skew)', 10, 1, @i5_version_count) WITH NOWAIT;
        END
        ELSE IF @i5_version_count = 1
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO',
                N'VERSION_HISTORY',
                N'Consistent version: all runs used ' + ISNULL(@i5_version_detail, N'(unknown)') + N'.',
                @i5_version_detail,
                N'No action needed. All runs use the same version.',
                N'',
                70
            );

            RAISERROR(N'  [INFO] I5: single version in use', 10, 1) WITH NOWAIT;
        END;
    END;

    /*
    ============================================================================
    QS EFFICACY ANALYSIS: Build #qs_efficacy temp table
    ============================================================================
    */
    RAISERROR(N'Computing QS efficacy metrics...', 10, 1) WITH NOWAIT;

    CREATE TABLE #qs_efficacy
    (
        RunLabel nvarchar(100) NOT NULL,
        StartTime datetime2(3) NOT NULL,
        SortOrder nvarchar(50) NULL,
        QueryStorePriority nvarchar(1) NULL,
        StatsProcessed integer NULL,
        StatsFound integer NULL,
        DurationSeconds integer NULL,
        StopReason nvarchar(50) NULL,
        IsQSRun bit NOT NULL DEFAULT 0,
        /* Computed efficacy metrics */
        HighCpuInFirstQuartilePct decimal(5, 1) NULL,
        MinutesToHighCpuComplete decimal(10, 1) NULL,
        WorkloadCoveragePct decimal(5, 1) NULL,
        CompletionPct decimal(5, 1) NULL,
        AvgSecPerStat decimal(10, 1) NULL,
        AvgPositionTop10 decimal(10, 1) NULL,

        CONSTRAINT PK_qs_efficacy PRIMARY KEY NONCLUSTERED (RunLabel)
    );

    /* Populate #qs_efficacy for all non-killed runs that have stat updates.
       BUG-D fix: QS-specific metrics (HighCpuInFirstQuartilePct, MinutesToHighCpuComplete,
       WorkloadCoveragePct, AvgPositionTop10) are only computed for runs with actual QS data.
       Non-QS runs get NULL for these columns to prevent random first-quartile noise.
       BUG-A fix: WorkloadCoveragePct uses honest denominator -- for completed runs = 100%,
       for incomplete runs, extrapolates total CPU from processed stats' average. */
    ;WITH stat_positions AS
    (
        /* Determine each stat's position within its run (use ProcessingPosition if available, else order by ID) */
        SELECT
            su.RunLabel,
            su.ID,
            su.DatabaseName,
            su.SchemaName,
            su.ObjectName,
            su.StatisticsName,
            su.QSTotalCpuMs,
            su.QSTotalExecutions,
            su.QSPlanCount,
            su.DurationMs,
            su.QualifyReason,
            processing_pos  = ISNULL(su.ProcessingPosition, ROW_NUMBER() OVER (PARTITION BY su.RunLabel ORDER BY su.ID)),
            cpu_rank        = ROW_NUMBER() OVER (PARTITION BY su.RunLabel ORDER BY ISNULL(su.QSTotalCpuMs, 0) DESC, su.ID),
            su.StartTime AS StatStartTime,
            su.EndTime AS StatEndTime
        FROM #stat_updates AS su
        WHERE su.ErrorNumber = 0
        OR    su.ErrorNumber IS NULL
    ),
    run_metrics AS
    (
        SELECT
            sp.RunLabel,
            /* BUG-D: Only count stats with actual QS data (QSTotalCpuMs > 0) for QS-specific metrics */
            high_cpu_first_q = SUM(
                CASE
                    WHEN sp.cpu_rank <= 10
                    AND  sp.QSTotalCpuMs > 0
                    AND  r.StatsFound > 0
                    AND  sp.processing_pos <= CEILING(r.StatsFound * 0.25)
                    THEN 1
                    ELSE 0
                END
            ),
            high_cpu_total = SUM(CASE WHEN sp.cpu_rank <= 10 AND sp.QSTotalCpuMs > 0 THEN 1 ELSE 0 END),
            /* Minutes from run start until all top-10 CPU stats are processed */
            max_top10_end = MAX(CASE WHEN sp.cpu_rank <= 10 AND sp.QSTotalCpuMs > 0 THEN sp.StatEndTime END),
            /* BUG-A: processed_cpu_ms = CPU of stats that were actually processed */
            processed_cpu_ms = SUM(CASE WHEN sp.QSTotalCpuMs > 0 THEN sp.QSTotalCpuMs ELSE 0 END),
            /* Average position of top-10 CPU stats (only those with QS data) */
            avg_pos_top10 = AVG(CASE WHEN sp.cpu_rank <= 10 AND sp.QSTotalCpuMs > 0 THEN CONVERT(decimal(10, 1), sp.processing_pos) END),
            stat_count = COUNT_BIG(*),
            /* Count of stats with actual QS data -- used to detect non-QS runs */
            qs_stat_count = SUM(CASE WHEN sp.QSTotalCpuMs > 0 THEN 1 ELSE 0 END)
        FROM stat_positions AS sp
        INNER JOIN #runs AS r
            ON r.RunLabel = sp.RunLabel
        GROUP BY sp.RunLabel
    )
    INSERT INTO #qs_efficacy
    (
        RunLabel, StartTime, SortOrder, QueryStorePriority,
        StatsProcessed, StatsFound, DurationSeconds, StopReason, IsQSRun,
        HighCpuInFirstQuartilePct, MinutesToHighCpuComplete,
        WorkloadCoveragePct, CompletionPct, AvgSecPerStat, AvgPositionTop10
    )
    SELECT
        r.RunLabel,
        r.StartTime,
        r.SortOrder,
        r.QueryStorePriority,
        r.StatsProcessed,
        r.StatsFound,
        r.DurationSeconds,
        r.StopReason,
        is_qs_run       = CASE
                              WHEN r.QueryStorePriority = N'Y'
                              OR   r.SortOrder LIKE N'%QUERY_STORE%'
                              THEN 1
                              ELSE 0
                          END,
        /* BUG-D: QS-specific metrics are NULL when no stats have QS data */
        high_cpu_q1_pct = CASE
                              WHEN ISNULL(rm.qs_stat_count, 0) = 0 THEN NULL
                              WHEN rm.high_cpu_total > 0
                              THEN CONVERT(decimal(5, 1), rm.high_cpu_first_q * 100.0 / rm.high_cpu_total)
                              ELSE NULL
                          END,
        min_to_high_cpu = CASE
                              WHEN ISNULL(rm.qs_stat_count, 0) = 0 THEN NULL
                              WHEN rm.max_top10_end IS NOT NULL
                              THEN CONVERT(decimal(10, 1), DATEDIFF(SECOND, r.StartTime, rm.max_top10_end) / 60.0)
                              ELSE NULL
                          END,
        /* BUG-A fix: For completed runs, WorkloadCoveragePct = 100% (all qualifying stats processed).
           PARALLEL_COMPLETE also means all distributed work finished -- treat same as COMPLETED.
           For incomplete runs, extrapolate: estimated_total = processed_cpu * (StatsFound / StatsProcessed).
           This accounts for unprocessed stats whose CPU we don't know. */
        workload_pct    = CASE
                              WHEN ISNULL(rm.qs_stat_count, 0) = 0 THEN NULL
                              WHEN rm.processed_cpu_ms <= 0 THEN NULL
                              /* kzx0: same worker-group cross-check as completion_pct --
                                 PARALLEL_COMPLETE with leftovers only counts as full
                                 coverage when the group drained the queue; otherwise
                                 fall through to the extrapolation branch. */
                              WHEN (r.StopReason IN (N'COMPLETED', N'PARALLEL_COMPLETE') OR r.StatsFound = ISNULL(r.StatsProcessed, 0))
                              AND  NOT (r.StopReason = N'PARALLEL_COMPLETE'
                                        AND ISNULL(r.StatsRemaining, 0) > 0
                                        AND ISNULL(grp.sum_processed, 0) < ISNULL(grp.max_found, 0))
                              THEN 100.0
                              WHEN r.StatsFound > 0 AND ISNULL(r.StatsProcessed, 0) > 0
                              THEN CONVERT(decimal(5, 1),
                                  rm.processed_cpu_ms * 100.0 /
                                  (rm.processed_cpu_ms + (rm.processed_cpu_ms * 1.0 / rm.qs_stat_count)
                                      * (r.StatsFound - ISNULL(r.StatsProcessed, 0)))
                              )
                              ELSE NULL
                          END,
        completion_pct  = CASE
                              /* sp_StatUpdate-kzx0: PARALLEL_COMPLETE with
                                 StatsRemaining > 0 is self-contradictory
                                 telemetry -- only score 100 when the worker
                                 group (overlapping parallel runs, this one
                                 included) actually drained the queue.  A
                                 zombied queue (v31y signature: found > 0,
                                 group processed = 0) scores honestly: SUM of
                                 group processed over MAX of group found. */
                              WHEN r.StopReason = N'PARALLEL_COMPLETE'
                              AND  ISNULL(r.StatsRemaining, 0) > 0
                              AND  ISNULL(grp.sum_processed, 0) < ISNULL(grp.max_found, 0)
                              THEN CONVERT(decimal(5, 1), ISNULL(grp.sum_processed, 0) * 100.0 / NULLIF(grp.max_found, 0))
                              /* sp_StatUpdate-3j5l: a run that reached a clean
                                 stop is 100% complete regardless of the
                                 StatsProcessed / StatsFound ratio.  In parallel
                                 mode StatsFound is the whole-queue total while
                                 StatsProcessed is this worker's slice, so the
                                 raw ratio understates completion (e.g. 50%). */
                              WHEN r.StopReason IN (N'COMPLETED', N'PARALLEL_COMPLETE') THEN 100.0
                              WHEN r.StatsFound > 0
                              THEN CONVERT(decimal(5, 1), ISNULL(r.StatsProcessed, 0) * 100.0 / r.StatsFound)
                              ELSE NULL
                          END,
        avg_sec_stat    = CASE
                              WHEN r.StatsProcessed > 0
                              THEN CONVERT(decimal(10, 1), r.DurationSeconds * 1.0 / r.StatsProcessed)
                              ELSE NULL
                          END,
        CASE WHEN ISNULL(rm.qs_stat_count, 0) = 0 THEN NULL ELSE rm.avg_pos_top10 END
    FROM #runs AS r
    LEFT JOIN run_metrics AS rm
        ON rm.RunLabel = r.RunLabel
    /* kzx0: worker group for the PARALLEL_COMPLETE cross-check -- non-killed
       parallel runs (param flag or stop reason) whose run window overlaps this
       run's window.  In parallel mode StatsFound is the whole-queue total and
       StatsProcessed is the per-worker slice, so aggregate before comparing:
       SUM(processed) across the group vs MAX(found). */
    OUTER APPLY
    (
        SELECT
            sum_processed = SUM(ISNULL(r2.StatsProcessed, 0)),
            max_found     = MAX(r2.StatsFound)
        FROM #runs AS r2
        WHERE r2.IsKilled = 0
        AND   (ISNULL(r2.StatsInParallel, N'N') = N'Y' OR r2.StopReason = N'PARALLEL_COMPLETE')
        AND   r2.StartTime <= ISNULL(r.EndTime, r.StartTime)
        AND   ISNULL(r2.EndTime, DATEADD(SECOND, ISNULL(r2.TimeLimit, 18000), r2.StartTime)) >= r.StartTime
    ) AS grp
    WHERE r.IsKilled = 0;

    DECLARE @qs_efficacy_count integer = (SELECT COUNT_BIG(*) FROM #qs_efficacy);
    DECLARE @qs_run_count integer = (SELECT COUNT_BIG(*) FROM #qs_efficacy WHERE IsQSRun = 1);
    RAISERROR(N'  Efficacy rows: %i (QS runs: %i)', 10, 1, @qs_efficacy_count, @qs_run_count) WITH NOWAIT;

    IF @Debug = 1 AND @qs_efficacy_count > 0
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        RAISERROR(N'DEBUG: #qs_efficacy sample (top 5)', 10, 1) WITH NOWAIT;
        SELECT TOP (5) * FROM #qs_efficacy ORDER BY StartTime DESC;
        RAISERROR(N'DEBUG: QS efficacy computation complete (%i ms)', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
    END;

    /* ======================================================================
       I6: QS_EFFICACY - Query Store prioritization effectiveness
       ====================================================================== */
    IF @qs_run_count > 0
    BEGIN
        DECLARE
            @i6_avg_q1_pct decimal(5, 1),
            @i6_avg_minutes decimal(10, 1),
            @i6_avg_workload decimal(5, 1),
            @i6_top10_in_q1 integer,
            @i6_run_count integer;

        SELECT
            @i6_avg_q1_pct    = AVG(e.HighCpuInFirstQuartilePct),
            @i6_avg_minutes   = AVG(e.MinutesToHighCpuComplete),
            @i6_avg_workload  = AVG(e.WorkloadCoveragePct),
            @i6_top10_in_q1   = AVG(CONVERT(integer, e.HighCpuInFirstQuartilePct / 10.0)),
            @i6_run_count     = COUNT_BIG(*)
        FROM #qs_efficacy AS e
        WHERE e.IsQSRun = 1
        AND   e.HighCpuInFirstQuartilePct IS NOT NULL;

        IF @i6_run_count = 0
        BEGIN
            /* QS-flagged runs exist but none had usable CPU metrics (all HighCpuInFirstQuartilePct IS NULL).
               This happens when Query Store was recently enabled, has no runtime stats, or databases have minimal activity. */
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO',
                N'QS_EFFICACY',
                N'Query Store prioritization is configured but no CPU workload data was found in '
                    + CONVERT(nvarchar(10), @qs_run_count) + N' recent QS run(s). '
                    + N'This may indicate Query Store was recently enabled, has no runtime stats yet, '
                    + N'or the monitored databases have minimal query activity.',
                N'QS-flagged runs found: ' + CONVERT(nvarchar(10), @qs_run_count)
                    + N'. None contained usable CPU metrics in sys.query_store_runtime_stats.',
                N'Verify Query Store is in READ_WRITE mode and has accumulated runtime statistics. '
                    + N'Check: SELECT actual_state_desc FROM sys.database_query_store_options;',
                N'EXECUTE dbo.sp_StatUpdate_Diag @EfficacyDaysBack = 100, @Debug = 1;',
                70
            );
            RAISERROR(N'  [INFO] I6: QS runs found but no CPU data available', 10, 1) WITH NOWAIT;
        END
        ELSE
        BEGIN
            /* GAP-E: Estimate time without prioritization for comparison.
               Without QS prioritization, critical stats land at random positions.
               Expected position = midpoint (StatsFound/2), so expected time =
               AvgSecPerStat * (StatsFound/2) / 60.0 minutes. */
            DECLARE
                @i6_estimated_no_qs_min decimal(10, 1);

            SELECT
                @i6_estimated_no_qs_min = AVG(e.AvgSecPerStat * e.StatsFound / 2.0 / 60.0)
            FROM #qs_efficacy AS e
            WHERE e.IsQSRun = 1
            AND   e.HighCpuInFirstQuartilePct IS NOT NULL
            AND   e.AvgSecPerStat > 0
            AND   e.StatsFound > 0;

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO',
                N'QS_EFFICACY',
                N'Query Store prioritization active: '
                    + CONVERT(nvarchar(10), CONVERT(integer, @i6_avg_q1_pct / 10.0)) + N' of 10 highest-workload statistics updated in the first '
                    + CONVERT(nvarchar(10), CONVERT(integer, @i6_avg_minutes)) + N' minutes across '
                    + CONVERT(nvarchar(10), @i6_run_count) + N' recent run(s). Workload coverage: '
                    + CONVERT(nvarchar(10), @i6_avg_workload) + N'% of measured CPU.'
                    + CASE WHEN @i6_estimated_no_qs_min IS NOT NULL AND @i6_avg_minutes IS NOT NULL
                        THEN N' Critical stats reached in '
                            + CONVERT(nvarchar(10), CONVERT(integer, @i6_avg_minutes)) + N' min (QS) vs ~'
                            + CONVERT(nvarchar(10), CONVERT(integer, @i6_estimated_no_qs_min)) + N' min estimated without prioritization.'
                        ELSE N''
                    END,
                N'Avg high-CPU-in-first-quartile: ' + CONVERT(nvarchar(10), @i6_avg_q1_pct) + N'%. '
                    + N'Avg minutes to complete top-10: ' + CONVERT(nvarchar(20), @i6_avg_minutes) + N'. '
                    + N'Avg workload coverage: ' + CONVERT(nvarchar(10), @i6_avg_workload) + N'%. '
                    + N'Across ' + CONVERT(nvarchar(10), @i6_run_count) + N' QS-priority run(s).'
                    + CASE WHEN @i6_estimated_no_qs_min IS NOT NULL
                        THEN N' Estimated without QS: ~' + CONVERT(nvarchar(10), CONVERT(integer, @i6_estimated_no_qs_min)) + N' min to reach critical stats.'
                        ELSE N''
                    END,
                N'High first-quartile placement means the most impactful statistics are being refreshed early in the maintenance window. '
                    + N'Monitor this over time to confirm QS prioritization continues to deliver value.',
                N'EXECUTE dbo.sp_StatUpdate_Diag @EfficacyDaysBack = 100;',
                70
            );

            RAISERROR(N'  [INFO] I6: QS efficacy computed', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       I7: QS_INFLECTION - Before/after change detection
       ====================================================================== */
    DECLARE
        @pre_qs_count integer = 0,
        @post_qs_count integer = 0,
        @inflection_date datetime2(3);

    /* Find inflection point: first QS run that follows a non-QS run */
    SELECT TOP (1)
        @inflection_date = e.StartTime
    FROM #qs_efficacy AS e
    WHERE e.IsQSRun = 1
    AND   EXISTS (
        SELECT 1 FROM #qs_efficacy AS e2
        WHERE e2.IsQSRun = 0
        AND   e2.StartTime < e.StartTime
    )
    ORDER BY e.StartTime;

    IF @inflection_date IS NOT NULL
    BEGIN
        SELECT
            @pre_qs_count = COUNT_BIG(*)
        FROM #qs_efficacy
        WHERE StartTime < @inflection_date
        AND   IsQSRun = 0;

        SELECT
            @post_qs_count = COUNT_BIG(*)
        FROM #qs_efficacy
        WHERE StartTime >= @inflection_date
        AND   IsQSRun = 1;
    END;

    IF @inflection_date IS NOT NULL AND @pre_qs_count >= 3 AND @post_qs_count >= 3
    BEGIN
        DECLARE
            @pre_q1_pct decimal(5, 1),
            @post_q1_pct decimal(5, 1),
            @pre_completion decimal(5, 1),
            @post_completion decimal(5, 1),
            @pre_minutes decimal(10, 1),
            @post_minutes decimal(10, 1);

        SELECT
            @pre_q1_pct     = AVG(e.HighCpuInFirstQuartilePct),
            @pre_completion = AVG(e.CompletionPct),
            @pre_minutes    = AVG(e.MinutesToHighCpuComplete)
        FROM #qs_efficacy AS e
        WHERE e.StartTime < @inflection_date
        AND   e.IsQSRun = 0;

        SELECT
            @post_q1_pct     = AVG(e.HighCpuInFirstQuartilePct),
            @post_completion = AVG(e.CompletionPct),
            @post_minutes    = AVG(e.MinutesToHighCpuComplete)
        FROM #qs_efficacy AS e
        WHERE e.StartTime >= @inflection_date
        AND   e.IsQSRun = 1;

        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        VALUES
        (
            N'INFO',
            N'QS_INFLECTION',
            N'Configuration change detected ('
                + CONVERT(nvarchar(20), @inflection_date, 120) + N'): High-workload stats moved from '
                + CASE WHEN ISNULL(@pre_q1_pct, 0) < 50 THEN N'bottom-half' ELSE N'mid-range' END
                + N' to first-quartile processing.'
                + CASE WHEN @pre_minutes IS NOT NULL AND @post_minutes IS NOT NULL AND @pre_minutes > @post_minutes
                    THEN N' Before: ' + CONVERT(nvarchar(10), CONVERT(integer, @pre_minutes)) + N' min to critical stats. After: '
                        + CONVERT(nvarchar(10), CONVERT(integer, @post_minutes)) + N' min. Time saved: '
                        + CONVERT(nvarchar(10), CONVERT(integer, @pre_minutes - @post_minutes)) + N' min per run.'
                    ELSE N''
                END,
            N'Before (' + CONVERT(nvarchar(10), @pre_qs_count) + N' runs): '
                + ISNULL(CONVERT(nvarchar(10), CONVERT(integer, @pre_q1_pct / 10.0)), N'?') + N'/10 critical stats in first quartile, '
                + ISNULL(CONVERT(nvarchar(10), CONVERT(integer, @pre_completion)), N'?') + N'% completion, '
                + ISNULL(CONVERT(nvarchar(10), CONVERT(integer, @pre_minutes)), N'?') + N' min to critical. '
                + N'After (' + CONVERT(nvarchar(10), @post_qs_count) + N' runs): '
                + ISNULL(CONVERT(nvarchar(10), CONVERT(integer, @post_q1_pct / 10.0)), N'?') + N'/10 critical stats in first quartile, '
                + ISNULL(CONVERT(nvarchar(10), CONVERT(integer, @post_completion)), N'?') + N'% completion, '
                + ISNULL(CONVERT(nvarchar(10), CONVERT(integer, @post_minutes)), N'?') + N' min to critical.',
            N'The switch to Query Store-based prioritization is delivering measurable improvement in how quickly '
                + N'the highest-workload statistics are refreshed. Continue monitoring via @EfficacyDaysBack.',
            N'EXECUTE dbo.sp_StatUpdate_Diag @EfficacyDaysBack = 100;',
            71
        );

        RAISERROR(N'  [INFO] I7: QS inflection detected', 10, 1) WITH NOWAIT;
    END;

    /* ======================================================================
       I8: QS_PERFORMANCE_TREND -- Are queries actually getting faster after stat updates?
       BUG-B fix: Normalize to per-execution CPU (QSTotalCpuMs / QSTotalExecutions).
       Raw QSTotalCpuMs is cumulative from Query Store and always grows as more
       queries execute. Per-execution CPU shows actual plan efficiency changes.
       ====================================================================== */

    /* ------------------------------------------------------------------
       w5p2 / gh-532: Pre-compute data-status so both I8 and RS13 can
       surface a machine-readable explanation instead of silent-empty.
       @i8_qs_cpu_runs  = distinct runs that have any QS CPU data.
       @i8_tracked_stats = stats appearing in 2+ QS-CPU-bearing runs
                           (the same population RS13 / first_last uses).
       @i8_data_status  = AVAILABLE / INSUFFICIENT_HISTORY / UNAVAILABLE.
       ------------------------------------------------------------------ */
    DECLARE
        @i8_qs_cpu_runs     integer = 0,
        @i8_tracked_stats   integer = 0,
        @i8_data_status     nvarchar(30) = N'UNAVAILABLE';

    SELECT @i8_qs_cpu_runs = COUNT(DISTINCT su.RunLabel)
    FROM #stat_updates AS su
    WHERE su.QSTotalCpuMs IS NOT NULL
    AND   su.QSTotalCpuMs > 0
    AND   su.QSTotalExecutions IS NOT NULL
    AND   su.QSTotalExecutions > 0;

    IF @i8_qs_cpu_runs >= 2
    BEGIN
        /* Count stats that appear in 2+ qualifying runs -- same filter as I8 CTE */
        SELECT @i8_tracked_stats = COUNT_BIG(*)
        FROM
        (
            SELECT su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
            FROM #stat_updates AS su
            WHERE su.QSTotalCpuMs IS NOT NULL
            AND   su.QSTotalCpuMs > 0
            AND   su.QSTotalExecutions IS NOT NULL
            AND   su.QSTotalExecutions > 0
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
            GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
            HAVING COUNT_BIG(*) >= 2
        ) AS qualified_stats;

        SET @i8_data_status = CASE
            WHEN @i8_tracked_stats >= 1 THEN N'AVAILABLE'
            ELSE N'INSUFFICIENT_HISTORY'
        END;
    END
    ELSE IF @i8_qs_cpu_runs >= 1
    BEGIN
        SET @i8_data_status = N'INSUFFICIENT_HISTORY';
    END;
    /* else: remains UNAVAILABLE */

    IF EXISTS (
        SELECT 1 FROM #stat_updates
        WHERE QSTotalCpuMs IS NOT NULL AND QSTotalCpuMs > 0
        AND   QSTotalExecutions IS NOT NULL AND QSTotalExecutions > 0
    )
    BEGIN
        DECLARE
            @i8_improving_count integer = 0,
            @i8_degrading_count integer = 0,
            @i8_stable_count integer = 0,
            @i8_regressed_count integer = 0,
            @i8_total_tracked integer = 0,
            @i8_avg_delta_pct decimal(10, 1) = 0,
            @i8_mem_improving integer = 0,
            @i8_mem_degrading integer = 0,
            @i8_mem_tracked integer = 0,
            @i8_mem_avg_delta_pct decimal(10, 1) = 0;

        /* Compare first vs last per-execution CPU for each stat across runs */
        ;WITH stat_appearances AS
        (
            SELECT
                su.DatabaseName,
                su.SchemaName,
                su.ObjectName,
                su.StatisticsName,
                su.QSTotalCpuMs,
                su.QSTotalExecutions,
                /* BUG-B: normalize to per-execution CPU */
                cpu_per_exec = CONVERT(decimal(18, 4), su.QSTotalCpuMs * 1.0 / NULLIF(su.QSTotalExecutions, 0)),
                su.RunLabel,
                r.StartTime,
                appearance_num = ROW_NUMBER() OVER (
                    PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                    ORDER BY r.StartTime
                ),
                appearance_cnt = COUNT_BIG(*) OVER (
                    PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                )
            FROM #stat_updates AS su
            INNER JOIN #runs AS r
                ON r.RunLabel = su.RunLabel
            WHERE su.QSTotalCpuMs IS NOT NULL
            AND   su.QSTotalCpuMs > 0
            AND   su.QSTotalExecutions IS NOT NULL
            AND   su.QSTotalExecutions > 0
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
        ),
        first_last AS
        (
            SELECT
                DatabaseName, SchemaName, ObjectName, StatisticsName,
                first_cpu_per_exec = MAX(CASE WHEN appearance_num = 1 THEN cpu_per_exec END),
                last_cpu_per_exec  = MAX(CASE WHEN appearance_num = appearance_cnt THEN cpu_per_exec END),
                min_cpu_per_exec   = MIN(cpu_per_exec),
                appearances = MAX(appearance_cnt)
            FROM stat_appearances
            WHERE appearance_cnt >= 2
            GROUP BY DatabaseName, SchemaName, ObjectName, StatisticsName
        )
        SELECT
            @i8_total_tracked   = COUNT_BIG(*),
            @i8_improving_count = SUM(CASE WHEN last_cpu_per_exec < first_cpu_per_exec * 0.95 THEN 1 ELSE 0 END),
            @i8_degrading_count = SUM(CASE WHEN last_cpu_per_exec > first_cpu_per_exec * 1.05 THEN 1 ELSE 0 END),
            @i8_stable_count    = SUM(CASE WHEN last_cpu_per_exec BETWEEN first_cpu_per_exec * 0.95 AND first_cpu_per_exec * 1.05 THEN 1 ELSE 0 END),
            /* #276: Detect improve-then-regress: min < first AND last > min (improved at some point, then got worse) */
            @i8_regressed_count = SUM(CASE WHEN appearances >= 3 AND min_cpu_per_exec < first_cpu_per_exec * 0.95 AND last_cpu_per_exec > min_cpu_per_exec * 1.05 THEN 1 ELSE 0 END),
            @i8_avg_delta_pct   = AVG(CASE WHEN first_cpu_per_exec > 0 THEN CONVERT(decimal(10, 1), (last_cpu_per_exec - first_cpu_per_exec) * 100.0 / first_cpu_per_exec) ELSE 0 END)
        FROM first_last;

        /* #368: Memory grant trending (separate query -- only stats with memory data) */
        ;WITH mem_appearances AS
        (
            SELECT
                su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName,
                su.QSTotalMemoryGrantKB,
                mem_rn  = ROW_NUMBER() OVER (
                    PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                    ORDER BY r.StartTime
                ),
                mem_cnt = COUNT_BIG(*) OVER (
                    PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                )
            FROM #stat_updates AS su
            INNER JOIN #runs AS r ON r.RunLabel = su.RunLabel
            WHERE su.QSTotalMemoryGrantKB IS NOT NULL
            AND   su.QSTotalMemoryGrantKB > 0
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
        ),
        mem_first_last AS
        (
            SELECT
                first_mem = MAX(CASE WHEN mem_rn = 1 THEN QSTotalMemoryGrantKB END),
                last_mem  = MAX(CASE WHEN mem_rn = mem_cnt THEN QSTotalMemoryGrantKB END)
            FROM mem_appearances
            WHERE mem_cnt >= 2
            GROUP BY DatabaseName, SchemaName, ObjectName, StatisticsName
        )
        SELECT
            @i8_mem_tracked       = COUNT_BIG(*),
            @i8_mem_improving     = SUM(CASE WHEN last_mem < first_mem * 0.95 THEN 1 ELSE 0 END),
            @i8_mem_degrading     = SUM(CASE WHEN last_mem > first_mem * 1.05 THEN 1 ELSE 0 END),
            @i8_mem_avg_delta_pct = AVG(CASE WHEN first_mem > 0 THEN CONVERT(decimal(10, 1), (last_mem - first_mem) * 100.0 / first_mem) ELSE 0 END)
        FROM mem_first_last;

        IF @i8_total_tracked < 2
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO',
                N'QS_PERFORMANCE_TREND',
                N'Insufficient data for per-execution CPU trend analysis. Need 2+ statistics appearing in 2+ runs with Query Store data.'
                    + CASE
                        WHEN (SELECT COUNT(DISTINCT su2.RunLabel) FROM #stat_updates AS su2 WHERE su2.QSTotalCpuMs IS NOT NULL AND su2.QSTotalCpuMs > 0) < 2
                        THEN N' Only ' + CONVERT(nvarchar(10), (SELECT COUNT(DISTINCT su2.RunLabel) FROM #stat_updates AS su2 WHERE su2.QSTotalCpuMs IS NOT NULL AND su2.QSTotalCpuMs > 0)) + N' QS-enabled run(s) found; need 2+ for comparison.'
                        ELSE N' QS data exists across runs, but individual stats appear only once each.'
                    END
                    /* w5p2 / gh-532: machine-readable DataStatus suffix */
                    + N' [DataStatus: ' + @i8_data_status
                        + N'; QSCpuRuns: ' + CONVERT(nvarchar(10), @i8_qs_cpu_runs)
                        + N'; TrackedStats: ' + CONVERT(nvarchar(10), @i8_tracked_stats)
                        + N']',
                N'Tracked ' + CONVERT(nvarchar(10), @i8_total_tracked) + N' statistics with 2+ appearances. At least 2 are needed for trend analysis.',
                N'Run sp_StatUpdate with @QueryStore = N''CPU'' (v3) across multiple maintenance windows to build up comparison data.',
                N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @QueryStore = N''CPU'';',
                73
            );

            RAISERROR(N'  [INFO] I8: insufficient data for QS performance trend (%i stats tracked)', 10, 1, @i8_total_tracked) WITH NOWAIT;
        END
        ELSE
        BEGIN
            /* #292: Count forced plans on objects with degrading CPU trend */
            DECLARE @i8_forced_at_risk integer = ISNULL((
                SELECT SUM(fp.ForcedPlanCount)
                FROM #forced_plans AS fp
                WHERE EXISTS (
                    SELECT 1
                    FROM #stat_updates AS su
                    WHERE su.DatabaseName = fp.DatabaseName
                    AND   su.ObjectName = fp.ObjectName
                    AND   su.QSTotalCpuMs IS NOT NULL
                    AND   su.QSTotalCpuMs > 0
                )
            ), 0);

            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES
            (
                N'INFO',
                N'QS_PERFORMANCE_TREND',
                CASE
                    WHEN @i8_improving_count > @i8_degrading_count AND @i8_avg_delta_pct < -5
                    THEN N'Per-execution query CPU improving after stat updates: '
                        + CONVERT(nvarchar(10), @i8_improving_count) + N' of ' + CONVERT(nvarchar(10), @i8_total_tracked)
                        + N' tracked statistics show lower per-execution CPU (avg '
                        + CONVERT(nvarchar(20), ABS(@i8_avg_delta_pct)) + N'% reduction).'
                        + CASE WHEN @i8_mem_tracked >= 2 AND @i8_mem_improving > @i8_mem_degrading
                            THEN N' Memory grants also improved for '
                                + CONVERT(nvarchar(10), @i8_mem_improving) + N' of ' + CONVERT(nvarchar(10), @i8_mem_tracked)
                                + N' tracked statistics (avg ' + CONVERT(nvarchar(20), ABS(@i8_mem_avg_delta_pct)) + N'% reduction).'
                            WHEN @i8_mem_tracked >= 2 AND @i8_mem_degrading > @i8_mem_improving
                            THEN N' However, memory grants degraded for '
                                + CONVERT(nvarchar(10), @i8_mem_degrading) + N' of ' + CONVERT(nvarchar(10), @i8_mem_tracked)
                                + N' tracked statistics despite CPU improvement.'
                            ELSE N''
                        END
                    /* #276: Improve-then-regress pattern -- CPU improved at some point but regressed back */
                    WHEN @i8_regressed_count > 0 AND @i8_regressed_count >= @i8_degrading_count
                    THEN N'Per-execution query CPU improved then regressed: '
                        + CONVERT(nvarchar(10), @i8_regressed_count) + N' of ' + CONVERT(nvarchar(10), @i8_total_tracked)
                        + N' tracked statistics showed CPU improvement at mid-window but have since regressed.'
                        + CASE WHEN @i8_forced_at_risk > 0
                            THEN N' WARNING: ' + CONVERT(nvarchar(10), @i8_forced_at_risk) + N' forced plan(s) exist on affected tables.'
                            ELSE N''
                        END
                    WHEN @i8_degrading_count > @i8_improving_count
                    THEN N'Per-execution query CPU not improving: '
                        + CONVERT(nvarchar(10), @i8_degrading_count) + N' of ' + CONVERT(nvarchar(10), @i8_total_tracked)
                        + N' tracked statistics show higher per-execution CPU (avg '
                        + CONVERT(nvarchar(20), @i8_avg_delta_pct) + N'% change).'
                        + CASE WHEN @i8_forced_at_risk > 0
                            THEN N' WARNING: ' + CONVERT(nvarchar(10), @i8_forced_at_risk) + N' forced plan(s) exist on affected tables -- stat updates may have triggered forced plan abandonment.'
                            ELSE N''
                        END
                    ELSE N'Per-execution query CPU stable across updates: '
                        + CONVERT(nvarchar(10), @i8_stable_count) + N' of ' + CONVERT(nvarchar(10), @i8_total_tracked)
                        + N' tracked statistics show consistent per-execution CPU. '
                        + CONVERT(nvarchar(10), @i8_improving_count) + N' improving, '
                        + CONVERT(nvarchar(10), @i8_degrading_count) + N' degrading.'
                END,
                N'Tracked ' + CONVERT(nvarchar(10), @i8_total_tracked)
                    + N' statistics appearing in 2+ runs (per-execution CPU). Improving: ' + CONVERT(nvarchar(10), @i8_improving_count)
                    + N'. Stable: ' + CONVERT(nvarchar(10), @i8_stable_count)
                    + N'. Degrading: ' + CONVERT(nvarchar(10), @i8_degrading_count)
                    + CASE WHEN @i8_regressed_count > 0
                        THEN N'. Improved-then-regressed: ' + CONVERT(nvarchar(10), @i8_regressed_count)
                        ELSE N''
                    END
                    + N'. Avg per-exec CPU change: ' + CONVERT(nvarchar(20), @i8_avg_delta_pct) + N'%.'
                    + CASE WHEN @i8_forced_at_risk > 0
                        THEN N' Forced plans at risk: ' + CONVERT(nvarchar(10), @i8_forced_at_risk) + N'.'
                        ELSE N''
                    END
                    + CASE WHEN @i8_mem_tracked >= 2
                        THEN N' Memory grant tracking: ' + CONVERT(nvarchar(10), @i8_mem_tracked)
                            + N' stats, improving: ' + CONVERT(nvarchar(10), @i8_mem_improving)
                            + N', degrading: ' + CONVERT(nvarchar(10), @i8_mem_degrading)
                            + N', avg change: ' + CONVERT(nvarchar(20), @i8_mem_avg_delta_pct) + N'%.'
                        ELSE N''
                    END,
                CASE
                    WHEN @i8_improving_count > @i8_degrading_count
                    THEN N'Statistics maintenance is contributing to query performance improvements. The stat updates are helping the optimizer choose better plans.'
                    WHEN @i8_regressed_count > 0 AND @i8_regressed_count >= @i8_degrading_count
                    THEN N'Some statistics improved then regressed -- possible external workload shift, schema change, or parameter sniffing. '
                        + N'Check RS 13 for specific stats and correlate with deployment or workload changes.'
                    WHEN @i8_degrading_count > @i8_improving_count AND @i8_forced_at_risk > 0
                    THEN N'CRITICAL: Forced plans on degrading tables may have been invalidated by stat updates. '
                        + N'Check sys.query_store_plan for is_forced_plan=1 with force_failure_count > 0. '
                        + N'A forced plan that fails reverts to optimizer choice -- often a regression.'
                    WHEN @i8_degrading_count > @i8_improving_count
                    THEN N'Stat updates are not correlating with improved query performance. Check for plan regressions, forced plans, or parameter sensitivity.'
                    ELSE N'Stat updates are maintaining stable query performance. This is expected for well-maintained databases.'
                END,
                N'EXECUTE dbo.sp_StatUpdate_Diag @ExpertMode = 1; /* RS13 shows per-stat detail */',
                72
            );

            RAISERROR(N'  [INFO] I8: QS performance trend computed', 10, 1) WITH NOWAIT;
        END;
    END
    ELSE
    BEGIN
        /* #239: No QS CPU data at all -- explain why I8/RS13 are empty instead of silent skip. */
        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        VALUES (
            N'INFO', N'QS_PERFORMANCE_TREND',
            /* w5p2 / gh-532: preserve existing text; append machine-readable DataStatus suffix */
            N'No Query Store CPU data found in any run. RS 13 (QS Performance Correlation) will be empty.'
                + N' [DataStatus: ' + @i8_data_status
                + N'; QSCpuRuns: ' + CONVERT(nvarchar(10), @i8_qs_cpu_runs)
                + N'; TrackedStats: ' + CONVERT(nvarchar(10), @i8_tracked_stats)
                + N']',
            N'0 of ' + CONVERT(nvarchar(10), (SELECT COUNT(*) FROM #runs))
                + N' runs contained Query Store CPU metrics. Ensure QS prioritization is configured (@QueryStore = N''CPU'' in v3) and Query Store is enabled/READ_WRITE.',
            N'Enable QS prioritization: EXEC sp_StatUpdate @QueryStore = N''CPU''.',
            N'EXECUTE dbo.sp_StatUpdate @Databases = N''USER_DATABASES'', @QueryStore = N''CPU'';',
            73
        );
        RAISERROR(N'  [INFO] I8: no Query Store CPU data available', 10, 1) WITH NOWAIT;
    END;

    /* ======================================================================
       I10: RECOMMENDED CONFIGURATION -- Synthesize a single parameter set
       based on diagnostic findings, parameter history, and safeguards.
       Baseline: latest completed (non-killed) run.  Adjustments driven by
       which checks fired (C1-C4, W1-W6).  Safeguards from any historical
       run are preserved even if dropped in the latest run.
       ====================================================================== */
    RAISERROR(N'Building recommended configuration (I10)...', 10, 1) WITH NOWAIT;

    BEGIN
        /* ---- Baseline: latest completed (non-killed) run ---- */
        DECLARE @rc_baseline nvarchar(100) = (
            SELECT TOP (1) RunLabel
            FROM #runs
            WHERE IsKilled = 0
            ORDER BY StartTime DESC
        );

        /* Fall back to latest run if every run was killed */
        IF @rc_baseline IS NULL
            SET @rc_baseline = (SELECT TOP (1) RunLabel FROM #runs ORDER BY StartTime DESC);

        IF @rc_baseline IS NOT NULL
        BEGIN
            DECLARE
                @rc_databases       nvarchar(max),
                @rc_timelimit       integer,
                @rc_sort            nvarchar(50),
                @rc_qs_pri          nvarchar(1),
                @rc_mod_thresh      bigint,
                @rc_long_min        integer,
                @rc_long_pct        integer,
                @rc_parallel        nvarchar(1),
                @rc_fail_fast       bit,
                /* sp_StatUpdate-6x80: widened from nvarchar(1000) to nvarchar(max) to
                   accommodate @CriticalTables hint which can carry multiple table names */
                @rc_call            nvarchar(max),
                @rc_rationale       nvarchar(2000) = N'',
                @rc_safeguards      nvarchar(500);

            SELECT
                @rc_databases     = ISNULL([Databases], N'USER_DATABASES'),
                @rc_timelimit     = TimeLimit,
                @rc_sort          = SortOrder,
                @rc_qs_pri        = QueryStorePriority,
                @rc_mod_thresh    = ModificationThreshold,
                @rc_long_min      = LongRunningThresholdMinutes,
                @rc_long_pct      = LongRunningSamplePercent,
                @rc_parallel      = StatsInParallel,
                @rc_fail_fast     = FailFast
            FROM #runs
            WHERE RunLabel = @rc_baseline;

            /* sp_StatUpdate-6x80: TimeLimit jitter normalization.
               When @StopByTime is used, each run derives its TimeLimit from
               DATEDIFF(SECOND, start_time, stop_by_time), so a job that starts
               at 23:00:01 vs 23:00:02 yields 21599 vs 21598 instead of 21600.
               If the spread across recent non-killed runs with non-NULL TimeLimit
               is < 300 s (5 min), round to the nearest minute to produce a clean
               value (e.g. 21600 instead of 21599). */
            DECLARE @rc_tl_spread integer = (
                SELECT MAX(TimeLimit) - MIN(TimeLimit)
                FROM #runs
                WHERE IsKilled = 0 AND TimeLimit IS NOT NULL
            );
            IF @rc_tl_spread IS NOT NULL AND @rc_tl_spread < 300
                SET @rc_timelimit = CONVERT(integer, ROUND(
                    (SELECT AVG(CONVERT(decimal(12, 2), TimeLimit))
                     FROM #runs WHERE IsKilled = 0 AND TimeLimit IS NOT NULL)
                    / 60.0, 0) * 60);

            /* ---- Adjust based on fired checks ---- */

            /* C3: Time limit exhaustion -- increase if short */
            IF EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'TIME_LIMIT_EXHAUSTION')
            BEGIN
                IF @rc_timelimit IS NULL OR @rc_timelimit < 3600
                    SET @rc_timelimit = 18000;
                ELSE IF @rc_timelimit < 18000
                    SET @rc_timelimit = CASE
                        WHEN @rc_timelimit * 2 > 28800 THEN 28800
                        ELSE @rc_timelimit * 2
                    END;
                SET @rc_rationale += N'TimeLimit adjusted (C3: time-limit exhaustion). ';
            END;

            /* Ensure a sane minimum time limit even without C3 */
            IF @rc_timelimit IS NOT NULL AND @rc_timelimit < 3600
            BEGIN
                SET @rc_timelimit = 18000;
                SET @rc_rationale += N'TimeLimit raised from <1h to 5h (too short for workload). ';
            END;

            /* sp_StatUpdate-6x80: W5-conditional QS drop.
               Only revert @SortOrder and clear @QueryStore when W5 fired due to
               genuine QS absence (QS_NOT_EFFECTIVE category).  When W5 fired as
               a parallel-ordering artifact (QS_PARALLEL_UNRELIABLE category),
               QS CPU data WAS observed so keeping @SortOrder=QUERY_STORE is
               correct -- the mhje fix (v3.5.4) corrected TablePriority ordering
               so the root cause is already resolved on the proc side. */
            IF EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'QS_NOT_EFFECTIVE')
            BEGIN
                /* True QS absence: revert sort and disable QS */
                SET @rc_sort   = N'MODIFICATION_COUNTER';
                SET @rc_qs_pri = N'N';
                SET @rc_rationale += N'QS disabled (W5: no QS data captured). ';
            END
            ELSE IF EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'QS_PARALLEL_UNRELIABLE')
            BEGIN
                /* Parallel artifact only -- keep QS, note that mhje fix applies */
                SET @rc_rationale += N'QS kept (W5 was parallel artifact -- v3.5.4 TablePriority fix applies). ';
            END;

            /* W1a: Always recommend tiered thresholds */
            /* (no variable needed -- hardcoded as 1 in output) */

            /* W2: Long-running stats -- tighten adaptive sampling */
            IF EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'LONG_RUNNING_STATS')
            BEGIN
                SET @rc_long_min = CASE
                    WHEN @rc_long_min IS NULL THEN 10
                    WHEN @rc_long_min > 10    THEN 10
                    ELSE @rc_long_min
                END;

                /* 5% for 100M+ row tables, 10% otherwise */
                IF EXISTS (
                    SELECT 1 FROM #stat_updates
                    WHERE DurationMs > @LongRunningMinutes * 60 * 1000
                    AND   ErrorNumber = 0
                    AND   RowCount_ > 100000000
                )
                    SET @rc_long_pct = 5;
                ELSE
                    SET @rc_long_pct = ISNULL(@rc_long_pct, 10);

                SET @rc_rationale += N'Adaptive sampling tightened to '
                    + CONVERT(nvarchar(10), @rc_long_min) + N'min/'
                    + CONVERT(nvarchar(10), @rc_long_pct) + N'% (W2: slow stats). ';
            END
            ELSE IF @rc_long_min IS NULL
            BEGIN
                /* Preventive: suggest enabling even without current slow stats */
                SET @rc_long_min = 15;
                SET @rc_long_pct = ISNULL(@rc_long_pct, 10);
            END;

            /* W3: Stale backlog -- suggest parallel if not already on */
            IF EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'STALE_BACKLOG')
            AND ISNULL(@rc_parallel, N'N') = N'N'
            BEGIN
                SET @rc_parallel = N'Y';
                SET @rc_rationale += N'Parallel enabled (W3: persistent backlog). ';
            END;

            /* ---- Build the EXEC call ---- */
            /*
            Note: I10 generates a v3-compatible call.  v3 removed several v2 public params
            (@TieredThresholds, @CleanupOrphanedRuns, @GroupByJoinPattern, @FilteredStatsMode,
            @QueryStorePriority/@QueryStoreMetric).  Tiered thresholds are always on in v3.
            Orphan cleanup is always on internally.  QS is enabled via @QueryStore = N'CPU'.
            FilteredStatsMode and GroupByJoinPattern have no v3 equivalents.
            */
            SET @rc_call = N'EXECUTE dbo.sp_StatUpdate'
                + NCHAR(13) + NCHAR(10) + N'    @Databases = N''' + @rc_databases + N''''
                + NCHAR(13) + NCHAR(10) + N'  , @TimeLimit = ' + CONVERT(nvarchar(10), ISNULL(@rc_timelimit, 18000))
                + NCHAR(13) + NCHAR(10) + N'  , @SortOrder = N''' + ISNULL(@rc_sort, N'MODIFICATION_COUNTER') + N''''
                + NCHAR(13) + NCHAR(10) + N'  , @ModificationThreshold = ' + CONVERT(nvarchar(20), ISNULL(@rc_mod_thresh, 5000));

            /* v3: QS enabled via @QueryStore = metric name (replaces v2 @QueryStorePriority + @QueryStoreMetric) */
            IF ISNULL(@rc_qs_pri, N'N') = N'Y'
                SET @rc_call += NCHAR(13) + NCHAR(10) + N'  , @QueryStore = N''CPU''';

            IF @rc_long_min IS NOT NULL
                SET @rc_call += NCHAR(13) + NCHAR(10) + N'  , @LongRunningThresholdMinutes = ' + CONVERT(nvarchar(10), @rc_long_min)
                    + NCHAR(13) + NCHAR(10) + N'  , @LongRunningSamplePercent = ' + CONVERT(nvarchar(10), ISNULL(@rc_long_pct, 10));

            IF ISNULL(@rc_parallel, N'N') = N'Y'
                SET @rc_call += NCHAR(13) + NCHAR(10) + N'  , @StatsInParallel = N''Y''';

            /* Add @MopUpPass if runs consistently complete early and it's not already enabled */
            IF EXISTS (
                SELECT 1 FROM #recommendations
                WHERE Category = N'UNUSED_FEATURES'
                AND   Finding LIKE N'%mop-up%'
            )
            AND ISNULL(@rc_parallel, N'N') = N'N'
                SET @rc_call += NCHAR(13) + NCHAR(10) + N'  , @MopUpPass = N''Y''';

            /* sp_StatUpdate-6x80: @CriticalTables hint.
               When W9 LOCK_TIMEOUT_INEFFECTIVE has fired, the contended tables
               are strong @CriticalTables candidates (per-table sample-rate
               override + priority boost in v3.5.0+).  Append a commented-out
               suggestion with the top 3 most-blocked tables so the operator can
               uncomment and tune.  Uses the same lock_timeouts CTE logic as W9
               but limited to top 3 tables ordered by hit count.
               Assumption: schema.table granularity is sufficient (stat names
               are omitted since @CriticalTables accepts table patterns). */
            IF EXISTS (SELECT 1 FROM #recommendations WHERE Category = N'LOCK_TIMEOUT_INEFFECTIVE')
            BEGIN
                DECLARE @rc_critical_tables nvarchar(500) = STUFF((
                    SELECT TOP (3) N', ' + su.SchemaName + N'.' + su.ObjectName
                    FROM (
                        SELECT su2.SchemaName, su2.ObjectName,
                               hit_count = COUNT(DISTINCT su2.RunLabel)
                        FROM #stat_updates AS su2
                        WHERE su2.ErrorNumber = 1222
                        GROUP BY su2.SchemaName, su2.ObjectName
                        HAVING COUNT(DISTINCT su2.RunLabel) >= 3
                    ) AS su
                    ORDER BY su.hit_count DESC
                    FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N'');

                IF @rc_critical_tables IS NOT NULL
                    SET @rc_call += NCHAR(13) + NCHAR(10)
                        + N'  /* Suggested (W9 lock contention -- uncomment and tune):'
                        + NCHAR(13) + NCHAR(10)
                        + N'  , @CriticalTables = N''' + @rc_critical_tables + N''''
                        + NCHAR(13) + NCHAR(10)
                        + N'  */'
                        ;
            END;

            SET @rc_call += N';';

            /* ---- Safeguard parameters (not tracked in CommandLog) ---- */
            SET @rc_safeguards = N'Also consider safeguards not tracked in CommandLog: @MinTempdbFreeMB = 500, @MaxConsecutiveFailures = 5';

            IF @ag_replica_role = N'PRIMARY'
                SET @rc_safeguards += N', @MaxAGRedoQueueMB = 1024';

            SET @rc_safeguards += N'.';

            /* ---- Insert the recommendation ---- */
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            VALUES (
                N'INFO',
                N'RECOMMENDED_CONFIG',
                N'Recommended parameter set based on ' + CONVERT(nvarchar(10), (SELECT COUNT(*) FROM #runs))
                    + N' run(s) and ' + CONVERT(nvarchar(10), (SELECT COUNT(*) FROM #recommendations))
                    + N' diagnostic finding(s)',
                LEFT(@rc_rationale + @rc_safeguards, 2000),
                N'Balanced configuration: preserves safeguards from prior runs, adjusts parameters flagged by diagnostics, and applies best-practice defaults.  Review @TimeLimit for your maintenance window.',
                @rc_call,
                5
            );

            RAISERROR(N'  [INFO] I10: Recommended configuration built', 10, 1) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W14: RECURRING SAFETY STOPS (4g9s)
       Fires when the same safety-stop StopReason appears in >= 2 runs.
       Safety StopReasons: TEMPDB_PRESSURE, AG_REDO_QUEUE, LOG_SPACE_HIGH,
       IO_CORRUPTION, FAIL_FAST, CONSECUTIVE_FAILURES.
       Each repeated reason produces one finding row.  Evidence lists up to
       10 most-recent run StartTimes (mirrors C1 evidence-cap convention).
       ====================================================================== */
    IF @run_count >= 2
    BEGIN
        DECLARE @w14_safety_reasons TABLE
        (
            StopReason   nvarchar(50)    NOT NULL,
            HitCount     integer         NOT NULL,
            MostRecent   datetime2(3)    NULL,
            EvidenceList nvarchar(2000)  NULL
        );

        INSERT INTO @w14_safety_reasons (StopReason, HitCount, MostRecent, EvidenceList)
        SELECT
            r.StopReason,
            HitCount    = COUNT_BIG(*),
            MostRecent  = MAX(r.StartTime),
            EvidenceList = CASE
                WHEN COUNT_BIG(*) > 10
                THEN N'(' + CONVERT(nvarchar(10), COUNT_BIG(*)) + N' occurrences, 10 most recent): '
                     + STUFF((
                         SELECT TOP (10) N', ' + CONVERT(nvarchar(30), r2.StartTime, 120)
                         FROM #runs AS r2
                         WHERE r2.StopReason = r.StopReason
                           AND r2.IsKilled = 0
                         ORDER BY r2.StartTime DESC
                         FOR XML PATH(N'')
                       ), 1, 2, N'')
                ELSE STUFF((
                         SELECT TOP (10) N', ' + CONVERT(nvarchar(30), r2.StartTime, 120)
                         FROM #runs AS r2
                         WHERE r2.StopReason = r.StopReason
                           AND r2.IsKilled = 0
                         ORDER BY r2.StartTime DESC
                         FOR XML PATH(N'')
                       ), 1, 2, N'')
                END
        FROM #runs AS r
        WHERE r.IsKilled = 0
          AND r.StopReason IN (
                N'TEMPDB_PRESSURE', N'AG_REDO_QUEUE', N'LOG_SPACE_HIGH',
                N'IO_CORRUPTION', N'FAIL_FAST', N'CONSECUTIVE_FAILURES', N'BATCH_LIMIT'
              )
        GROUP BY r.StopReason
        HAVING COUNT_BIG(*) >= 2;

        IF EXISTS (SELECT 1 FROM @w14_safety_reasons)
        BEGIN
            INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
            SELECT
                N'WARNING',
                N'RECURRING_SAFETY_STOP',
                N'Safety stop ''' + w.StopReason + N''' in ' + CONVERT(nvarchar(10), w.HitCount) + N' of '
                    + CONVERT(nvarchar(10), @run_count) + N' runs in the last '
                    + CONVERT(nvarchar(10), @DaysBack) + N' days',
                w.EvidenceList,
                CASE w.StopReason
                    WHEN N'TEMPDB_PRESSURE'       THEN N'tempdb free space fell below @MinTempdbFreeMB threshold repeatedly. Expand tempdb data files or increase @MinTempdbFreeMB to detect pressure earlier. CHECKDB tempdb for corruption.'
                    WHEN N'AG_REDO_QUEUE'         THEN N'AG secondary redo queue exceeded @MaxAGRedoQueueMB. Investigate AG latency, network throughput, or secondary IO. Consider increasing @MaxAGWaitMinutes or reducing @MaxAGRedoQueueMB to match actual redo capacity.'
                    WHEN N'LOG_SPACE_HIGH'        THEN N'Transaction log space fell below threshold during maintenance. Expand log file or add log backup frequency. Ensure log backup job is not blocked during maintenance window.'
                    WHEN N'IO_CORRUPTION'         THEN N'UPDATE STATISTICS triggered IO integrity errors. Run DBCC CHECKDB immediately on affected databases. Do not re-enable stats maintenance until corruption is resolved.'
                    WHEN N'FAIL_FAST'             THEN N'@FailFast=1 aborted on repeated errors. Investigate ErrorNumber distribution in RS6 Failing Statistics. Consider lowering @FailFast threshold or disabling for non-critical workloads.'
                    WHEN N'CONSECUTIVE_FAILURES'  THEN N'Run aborted after N consecutive stat failures (@MaxConsecutiveFailures). Check RS6 for error clustering. Investigate lock contention (error 1222), permission issues (error 262), or transient IO errors.'
                    WHEN N'BATCH_LIMIT'           THEN N'@BatchLimit cap reached repeatedly. Consider increasing @BatchLimit or switching to time-based limiting via @TimeLimit.'
                    ELSE N'Investigate root cause of repeated ' + w.StopReason + N' safety stops.'
                END,
                NULL,
                32
            FROM @w14_safety_reasons AS w;

            DECLARE @w14_count integer = (SELECT COUNT_BIG(*) FROM @w14_safety_reasons);
            RAISERROR(N'  [WARNING] W14: %i recurring safety stop reason(s) detected', 10, 1, @w14_count) WITH NOWAIT;
        END;
    END;

    /* ======================================================================
       W15 / I16: RECURRING RUNTIME WARNINGS (t8lj)

       Ingests WarningsCodes from END Summary XML (pipe-delimited tokens,
       v3.5.9+).  Splits codes, counts frequency across non-killed runs.

       Threshold: fires when a code appears in >= 3 runs OR >= 50% of
       non-killed runs (whichever is smaller), minimum 2 occurrences.

       Severity tiering:
         WARNING (W15) -- environmental/actionable codes that indicate
           operational problems the DBA can address.
         INFO    (I16) -- purely informational codes that are useful for
           context but do not require immediate action.

       Old runs without WarningsCodes element produce zero findings.
       ====================================================================== */
    DECLARE @w15_non_killed_runs integer = (SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 0);
    DECLARE @w15_coded_runs integer = (SELECT COUNT_BIG(*) FROM #runs WHERE IsKilled = 0 AND WarningsCodes IS NOT NULL);

    IF @w15_coded_runs >= 2   /* at least 2 non-killed runs have the element */
    BEGIN
        /* Threshold: fires when count >= 3 OR >= 50% of non-killed runs, min 2 */
        DECLARE @w15_freq_threshold integer = CASE
            WHEN @w15_non_killed_runs > 0
            THEN CASE
                     WHEN CONVERT(decimal(5,1), @w15_non_killed_runs * 0.5) < 3
                     THEN 2   /* small window: use 2 (minimum) */
                     ELSE 3   /* otherwise use 3 */
                 END
            ELSE 2
        END;

        DECLARE @w15_pct_threshold decimal(5,1) = 50.0;

        /* Build code-frequency table */
        DECLARE @warning_code_freq TABLE
        (
            WarningCode   nvarchar(100)   NOT NULL,
            HitCount      integer         NOT NULL,
            HitPct        decimal(5,1)    NOT NULL
        );

        INSERT INTO @warning_code_freq (WarningCode, HitCount, HitPct)
        SELECT
            codes.value,
            HitCount = COUNT_BIG(DISTINCT r.RunLabel),
            HitPct   = CONVERT(decimal(5,1), COUNT_BIG(DISTINCT r.RunLabel) * 100.0 / NULLIF(@w15_non_killed_runs, 0))
        FROM #runs AS r
        CROSS APPLY STRING_SPLIT(r.WarningsCodes, N'|') AS codes
        WHERE r.IsKilled = 0
          AND r.WarningsCodes IS NOT NULL
          AND LTRIM(RTRIM(codes.value)) <> N''
        GROUP BY codes.value
        HAVING COUNT_BIG(DISTINCT r.RunLabel) >= @w15_freq_threshold
            OR CONVERT(decimal(5,1), COUNT_BIG(DISTINCT r.RunLabel) * 100.0 / NULLIF(@w15_non_killed_runs, 0)) >= @w15_pct_threshold;

        /* W15: environmental/actionable codes */
        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        SELECT
            N'WARNING',
            N'RECURRING_RUNTIME_WARNING',
            wc.WarningCode + N' in ' + CONVERT(nvarchar(10), wc.HitCount) + N' of ' + CONVERT(nvarchar(10), @w15_non_killed_runs) + N' runs -- '
                + CASE wc.WarningCode
                    WHEN N'BACKUP_RUNNING'              THEN N'maintenance window overlaps backups'
                    WHEN N'BACKUP_STARTED_MID_RUN'      THEN N'backup started while stats maintenance was running'
                    WHEN N'LOG_SPACE_HIGH'              THEN N'log space consistently low during maintenance'
                    WHEN N'CONTAINER_MEMORY'            THEN N'container memory pressure during maintenance'
                    WHEN N'RCSI_VERSION_STORE'          THEN N'RCSI version store pressure during maintenance'
                    WHEN N'ELASTIC_POOL'                THEN N'elastic pool DTU/eDTU pressure during maintenance'
                    WHEN N'PEAK_HOURS'                  THEN N'maintenance running during identified peak hours'
                    WHEN N'IO_CORRUPTION'               THEN N'IO integrity errors detected during maintenance'
                    WHEN N'STOPBYTIME_OVERSHOOT'        THEN N'@StopByTime deadline repeatedly overshot'
                    WHEN N'CONSECUTIVE_FAILURES_ELEVATED' THEN N'elevated consecutive failure rate'
                    WHEN N'PERSIST_SAMPLE_INADEQUATE'   THEN N'PERSIST_SAMPLE_PERCENT too low for workload'
                    WHEN N'PARALLEL_ORPHAN_BACKLOG'     THEN N'orphaned parallel worker entries accumulating'
                    WHEN N'STALE_QUEUE_SWEEP'           THEN N'stale queue entries swept on each run'
                    WHEN N'DB_SKIPPED'                  THEN N'one or more databases skipped repeatedly'
                    ELSE wc.WarningCode + N' recurring'
                  END,
            N'Code ' + wc.WarningCode + N' appeared in ' + CONVERT(nvarchar(10), wc.HitCount) + N' run(s) ('
                + CONVERT(nvarchar(10), CONVERT(integer, wc.HitPct)) + N'%).',
            CASE wc.WarningCode
                    WHEN N'BACKUP_RUNNING'              THEN N'Adjust your maintenance window to avoid backup overlap. Check msdb job schedules.'
                    WHEN N'BACKUP_STARTED_MID_RUN'      THEN N'Reorder Agent jobs so backups start after maintenance completes, or extend @TimeLimit to finish before backup window.'
                    WHEN N'LOG_SPACE_HIGH'              THEN N'Increase log file autogrowth, add more frequent log backups, or reduce @TimeLimit so maintenance ends earlier.'
                    WHEN N'CONTAINER_MEMORY'            THEN N'Increase container memory limits or reduce @MaxDOP to lower per-query memory grant.'
                    WHEN N'RCSI_VERSION_STORE'          THEN N'Long-running transactions may be holding the version store open. Check sys.dm_tran_active_snapshot_database_transactions.'
                    WHEN N'ELASTIC_POOL'                THEN N'Schedule maintenance during elastic pool low-activity periods, or move the database to a higher-tier pool.'
                    WHEN N'PEAK_HOURS'                  THEN N'Reschedule maintenance outside peak hours. Use @StopByTime to enforce a hard deadline.'
                    WHEN N'IO_CORRUPTION'               THEN N'Run DBCC CHECKDB immediately. Do not re-enable stats maintenance until corruption is resolved.'
                    WHEN N'STOPBYTIME_OVERSHOOT'        THEN N'The run consistently exceeds @StopByTime. Set @TimeLimit to a value shorter than the overshoot margin.'
                    WHEN N'CONSECUTIVE_FAILURES_ELEVATED' THEN N'Check RS6 Failing Statistics for error clustering. Reduce @MaxConsecutiveFailures or investigate lock/permission issues.'
                    WHEN N'PERSIST_SAMPLE_INADEQUATE'   THEN N'Increase @StatisticsSample or use FULLSCAN for high-volatility tables flagged in RS5 Top Tables.'
                    WHEN N'PARALLEL_ORPHAN_BACKLOG'     THEN N'Run sp_StatUpdate with @CleanupOrphanedRuns=Y or manually delete stale QueueStatistic entries.'
                    WHEN N'STALE_QUEUE_SWEEP'           THEN N'Stale queue entries from prior killed runs accumulate. Ensure @CleanupOrphanedRuns=Y runs between parallel jobs.'
                    WHEN N'DB_SKIPPED'                  THEN N'Check @Databases filter and verify all target databases are accessible (HAS_DBACCESS).'
                    ELSE N'Investigate root cause of recurring code ' + wc.WarningCode + N'.'
                  END,
            NULL,
            33
        FROM @warning_code_freq AS wc
        WHERE wc.WarningCode IN (
            N'BACKUP_RUNNING', N'BACKUP_STARTED_MID_RUN', N'LOG_SPACE_HIGH',
            N'CONTAINER_MEMORY', N'RCSI_VERSION_STORE', N'ELASTIC_POOL',
            N'PEAK_HOURS', N'IO_CORRUPTION', N'STOPBYTIME_OVERSHOOT',
            N'CONSECUTIVE_FAILURES_ELEVATED', N'PERSIST_SAMPLE_INADEQUATE',
            N'PARALLEL_ORPHAN_BACKLOG', N'STALE_QUEUE_SWEEP', N'DB_SKIPPED'
        );

        DECLARE @w15_fires integer = @@ROWCOUNT;
        IF @w15_fires > 0
            RAISERROR(N'  [WARNING] W15: %i recurring environmental warning code(s) detected', 10, 1, @w15_fires) WITH NOWAIT;

        /* I16: informational codes */
        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        SELECT
            N'INFO',
            N'RECURRING_RUNTIME_WARNING',
            wc.WarningCode + N' in ' + CONVERT(nvarchar(10), wc.HitCount) + N' of ' + CONVERT(nvarchar(10), @w15_non_killed_runs) + N' runs -- '
                + CASE wc.WarningCode
                    WHEN N'CDC_TABLES'                  THEN N'CDC-tracked tables encountered (FULLSCAN advisory applied)'
                    WHEN N'REPLICATION_MAJORITY'        THEN N'majority of target tables are replicated'
                    WHEN N'COLUMNSTORE_TABLES'          THEN N'columnstore tables present (modification_counter underreporting possible)'
                    WHEN N'RLS_DETECTED'                THEN N'Row Level Security active on target tables (histogram bias risk)'
                    WHEN N'FILTER_MISMATCH'             THEN N'filtered stats with filter/index mismatch detected'
                    WHEN N'CASE_SENSITIVE_COLLATION'    THEN N'case-sensitive collation on instance'
                    WHEN N'AZURE_SQL_DB'                THEN N'running on Azure SQL DB'
                    WHEN N'AZURE_SQL_MI'                THEN N'running on Azure SQL MI'
                    WHEN N'AZURE_SQL_EDGE'              THEN N'running on Azure SQL Edge'
                    WHEN N'LOW_UPTIME'                  THEN N'server uptime low when maintenance ran'
                    WHEN N'TOCTOU_SKIPS'                THEN N'TOCTOU (time-of-check-to-time-of-use) skips logged'
                    WHEN N'EMPTY_STRING_PARAM'          THEN N'one or more parameters passed as empty string instead of NULL'
                    WHEN N'DEAD_WORKER_TIMEOUT_NULL_COERCED' THEN N'@DeadWorkerTimeoutMinutes coerced from NULL to default'
                    ELSE wc.WarningCode + N' recurring (informational)'
                  END,
            N'Code ' + wc.WarningCode + N' appeared in ' + CONVERT(nvarchar(10), wc.HitCount) + N' run(s) ('
                + CONVERT(nvarchar(10), CONVERT(integer, wc.HitPct)) + N'%).',
            CASE wc.WarningCode
                    WHEN N'CDC_TABLES'                  THEN N'sp_StatUpdate applies FULLSCAN for CDC-tracked tables to avoid biased histograms. No action required unless CDC overhead is a concern.'
                    WHEN N'REPLICATION_MAJORITY'        THEN N'Replicated tables have schema constraints on UPDATE STATISTICS. Monitor for schema-lock contention.'
                    WHEN N'COLUMNSTORE_TABLES'          THEN N'modification_counter on columnstore indexes underreports row churn. Consider lower @ModificationThreshold for columnstore-heavy workloads.'
                    WHEN N'RLS_DETECTED'                THEN N'RLS predicates may cause biased histograms if data distribution differs by security context. Use @StatisticsSample = 100 for RLS-protected tables.'
                    WHEN N'FILTER_MISMATCH'             THEN N'A filtered statistic uses a different filter than its matching filtered index. Update statistics and index together when possible.'
                    WHEN N'CASE_SENSITIVE_COLLATION'    THEN N'Parameter matching uses COLLATE DATABASE_DEFAULT. Verify database and instance collations align.'
                    WHEN N'AZURE_SQL_DB'                THEN N'On Azure SQL DB, @StatsInParallel=Y is not supported. Use serial mode.'
                    WHEN N'AZURE_SQL_MI'                THEN N'Azure SQL MI supports most features. Verify @IncludeSystemObjects behavior on MI.'
                    WHEN N'AZURE_SQL_EDGE'              THEN N'Azure SQL Edge has reduced DMV coverage. Some discovery features may return empty.'
                    WHEN N'LOW_UPTIME'                  THEN N'Maintenance ran shortly after server restart. Buffer pool may be cold; duration metrics for these runs are inflated.'
                    WHEN N'TOCTOU_SKIPS'                THEN N'TOCTOU skips mean a stat was claimed by another worker between discovery and execution. Normal in parallel mode; investigate if occurring in serial runs.'
                    WHEN N'EMPTY_STRING_PARAM'          THEN N'An empty string parameter was coerced. Review sp_StatUpdate call for @Databases or @Tables set to empty string.'
                    WHEN N'DEAD_WORKER_TIMEOUT_NULL_COERCED' THEN N'@DeadWorkerTimeoutMinutes = NULL was coerced to the internal default. Set explicitly to avoid jitter in parallel dead-worker detection.'
                    ELSE N'Informational code ' + wc.WarningCode + N' -- review sp_StatUpdate run log for context.'
                  END,
            NULL,
            72
        FROM @warning_code_freq AS wc
        WHERE wc.WarningCode NOT IN (
            /* environmental codes already emitted as W15 */
            N'BACKUP_RUNNING', N'BACKUP_STARTED_MID_RUN', N'LOG_SPACE_HIGH',
            N'CONTAINER_MEMORY', N'RCSI_VERSION_STORE', N'ELASTIC_POOL',
            N'PEAK_HOURS', N'IO_CORRUPTION', N'STOPBYTIME_OVERSHOOT',
            N'CONSECUTIVE_FAILURES_ELEVATED', N'PERSIST_SAMPLE_INADEQUATE',
            N'PARALLEL_ORPHAN_BACKLOG', N'STALE_QUEUE_SWEEP', N'DB_SKIPPED'
        );

        DECLARE @i16_fires integer = @@ROWCOUNT;
        IF @i16_fires > 0
            RAISERROR(N'  [INFO] I16: %i recurring informational warning code(s) detected', 10, 1, @i16_fires) WITH NOWAIT;
    END;

    /* ======================================================================
       W16: CRITICAL_TABLES_NO_MATCH (sw82)

       Fires when a recent non-killed run has CriticalTables configured (non-NULL)
       but ZERO stat rows in that run carry IsCritical=1.  The pattern matched
       nothing -- a silent misconfiguration.

       "Recent" = any non-killed run within the analysis window that has the
       CriticalTables value non-NULL (element presence is implied -- FOR XML omits NULL params).
       We pick the most recent such run for the evidence.
       ====================================================================== */
    IF EXISTS (
        SELECT 1
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.CriticalTables IS NOT NULL
        AND   r.CriticalTables IS NOT NULL   /* element presence implied by non-NULL value */
        AND   NOT EXISTS (
            SELECT 1
            FROM #stat_updates AS su
            WHERE su.RunLabel = r.RunLabel
            AND   su.IsCritical = 1
        )
    )
    BEGIN
        DECLARE
            @w16_run_label nvarchar(100),
            @w16_pattern nvarchar(max),
            @w16_stat_count integer;

        SELECT TOP (1)
            @w16_run_label = r.RunLabel,
            @w16_pattern   = r.CriticalTables
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.CriticalTables IS NOT NULL
        AND   r.CriticalTables IS NOT NULL   /* element presence implied by non-NULL value */
        AND   NOT EXISTS (
            SELECT 1
            FROM #stat_updates AS su
            WHERE su.RunLabel = r.RunLabel
            AND   su.IsCritical = 1
        )
        ORDER BY r.StartTime DESC;

        SET @w16_stat_count = (
            SELECT COUNT_BIG(*)
            FROM #stat_updates AS su
            WHERE su.RunLabel = @w16_run_label
        );

        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        VALUES
        (
            N'WARNING',
            N'CRITICAL_TABLES_NO_MATCH',
            N'@CriticalTables configured but matched no stats in recent run',
            N'Run ' + @w16_run_label + N': CriticalTables = ''' + ISNULL(@w16_pattern, N'(NULL)') + N'''. '
                + CONVERT(nvarchar(10), @w16_stat_count) + N' stat(s) processed -- none carry IsCritical=1. '
                + N'Patterns use LIKE syntax; verify they match actual table names (case-insensitive, wildcards supported).',
            N'Confirm the CriticalTables patterns produce matches: '
                + N'SELECT name FROM sys.objects WHERE OBJECT_ID IN (SELECT object_id FROM sys.stats) '
                + N'AND (name LIKE N''<your pattern>''). '
                + N'Requires sp_StatUpdate v3.5.0+ to log IsCritical in per-stat ExtendedInfo.',
            N'EXECUTE dbo.sp_StatUpdate @CriticalTables = N''dbo.Orders,dbo.OrderItems'', @Databases = N''USER_DATABASES'';',
            28
        );

        RAISERROR(N'  [WARNING] W16: CriticalTables configured but matched no stats', 10, 1) WITH NOWAIT;
    END;

    /* ======================================================================
       I17: CRITICAL_TABLES_COVERAGE (sw82)

       When CriticalTables is configured AND critical stats exist, emit a
       leadership-friendly summary: count updated, avg ProcessingPosition
       (when CriticalTablesFirst=Y -- early positions prove priority worked),
       count with CriticalSampleOverride applied.
       ====================================================================== */
    IF EXISTS (
        SELECT 1
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.CriticalTables IS NOT NULL
        AND   r.CriticalTables IS NOT NULL   /* element presence implied by non-NULL value */
        AND   EXISTS (
            SELECT 1
            FROM #stat_updates AS su
            WHERE su.RunLabel = r.RunLabel
            AND   su.IsCritical = 1
        )
    )
    BEGIN
        DECLARE
            @i17_critical_count integer,
            @i17_override_count integer,
            @i17_avg_position decimal(10, 1),
            @i17_pattern nvarchar(max),
            @i17_first nvarchar(1);

        SELECT
            @i17_critical_count = COUNT_BIG(CASE WHEN su.IsCritical = 1 THEN 1 END),
            @i17_override_count = COUNT_BIG(CASE WHEN su.CriticalSampleOverride = 1 THEN 1 END),
            @i17_avg_position   = AVG(CASE WHEN su.IsCritical = 1 AND su.ProcessingPosition IS NOT NULL
                                           THEN CONVERT(decimal(10, 1), su.ProcessingPosition)
                                      END)
        FROM #stat_updates AS su
        INNER JOIN #runs AS r
            ON r.RunLabel = su.RunLabel
            AND r.IsKilled = 0
            AND r.CriticalTables IS NOT NULL
            AND r.CriticalTables IS NOT NULL;

        /* Pull pattern and CriticalTablesFirst from most recent qualifying run */
        SELECT TOP (1)
            @i17_pattern = r.CriticalTables,
            @i17_first   = r.CriticalTablesFirst
        FROM #runs AS r
        WHERE r.IsKilled = 0
        AND   r.CriticalTables IS NOT NULL
        AND   r.CriticalTables IS NOT NULL   /* element presence implied by non-NULL value */
        ORDER BY r.StartTime DESC;

        INSERT INTO #recommendations (Severity, Category, Finding, Evidence, Recommendation, ExampleCall, SortPriority)
        VALUES
        (
            N'INFO',
            N'CRITICAL_TABLES_COVERAGE',
            N'@CriticalTables is active: '
                + CONVERT(nvarchar(10), @i17_critical_count) + N' critical stat update(s) recorded'
                + CASE WHEN @i17_first = N'Y' AND @i17_avg_position IS NOT NULL
                       THEN N', avg position ' + CONVERT(nvarchar(10), @i17_avg_position)
                            + N' (low position = early in run = priority is working)'
                       ELSE N''
                  END
                + CASE WHEN @i17_override_count > 0
                       THEN N', ' + CONVERT(nvarchar(10), @i17_override_count) + N' with sample-rate override applied'
                       ELSE N''
                  END + N'.',
            N'Configured pattern(s): ' + ISNULL(@i17_pattern, N'(NULL)')
                + N'. CriticalTablesFirst: ' + ISNULL(@i17_first, N'(not set)')
                + CASE WHEN @i17_avg_position IS NOT NULL
                       THEN N'. Avg ProcessingPosition of critical stats: ' + CONVERT(nvarchar(10), @i17_avg_position)
                            + N'. Positions close to 1 confirm the priority boost is taking effect.'
                       ELSE N'. ProcessingPosition not available (requires @CriticalTablesFirst = N''Y'').'
                  END,
            N'Critical tables are being processed. Monitor via RS 5 Top Tables and RS 4 Run Detail. '
                + N'If positions are not early enough, verify @CriticalTablesFirst = N''Y'' and that @SortOrder is compatible.',
            N'EXECUTE dbo.sp_StatUpdate @CriticalTables = N''' + ISNULL(REPLACE(@i17_pattern, N'''', N''''''), N'dbo.Orders') + N''', @CriticalTablesFirst = N''Y'', @Databases = N''USER_DATABASES'';',
            72
        );

        RAISERROR(N'  [INFO] I17: CriticalTables coverage (%i critical stat updates)', 10, 1, @i17_critical_count) WITH NOWAIT;
    END;

    RAISERROR(N'', 10, 1) WITH NOWAIT;
    RAISERROR(N'Diagnostic checks complete.', 10, 1) WITH NOWAIT;

    IF @Debug = 1
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        DECLARE @debug_crit integer = (SELECT COUNT_BIG(*) FROM #recommendations WHERE Severity = N'CRITICAL');
        DECLARE @debug_warn integer = (SELECT COUNT_BIG(*) FROM #recommendations WHERE Severity = N'WARNING');
        DECLARE @debug_info integer = (SELECT COUNT_BIG(*) FROM #recommendations WHERE Severity = N'INFO');
        RAISERROR(N'DEBUG: #recommendations: %i CRITICAL, %i WARNING, %i INFO', 10, 1, @debug_crit, @debug_warn, @debug_info) WITH NOWAIT;
        RAISERROR(N'DEBUG: Diagnostic checks complete (%i ms)', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
    END;

    RAISERROR(N'', 10, 1) WITH NOWAIT;

    /*
    ============================================================================
    EXECUTIVE DASHBOARD -- Letter grades (A-F) with plain English headlines.
    Inspired by sp_Blitz priority system. Always returned as RS 1.

    Grading scale (each category scored 0-100):
      A = 90-100   B = 75-89   C = 60-74   D = 40-59   F = 0-39

    Categories:
      1. Overall        -- composite of all other categories
      2. Completion      -- are all qualifying stats getting updated?
      3. Reliability     -- how often do runs complete without failures or kills?
      4. Speed           -- throughput (seconds per stat) + time to critical stats
      5. Workload Focus  -- are the highest-impact stats prioritized? (QS runs)
    ============================================================================
    */
    RAISERROR(N'Computing executive dashboard...', 10, 1) WITH NOWAIT;

    DECLARE
        @score_completion integer = 0,
        @score_reliability integer = 0,
        @score_speed integer = 0,
        @score_workload integer = 50,   /* default 50 if no QS runs (neutral); #267: updated below based on run count */
        @score_overall integer = 0,
        @health_score integer = 0,
        @all_parallel bit = 0;          /* 1 when every non-killed run uses @StatsInParallel='Y' */

    /* gh-480: Hoist @avg_completion and @tl_run_pct out of the ELSE branch so the parallel-complete
       fast path also populates them.  The COMPLETION dashboard row's Detail text references
       @avg_completion, producing 'N/A' when parallel-complete was the only signal. */
    DECLARE @avg_completion decimal(5, 1) = NULL;
    DECLARE @tl_run_pct decimal(5, 1) = 0.0;

    /* Completion score: based on avg completion % across recent runs */
    IF @run_count > 0
    BEGIN
        /* 2k2 fix: in parallel mode each worker processes a fraction of StatsFound but the
           aggregate completion is 100%.  When all non-killed runs ended PARALLEL_COMPLETE and
           total StatsRemaining = 0, skip the per-worker ratio and award Grade A (score 95).
           @w3_parallel_complete was computed in the W3 block above. */
        IF @w3_parallel_complete = 1
        BEGIN
            SET @score_completion = 95;     /* Grade A: all work distributed and completed */
            /* gh-480: Populate downstream display variables so COMPLETION detail text is accurate */
            SET @avg_completion = 100.0;
            SET @tl_run_pct = 0.0;
        END
        ELSE
        BEGIN
            SET @avg_completion = (
                SELECT AVG(CASE WHEN r.StatsFound > 0 THEN CONVERT(decimal(5, 1), ISNULL(r.StatsProcessed, 0) * 100.0 / r.StatsFound) ELSE 100.0 END)
                FROM #runs AS r WHERE r.IsKilled = 0
            );
            SET @score_completion = CASE
                WHEN @avg_completion >= 95 THEN 100
                WHEN @avg_completion >= 85 THEN 90
                WHEN @avg_completion >= 70 THEN 75
                WHEN @avg_completion >= 50 THEN 60
                WHEN @avg_completion >= 30 THEN 40
                ELSE 20
            END;

            /* #238: If majority of runs hit TIME_LIMIT, cap completion score --
               a 95% avg looks great but means nothing if the window is too short */
            SET @tl_run_pct = @time_limit_runs * 100.0 / @run_count;

            IF @tl_run_pct >= 80.0 AND @score_completion > 60
                SET @score_completion = 60;     /* Can't exceed C if 80%+ runs hit time limit */
            ELSE IF @tl_run_pct >= 50.0 AND @score_completion > 75
                SET @score_completion = 75;     /* Can't exceed B if 50%+ runs hit time limit */
        END;
    END;

    /* Reliability score: penalize killed runs, failures, time limit exhaustion */
    IF @run_count > 0
    BEGIN
        DECLARE
            @kill_pct decimal(5, 1) = @killed_count * 100.0 / @run_count,
            @fail_pct decimal(5, 1) = (SELECT COUNT_BIG(*) FROM #stat_updates WHERE ErrorNumber > 0) * 100.0 / NULLIF(@stat_update_count, 0),
            @tl_pct decimal(5, 1) = @time_limit_runs * 100.0 / @run_count;

        SET @score_reliability = 100
            - CONVERT(integer, ISNULL(@kill_pct, 0) * 3)     /* heavy penalty for killed runs */
            - CONVERT(integer, ISNULL(@fail_pct, 0) * 2)     /* moderate penalty for failures */
            - CONVERT(integer, ISNULL(@tl_pct, 0) * 1.5);    /* C3 is CRITICAL -- stronger penalty for chronic time limit exhaustion */

        IF @score_reliability < 0 SET @score_reliability = 0;
        IF @score_reliability > 100 SET @score_reliability = 100;
    END;

    /* Speed score: based on avg seconds per stat (lower is better).
       Parallel-mode caveat: sec/stat is wall-clock / total-stats-across-all-workers, which
       underestimates per-worker throughput.  When ALL non-killed runs use @StatsInParallel='Y',
       grade on GB/min instead (> 50 A, > 30 B, > 15 C, > 5 D, else F).
       sec/stat is still shown in the Detail text for reference. */
    IF EXISTS (SELECT 1 FROM #runs WHERE IsKilled = 0 AND StatsProcessed > 0)
    BEGIN
        DECLARE @avg_sec_per_stat decimal(10, 1) = (
            SELECT AVG(CONVERT(decimal(10, 1), r.DurationSeconds * 1.0 / r.StatsProcessed))
            FROM #runs AS r WHERE r.IsKilled = 0 AND r.StatsProcessed > 0
        );
        DECLARE @avg_total_gb decimal(10, 2) = (
            SELECT AVG(r.TotalGB) FROM #runs AS r WHERE r.IsKilled = 0 AND r.TotalGB IS NOT NULL
        );
        DECLARE @avg_gb_per_min decimal(10, 2) = (
            SELECT AVG(CASE WHEN r.DurationSeconds > 0 THEN CONVERT(decimal(10, 2), r.TotalGB / (r.DurationSeconds / 60.0)) ELSE NULL END)
            FROM #runs AS r WHERE r.IsKilled = 0 AND r.TotalGB IS NOT NULL AND r.DurationSeconds > 0
        );

        /* Detect all-parallel mode: every non-killed run uses @StatsInParallel='Y' */
        SET @all_parallel = (
            SELECT CASE WHEN COUNT(*) > 0
                         AND SUM(CASE WHEN ISNULL(r.StatsInParallel, N'N') = N'Y' THEN 1 ELSE 0 END) = COUNT(*)
                        THEN 1 ELSE 0 END
            FROM #runs AS r
            WHERE r.IsKilled = 0
        );

        IF @all_parallel = 1 AND @avg_gb_per_min IS NOT NULL
        BEGIN
            /* Parallel mode: use GB/min as the primary speed signal */
            SET @score_speed = CASE
                WHEN @avg_gb_per_min > 50.0 THEN 100
                WHEN @avg_gb_per_min > 30.0 THEN 90
                WHEN @avg_gb_per_min > 15.0 THEN 75
                WHEN @avg_gb_per_min >  5.0 THEN 55
                ELSE 25
            END;
        END
        ELSE
        BEGIN
            /* Serial or mixed mode: use sec/stat */
            SET @score_speed = CASE
                WHEN @avg_sec_per_stat <= 0.5 THEN 100
                WHEN @avg_sec_per_stat <= 1.0 THEN 90
                WHEN @avg_sec_per_stat <= 2.0 THEN 80
                WHEN @avg_sec_per_stat <= 5.0 THEN 70
                WHEN @avg_sec_per_stat <= 10.0 THEN 55
                WHEN @avg_sec_per_stat <= 30.0 THEN 40
                ELSE 20
            END;
        END;
    END;

    /* Workload Focus score: how well QS prioritization is working */
    IF @qs_run_count > 0
    BEGIN
        DECLARE @avg_workload_cov decimal(5, 1) = (
            SELECT AVG(e.WorkloadCoveragePct) FROM #qs_efficacy AS e WHERE e.IsQSRun = 1 AND e.WorkloadCoveragePct IS NOT NULL
        );
        DECLARE @avg_q1_pct_score decimal(5, 1) = (
            SELECT AVG(e.HighCpuInFirstQuartilePct) FROM #qs_efficacy AS e WHERE e.IsQSRun = 1 AND e.HighCpuInFirstQuartilePct IS NOT NULL
        );
        SET @score_workload = CONVERT(integer, (ISNULL(@avg_workload_cov, 50) + ISNULL(@avg_q1_pct_score, 50)) / 2.0);
        IF @score_workload > 100 SET @score_workload = 100;
    END
    ELSE IF @run_count >= 10
    BEGIN
        /* #267: No QS runs but enough data to know -- grade D (35) indicating missing feature */
        SET @score_workload = 35;
    END;

    /* Apply grade overrides: forced grades map to fixed scores (A=95, B=82, C=67, D=50, F=20) */
    DECLARE
        @effective_completion  integer = @score_completion,
        @effective_reliability integer = @score_reliability,
        @effective_speed       integer = @score_speed,
        @effective_workload    integer = @score_workload;

    IF @override_completion  IN ('A','B','C','D','F') SET @effective_completion  = CASE @override_completion  WHEN 'A' THEN 95 WHEN 'B' THEN 82 WHEN 'C' THEN 67 WHEN 'D' THEN 50 ELSE 20 END;
    IF @override_reliability IN ('A','B','C','D','F') SET @effective_reliability = CASE @override_reliability WHEN 'A' THEN 95 WHEN 'B' THEN 82 WHEN 'C' THEN 67 WHEN 'D' THEN 50 ELSE 20 END;
    IF @override_speed       IN ('A','B','C','D','F') SET @effective_speed       = CASE @override_speed       WHEN 'A' THEN 95 WHEN 'B' THEN 82 WHEN 'C' THEN 67 WHEN 'D' THEN 50 ELSE 20 END;
    IF @override_workload    IN ('A','B','C','D','F') SET @effective_workload    = CASE @override_workload    WHEN 'A' THEN 95 WHEN 'B' THEN 82 WHEN 'C' THEN 67 WHEN 'D' THEN 50 ELSE 20 END;

    /* Overall = weighted average (defaults: COMPLETION=30%, RELIABILITY=25%, SPEED=20%, WORKLOAD=25%;
       overridden by @GradeWeights, normalized to sum to 1.0; IGNOREd categories get weight 0) */
    SET @score_overall = CONVERT(integer,
        @effective_completion  * @weight_completion
        + @effective_reliability * @weight_reliability
        + @effective_speed       * @weight_speed
        + @effective_workload    * @weight_workload
    );
    SET @health_score = @score_overall;

    /* GAP-F: Compute OVERALL trend from history table (if available) */
    DECLARE @prior_health integer = NULL;
    DECLARE @overall_trend nvarchar(20) = NULL;

    IF @SkipHistory = 0 AND @history_exists = 1
    BEGIN
        SET @sql = N'SELECT TOP (1) @ph = h.HealthScore FROM ' + @history_ref + N' AS h ORDER BY h.CapturedAt DESC;';
        EXECUTE sys.sp_executesql @sql, N'@ph integer OUTPUT', @ph = @prior_health OUTPUT;

        IF @prior_health IS NOT NULL
            SET @overall_trend = CASE
                WHEN @score_overall >= @prior_health + 5 THEN N'IMPROVING'
                WHEN @score_overall <= @prior_health - 5 THEN N'DEGRADING'
                ELSE N'STABLE'
            END;
    END;

    /* Populate dashboard rows.
       Override logic: IGNORE -> Grade='-', Score=0, headline prefixed '[IGNORED]'.
       Forced grade -> use forced grade/score, headline prefixed '[OVERRIDE: X]', detail shows actual score.
       OVERALL appends '[Overrides active]' when any override is in effect. */
    INSERT INTO #executive_dashboard (Category, Grade, Score, Headline, Detail, Trend, SortOrder)
    VALUES
    (
        N'OVERALL',
        CASE WHEN @score_overall >= 90 THEN 'A' WHEN @score_overall >= 75 THEN 'B' WHEN @score_overall >= 60 THEN 'C' WHEN @score_overall >= 40 THEN 'D' ELSE 'F' END,
        @score_overall,
        CASE
            WHEN @score_overall >= 90 THEN N'Statistics maintenance is running excellently. No immediate action needed.'
            WHEN @score_overall >= 75 THEN N'Statistics maintenance is healthy with minor opportunities for improvement.'
            WHEN @score_overall >= 60 THEN N'Statistics maintenance is functional but has notable gaps. Review recommendations below.'
            WHEN @score_overall >= 40 THEN N'Statistics maintenance needs attention. Multiple issues affecting database performance.'
            ELSE N'Statistics maintenance has critical issues requiring immediate action.'
        END
            + CASE WHEN @overall_trend IS NOT NULL THEN N' (' + @overall_trend + N' from prior assessment: ' + CONVERT(nvarchar(10), @prior_health) + N' -> ' + CONVERT(nvarchar(10), @score_overall) + N')' ELSE N'' END
            + CASE WHEN @has_overrides = 1 THEN N' [Overrides active]' ELSE N'' END,
        CONVERT(nvarchar(10), @run_count) + N' runs analyzed over ' + CONVERT(nvarchar(10), @DaysBack) + N' days. '
            + CONVERT(nvarchar(10), @stat_update_count) + N' individual stat updates. '
            + CASE WHEN @qs_run_count > 0 THEN CONVERT(nvarchar(10), @qs_run_count) + N' runs using Query Store prioritization.' ELSE N'Query Store prioritization not in use.' END
            /* atk1: short flag in OVERALL Detail when time limit is dominant (not Headline, only Detail) */
            + CASE WHEN @parallel_aggregate_done = 0
                        AND @total_completed_runs > 0
                        AND @tl_run_pct >= @TimeLimitExhaustionPct
                   THEN N' Note: ' + CONVERT(nvarchar(10), CONVERT(integer, @tl_run_pct))
                        + N'% of runs budget-capped by TIME_LIMIT -- see COMPLETION category.'
                   ELSE N''
              END,
        @overall_trend,
        1
    ),
    (
        N'COMPLETION',
        CASE WHEN @override_completion = 'X' THEN '-'
             WHEN @override_completion IN ('A','B','C','D','F') THEN @override_completion
             WHEN @score_completion >= 90 THEN 'A' WHEN @score_completion >= 75 THEN 'B' WHEN @score_completion >= 60 THEN 'C' WHEN @score_completion >= 40 THEN 'D' ELSE 'F' END,
        CASE WHEN @override_completion = 'X' THEN 0 ELSE @score_completion END,
        CASE WHEN @override_completion = 'X' THEN N'[IGNORED] '
             WHEN @override_completion IN ('A','B','C','D','F') THEN N'[OVERRIDE: ' + @override_completion + N'] '
             ELSE N'' END
            + CASE
                WHEN @score_completion >= 90 THEN N'Nearly all qualifying statistics are being updated each run.'
                WHEN @score_completion >= 75 AND @tl_run_pct >= 50.0
                    THEN N'Most statistics are updated, but ' + CONVERT(nvarchar(10), @time_limit_runs)
                         + N' of ' + CONVERT(nvarchar(10), @run_count) + N' runs hit the time limit.'
                WHEN @score_completion >= 75 THEN N'Most statistics are being updated, but some are consistently left behind.'
                WHEN @score_completion >= 60 AND @tl_run_pct >= 50.0
                    THEN N'Maintenance window is too short -- ' + CONVERT(nvarchar(10), @time_limit_runs)
                         + N' of ' + CONVERT(nvarchar(10), @run_count) + N' runs hit the time limit before finishing.'
                WHEN @score_completion >= 60 THEN N'A significant portion of statistics are not being reached within the maintenance window.'
                WHEN @score_completion >= 40 THEN N'Less than half of qualifying statistics are being updated. Increase time limit or reduce scope.'
                ELSE N'Very few statistics are being updated. Maintenance window is severely undersized for the workload.'
            END
            /* atk1: TIME_LIMIT banner -- annotation only; does NOT change score/grade.
               Fires when the share of recent non-killed TIME_LIMIT runs meets @TimeLimitExhaustionPct,
               reusing @tl_run_pct and @time_limit_runs already computed by the C3 block above. */
            + CASE WHEN @parallel_aggregate_done = 0
                        AND @total_completed_runs > 0
                        AND @tl_run_pct >= @TimeLimitExhaustionPct
                   THEN N' [!] Time limit exhausted in ' + CONVERT(nvarchar(10), CONVERT(integer, @tl_run_pct))
                        + N'% of runs -- completion is budget-capped, not workload-complete.'
                   ELSE N''
              END,
        N'Average completion rate: ' + ISNULL(CONVERT(nvarchar(10), @avg_completion), N'N/A') + N'% of qualifying statistics updated per run.'
            + CASE WHEN @override_completion IN ('A','B','C','D','F') THEN N' (actual score: ' + CONVERT(nvarchar(10), @score_completion) + N')' ELSE N'' END
            /* atk1: Completion-reason clause in Detail when time limit dominates */
            + CASE WHEN @parallel_aggregate_done = 0
                        AND @total_completed_runs > 0
                        AND @tl_run_pct >= @TimeLimitExhaustionPct
                   THEN N' CompletionReason: ' + CONVERT(nvarchar(10), @time_limit_runs) + N' of '
                        + CONVERT(nvarchar(10), @total_completed_runs) + N' runs stopped at TIME_LIMIT; '
                        + N'true qualifying-stats count may exceed StatsFound.'
                   ELSE N''
              END,
        NULL,
        2
    ),
    (
        N'RELIABILITY',
        CASE WHEN @override_reliability = 'X' THEN '-'
             WHEN @override_reliability IN ('A','B','C','D','F') THEN @override_reliability
             WHEN @score_reliability >= 90 THEN 'A' WHEN @score_reliability >= 75 THEN 'B' WHEN @score_reliability >= 60 THEN 'C' WHEN @score_reliability >= 40 THEN 'D' ELSE 'F' END,
        CASE WHEN @override_reliability = 'X' THEN 0 ELSE @score_reliability END,
        CASE WHEN @override_reliability = 'X' THEN N'[IGNORED] '
             WHEN @override_reliability IN ('A','B','C','D','F') THEN N'[OVERRIDE: ' + @override_reliability + N'] '
             ELSE N'' END
            + CASE
                WHEN @killed_count > 0 AND @score_reliability < 60 THEN CONVERT(nvarchar(10), @killed_count) + N' run(s) were killed before completing. Check SQL Agent job history for failures.'
                WHEN @killed_count > 0 THEN CONVERT(nvarchar(10), @killed_count) + N' run(s) were killed, but overall reliability is acceptable.'
                WHEN @score_reliability >= 90 THEN N'All runs completed normally without errors or kills.'
                ELSE N'Runs are completing but experiencing errors or consistently hitting time limits.'
            END,
        N'Killed runs: ' + CONVERT(nvarchar(10), @killed_count)
            + N'. Failed stat updates: ' + CONVERT(nvarchar(10), (SELECT COUNT_BIG(*) FROM #stat_updates WHERE ErrorNumber > 0))
            + N'. Time-limited runs: ' + CONVERT(nvarchar(10), @time_limit_runs) + N'.'
            + CASE WHEN @override_reliability IN ('A','B','C','D','F') THEN N' (actual score: ' + CONVERT(nvarchar(10), @score_reliability) + N')' ELSE N'' END,
        NULL,
        3
    ),
    (
        N'SPEED',
        CASE WHEN @override_speed = 'X' THEN '-'
             WHEN @override_speed IN ('A','B','C','D','F') THEN @override_speed
             WHEN @score_speed >= 90 THEN 'A' WHEN @score_speed >= 75 THEN 'B' WHEN @score_speed >= 60 THEN 'C' WHEN @score_speed >= 40 THEN 'D' ELSE 'F' END,
        CASE WHEN @override_speed = 'X' THEN 0 ELSE @score_speed END,
        CASE WHEN @override_speed = 'X' THEN N'[IGNORED] '
             WHEN @override_speed IN ('A','B','C','D','F') THEN N'[OVERRIDE: ' + @override_speed + N'] '
             ELSE N'' END
            /* Parallel mode: headline leads with GB/min (the meaningful throughput metric).
               Serial/mixed mode: headline leads with sec/stat as before. */
            + CASE WHEN @all_parallel = 1 AND @avg_gb_per_min IS NOT NULL
                THEN CASE
                    WHEN @score_speed >= 90 THEN N'Parallel throughput is excellent at ' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min'
                        + N' (' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'?') + N' sec/stat wall-clock).'
                    WHEN @score_speed >= 75 THEN N'Parallel throughput is good at ' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min'
                        + N' (' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'?') + N' sec/stat wall-clock).'
                    WHEN @score_speed >= 55 THEN N'Parallel throughput is moderate at ' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min'
                        + N'. Consider adding more parallel workers or reviewing I/O capacity.'
                    ELSE N'Parallel throughput is low at ' + ISNULL(CONVERT(nvarchar(20), @avg_gb_per_min), N'?') + N' GB/min'
                        + N'. Investigate I/O, worker count, and table sizes.'
                END
                ELSE CASE
                    WHEN @score_speed >= 90 THEN N'Statistics are being updated very quickly (' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'<1') + N' sec/stat average'
                        + CASE WHEN @avg_gb_per_min IS NOT NULL THEN N', ' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min' ELSE N'' END + N').'
                    WHEN @score_speed >= 75 THEN N'Update speed is good at ' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'?') + N' sec/stat average'
                        + CASE WHEN @avg_gb_per_min IS NOT NULL THEN N' (' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min)' ELSE N'' END + N'.'
                    WHEN @score_speed >= 60 THEN N'Update speed is moderate at ' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'?') + N' sec/stat'
                        + CASE WHEN @avg_gb_per_min IS NOT NULL THEN N' (' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min)' ELSE N'' END + N'. Consider parallel mode or adaptive sampling.'
                    ELSE N'Updates are slow at ' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'?') + N' sec/stat'
                        + CASE WHEN @avg_gb_per_min IS NOT NULL THEN N' (' + CONVERT(nvarchar(20), @avg_gb_per_min) + N' GB/min)' ELSE N'' END + N'. Investigate I/O, table sizes, and sample rates.'
                END
            END,
        CASE WHEN @all_parallel = 1
            THEN N'Parallel mode (all runs use @StatsInParallel=Y). Speed graded on GB/min: '
                + ISNULL(CONVERT(nvarchar(20), @avg_gb_per_min), N'N/A') + N' GB/min avg.'
                + N' Wall-clock sec/stat: ' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'N/A')
                + N' (not used for grade -- underestimates per-worker throughput).'
            ELSE N'Average seconds per stat update: ' + ISNULL(CONVERT(nvarchar(20), @avg_sec_per_stat), N'N/A')
        END
            + CASE WHEN @avg_total_gb IS NOT NULL THEN N'. Average data volume: ' + CONVERT(nvarchar(20), @avg_total_gb) + N' GB/run (' + ISNULL(CONVERT(nvarchar(20), @avg_gb_per_min), N'N/A') + N' GB/min)' ELSE N'' END
            + N'. Average run duration: ' + ISNULL(CONVERT(nvarchar(10), (SELECT AVG(DurationSeconds) / 60 FROM #runs WHERE IsKilled = 0)), N'N/A') + N' minutes.'
            + CASE WHEN @override_speed IN ('A','B','C','D','F') THEN N' (actual score: ' + CONVERT(nvarchar(10), @score_speed) + N')' ELSE N'' END,
        NULL,
        4
    ),
    (
        N'WORKLOAD FOCUS',
        CASE WHEN @override_workload = 'X' THEN '-'
             WHEN @override_workload IN ('A','B','C','D','F') THEN @override_workload
             /* #267: insufficient data for workload grade when <10 runs and no QS */
             WHEN @qs_run_count = 0 AND @run_count < 10 THEN '-'
             WHEN @score_workload >= 90 THEN 'A' WHEN @score_workload >= 75 THEN 'B' WHEN @score_workload >= 60 THEN 'C' WHEN @score_workload >= 40 THEN 'D' ELSE 'F' END,
        CASE WHEN @override_workload = 'X' THEN 0 WHEN @qs_run_count = 0 AND @run_count < 10 THEN 0 ELSE @score_workload END,
        CASE WHEN @override_workload = 'X' THEN N'[IGNORED] '
             WHEN @override_workload IN ('A','B','C','D','F') THEN N'[OVERRIDE: ' + @override_workload + N'] '
             ELSE N'' END
            + CASE
                /* #267: Differentiate no-QS headline based on data sufficiency */
                WHEN @qs_run_count = 0 AND @run_count < 10 THEN N'Insufficient data to evaluate workload-aware prioritization.'
                WHEN @qs_run_count = 0 THEN N'No workload-aware prioritization configured. Statistics are updated by modification count, not workload impact.'
                WHEN @score_workload >= 90 THEN N'Query Store prioritization is highly effective. The most performance-critical statistics are updated first.'
                WHEN @score_workload >= 75 THEN N'Query Store prioritization is working well. Most high-impact statistics are prioritized.'
                ELSE N'Query Store prioritization is enabled but not fully effective. Check Query Store health on target databases.'
            END,
        CASE
            WHEN @qs_run_count > 0 THEN N'QS runs: ' + CONVERT(nvarchar(10), @qs_run_count)
                + N'. Avg workload coverage: ' + ISNULL(CONVERT(nvarchar(10), @avg_workload_cov), N'N/A') + N'%'
                + N'. High-CPU stats in first quartile: ' + ISNULL(CONVERT(nvarchar(10), @avg_q1_pct_score), N'N/A') + N'%.'
            ELSE N'Enable with: @QueryStore = N''CPU'', @SortOrder = N''QUERY_STORE'''
        END
            + CASE WHEN @override_workload IN ('A','B','C','D','F') THEN N' (actual score: ' + CONVERT(nvarchar(10), @score_workload) + N')' ELSE N'' END,
        NULL,
        5
    );

    RAISERROR(N'  Health score: %i / 100', 10, 1, @health_score) WITH NOWAIT;

    /*
    ============================================================================
    PERSIST TO HISTORY TABLE (incremental insert for new runs only)
    ============================================================================
    */
    IF @SkipHistory = 0 AND @history_exists = 1 AND @Obfuscate = 0
    BEGIN
        DECLARE @new_max_id integer = (SELECT ISNULL(MAX(ID), 0) FROM #stat_updates);

        /* BUG-C fix: Compute per-run HealthScore inline instead of using aggregate @health_score.
           Each run gets its own score based on its completion, speed, and workload metrics.
           Grading scale: A=90-100, B=75-89, C=60-74, D=40-59, F=0-39 */
        /* 9axc: @new_max_start = the most recent StartTime among all #runs rows being processed.
           Written to MaxStartTime so future watermark reads can use WHERE StartTime > @watermark_time,
           which is stable even when CommandLog IDs are renumbered after purge/archive. */
        DECLARE @new_max_start datetime2(3) = (SELECT MAX(r.StartTime) FROM #runs AS r WHERE r.IsKilled = 0);

        SET @sql = N'
            INSERT INTO ' + @history_ref + N'
            (MaxCommandLogID, MaxStartTime, RunLabel, StartTime, HealthScore, OverallGrade,
             CompletionPct, AvgSecPerStat, WorkloadCoveragePct, HighCpuFirstQuartilePct,
             MinutesToHighCpuComplete, StatsFound, StatsProcessed, StatsFailed,
             StopReason, DurationSeconds, IsQSRun, DiagVersion)
            SELECT
                @max_id,
                @max_start,     /* 9axc: MaxStartTime watermark -- robust to ID gaps after purge/archive */
                e.RunLabel,
                e.StartTime,
                /* Per-run HealthScore: weighted composite of completion + speed + workload focus */
                per_run_health = CONVERT(integer,
                    /* Completion 40% */
                    CASE
                        WHEN ISNULL(e.CompletionPct, 0) >= 95 THEN 100
                        WHEN ISNULL(e.CompletionPct, 0) >= 85 THEN 90
                        WHEN ISNULL(e.CompletionPct, 0) >= 70 THEN 75
                        WHEN ISNULL(e.CompletionPct, 0) >= 50 THEN 60
                        WHEN ISNULL(e.CompletionPct, 0) >= 30 THEN 40
                        ELSE 20
                    END * 0.40
                    /* Speed 30% */
                    + CASE
                        WHEN ISNULL(e.AvgSecPerStat, 999) <= 0.5 THEN 100
                        WHEN ISNULL(e.AvgSecPerStat, 999) <= 1.0 THEN 90
                        WHEN ISNULL(e.AvgSecPerStat, 999) <= 2.0 THEN 80
                        WHEN ISNULL(e.AvgSecPerStat, 999) <= 5.0 THEN 70
                        WHEN ISNULL(e.AvgSecPerStat, 999) <= 10.0 THEN 55
                        WHEN ISNULL(e.AvgSecPerStat, 999) <= 30.0 THEN 40
                        ELSE 20
                    END * 0.30
                    /* Workload Focus 30% (neutral 50 if no QS data) */
                    + CASE
                        WHEN e.IsQSRun = 0 OR e.HighCpuInFirstQuartilePct IS NULL THEN 50
                        ELSE CONVERT(integer, (ISNULL(e.WorkloadCoveragePct, 50) + ISNULL(e.HighCpuInFirstQuartilePct, 50)) / 2.0)
                    END * 0.30
                ),
                per_run_grade = CASE
                    WHEN CONVERT(integer,
                        CASE WHEN ISNULL(e.CompletionPct, 0) >= 95 THEN 100 WHEN ISNULL(e.CompletionPct, 0) >= 85 THEN 90
                             WHEN ISNULL(e.CompletionPct, 0) >= 70 THEN 75 WHEN ISNULL(e.CompletionPct, 0) >= 50 THEN 60
                             WHEN ISNULL(e.CompletionPct, 0) >= 30 THEN 40 ELSE 20 END * 0.40
                        + CASE WHEN ISNULL(e.AvgSecPerStat, 999) <= 0.5 THEN 100 WHEN ISNULL(e.AvgSecPerStat, 999) <= 1.0 THEN 90
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 2.0 THEN 80 WHEN ISNULL(e.AvgSecPerStat, 999) <= 5.0 THEN 70
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 10.0 THEN 55 WHEN ISNULL(e.AvgSecPerStat, 999) <= 30.0 THEN 40 ELSE 20 END * 0.30
                        + CASE WHEN e.IsQSRun = 0 OR e.HighCpuInFirstQuartilePct IS NULL THEN 50
                               ELSE CONVERT(integer, (ISNULL(e.WorkloadCoveragePct, 50) + ISNULL(e.HighCpuInFirstQuartilePct, 50)) / 2.0) END * 0.30
                    ) >= 90 THEN ''A'' WHEN CONVERT(integer,
                        CASE WHEN ISNULL(e.CompletionPct, 0) >= 95 THEN 100 WHEN ISNULL(e.CompletionPct, 0) >= 85 THEN 90
                             WHEN ISNULL(e.CompletionPct, 0) >= 70 THEN 75 WHEN ISNULL(e.CompletionPct, 0) >= 50 THEN 60
                             WHEN ISNULL(e.CompletionPct, 0) >= 30 THEN 40 ELSE 20 END * 0.40
                        + CASE WHEN ISNULL(e.AvgSecPerStat, 999) <= 0.5 THEN 100 WHEN ISNULL(e.AvgSecPerStat, 999) <= 1.0 THEN 90
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 2.0 THEN 80 WHEN ISNULL(e.AvgSecPerStat, 999) <= 5.0 THEN 70
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 10.0 THEN 55 WHEN ISNULL(e.AvgSecPerStat, 999) <= 30.0 THEN 40 ELSE 20 END * 0.30
                        + CASE WHEN e.IsQSRun = 0 OR e.HighCpuInFirstQuartilePct IS NULL THEN 50
                               ELSE CONVERT(integer, (ISNULL(e.WorkloadCoveragePct, 50) + ISNULL(e.HighCpuInFirstQuartilePct, 50)) / 2.0) END * 0.30
                    ) >= 75 THEN ''B'' WHEN CONVERT(integer,
                        CASE WHEN ISNULL(e.CompletionPct, 0) >= 95 THEN 100 WHEN ISNULL(e.CompletionPct, 0) >= 85 THEN 90
                             WHEN ISNULL(e.CompletionPct, 0) >= 70 THEN 75 WHEN ISNULL(e.CompletionPct, 0) >= 50 THEN 60
                             WHEN ISNULL(e.CompletionPct, 0) >= 30 THEN 40 ELSE 20 END * 0.40
                        + CASE WHEN ISNULL(e.AvgSecPerStat, 999) <= 0.5 THEN 100 WHEN ISNULL(e.AvgSecPerStat, 999) <= 1.0 THEN 90
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 2.0 THEN 80 WHEN ISNULL(e.AvgSecPerStat, 999) <= 5.0 THEN 70
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 10.0 THEN 55 WHEN ISNULL(e.AvgSecPerStat, 999) <= 30.0 THEN 40 ELSE 20 END * 0.30
                        + CASE WHEN e.IsQSRun = 0 OR e.HighCpuInFirstQuartilePct IS NULL THEN 50
                               ELSE CONVERT(integer, (ISNULL(e.WorkloadCoveragePct, 50) + ISNULL(e.HighCpuInFirstQuartilePct, 50)) / 2.0) END * 0.30
                    ) >= 60 THEN ''C'' WHEN CONVERT(integer,
                        CASE WHEN ISNULL(e.CompletionPct, 0) >= 95 THEN 100 WHEN ISNULL(e.CompletionPct, 0) >= 85 THEN 90
                             WHEN ISNULL(e.CompletionPct, 0) >= 70 THEN 75 WHEN ISNULL(e.CompletionPct, 0) >= 50 THEN 60
                             WHEN ISNULL(e.CompletionPct, 0) >= 30 THEN 40 ELSE 20 END * 0.40
                        + CASE WHEN ISNULL(e.AvgSecPerStat, 999) <= 0.5 THEN 100 WHEN ISNULL(e.AvgSecPerStat, 999) <= 1.0 THEN 90
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 2.0 THEN 80 WHEN ISNULL(e.AvgSecPerStat, 999) <= 5.0 THEN 70
                               WHEN ISNULL(e.AvgSecPerStat, 999) <= 10.0 THEN 55 WHEN ISNULL(e.AvgSecPerStat, 999) <= 30.0 THEN 40 ELSE 20 END * 0.30
                        + CASE WHEN e.IsQSRun = 0 OR e.HighCpuInFirstQuartilePct IS NULL THEN 50
                               ELSE CONVERT(integer, (ISNULL(e.WorkloadCoveragePct, 50) + ISNULL(e.HighCpuInFirstQuartilePct, 50)) / 2.0) END * 0.30
                    ) >= 40 THEN ''D'' ELSE ''F'' END,
                e.CompletionPct,
                e.AvgSecPerStat,
                e.WorkloadCoveragePct,
                e.HighCpuInFirstQuartilePct,
                e.MinutesToHighCpuComplete,
                e.StatsFound,
                e.StatsProcessed,
                r.StatsFailed,
                e.StopReason,
                e.DurationSeconds,
                e.IsQSRun,
                @version
            FROM #qs_efficacy AS e
            INNER JOIN #runs AS r ON r.RunLabel = e.RunLabel
            WHERE NOT EXISTS (
                SELECT 1 FROM ' + @history_ref + N' AS h
                WHERE h.RunLabel = e.RunLabel
            );
        ';

        DECLARE @rows_inserted integer;

        EXECUTE sys.sp_executesql
            @sql,
            N'@max_id integer, @max_start datetime2(3), @version varchar(20)',
            @max_id   = @new_max_id,
            @max_start = @new_max_start,
            @version  = @procedure_version;

        SET @rows_inserted = @@ROWCOUNT;

        IF @rows_inserted > 0
            RAISERROR(N'  Persisted %i new run(s) to history table', 10, 1, @rows_inserted) WITH NOWAIT;
    END;

    RAISERROR(N'', 10, 1) WITH NOWAIT;

    /* #270: When ExpertMode=0 and QS data exists, enrich CRITICAL/WARNING evidence with workload context */
    IF @ExpertMode = 0 AND @workload_impact_count > 0
    BEGIN
        UPDATE rec
        SET Evidence = rec.Evidence
            + N' [Workload context: '
            + CONVERT(nvarchar(10), wi_stats.high_impact_count) + N' of '
            + CONVERT(nvarchar(10), @workload_impact_count) + N' tracked stats are high-impact (top 10% by CPU).]'
        FROM #recommendations AS rec
        CROSS APPLY (
            SELECT high_impact_count = COUNT_BIG(*)
            FROM #workload_impact AS wi
            WHERE wi.ImpactScore >= 0.90
        ) AS wi_stats
        WHERE rec.Severity IN (N'CRITICAL', N'WARNING')
        AND   wi_stats.high_impact_count > 0;
    END;

    IF @Debug = 1
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        RAISERROR(N'DEBUG: #executive_dashboard contents', 10, 1) WITH NOWAIT;
        SELECT * FROM #executive_dashboard;
        RAISERROR(N'DEBUG: Dashboard computation complete (%i ms)', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
    END;

    /*
    ============================================================================
    RESULT SET 1: EXECUTIVE DASHBOARD (always returned, even with @ExpertMode=0)
    ============================================================================
    */
    IF @SingleResultSet = 0
    BEGIN
        SELECT
            Category,
            Grade,
            Score,
            Headline,
            Detail,
            Trend
        FROM #executive_dashboard
        ORDER BY SortOrder;
    END
    ELSE
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 1,
            ResultSetName = N'Executive Dashboard',
            RowNum        = ROW_NUMBER() OVER (ORDER BY ed.SortOrder),
            RowData       = (
                SELECT
                    Category = ed2.Category,
                    Grade    = ed2.Grade,
                    Score    = ed2.Score,
                    Headline = ed2.Headline,
                    Detail   = ed2.Detail,
                    Trend    = ed2.Trend
                FROM #executive_dashboard AS ed2
                WHERE ed2.Category = ed.Category
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #executive_dashboard AS ed;
    END;

    /*
    ============================================================================
    RESULT SET 2: RECOMMENDATIONS (always returned)
    ============================================================================
    */
    IF @SingleResultSet = 0
    BEGIN
        SELECT
            Severity,
            Category,
            Finding,
            Evidence,
            Recommendation,
            ExampleCall,
            /* #283: One-line summary for quick scanning */
            Summary = N'[' + Severity + N'] ' + Finding
                + CASE WHEN Recommendation IS NOT NULL THEN N' -- ' + LEFT(Recommendation, 200) ELSE N'' END
                + CASE WHEN ExampleCall IS NOT NULL THEN N' Fix: ' + ExampleCall ELSE N'' END
        FROM #recommendations
        ORDER BY
            CASE Severity
                WHEN N'CRITICAL' THEN 1
                WHEN N'WARNING'  THEN 2
                WHEN N'INFO'     THEN 3
                ELSE 4
            END,
            SortPriority,
            FindingID;
    END
    ELSE
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 2,
            ResultSetName = N'Recommendations',
            RowNum        = ROW_NUMBER() OVER (
                                ORDER BY
                                    CASE r.Severity
                                        WHEN N'CRITICAL' THEN 1
                                        WHEN N'WARNING'  THEN 2
                                        WHEN N'INFO'     THEN 3
                                        ELSE 4
                                    END,
                                    r.SortPriority,
                                    r.FindingID
                            ),
            RowData       = (
                SELECT
                    Severity       = r2.Severity,
                    Category       = r2.Category,
                    Finding        = r2.Finding,
                    Evidence       = r2.Evidence,
                    Recommendation = r2.Recommendation,
                    ExampleCall    = r2.ExampleCall,
                    Summary        = N'[' + r2.Severity + N'] ' + r2.Finding
                        + CASE WHEN r2.Recommendation IS NOT NULL THEN N' -- ' + LEFT(r2.Recommendation, 200) ELSE N'' END
                        + CASE WHEN r2.ExampleCall IS NOT NULL THEN N' Fix: ' + r2.ExampleCall ELSE N'' END
                FROM #recommendations AS r2
                WHERE r2.FindingID = r.FindingID
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #recommendations AS r;
    END;

    /*
    ============================================================================
    RESULT SET 3: RUN HEALTH SUMMARY (@ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        SELECT
            TotalRuns = @run_count,
            CompletedRuns = @total_completed_runs,
            KilledRuns = @killed_count,
            CompletionPct = CASE
                WHEN @run_count > 0
                THEN CONVERT(decimal(5, 1), @total_completed_runs * 100.0 / @run_count)
                ELSE 0
            END,
            TimeLimitedRuns = @time_limit_runs,
            NaturalEndRuns = (SELECT COUNT_BIG(*) FROM #runs WHERE StopReason IN (N'COMPLETED', N'PARALLEL_COMPLETE')),
            /* ksi fix: exclude killed runs with StatsProcessed=0 -- orphan-cleanup creates 48-hour phantom END records that inflate avg */
            AvgDurationSec = (SELECT AVG(DurationSeconds) FROM #runs WHERE IsKilled = 0 OR ISNULL(StatsProcessed, 0) > 0),
            AvgStatsProcessed = (SELECT AVG(StatsProcessed) FROM #runs WHERE IsKilled = 0),
            AvgStatsRemaining = (SELECT AVG(StatsRemaining) FROM #runs WHERE IsKilled = 0),
            TotalStatUpdates = @stat_update_count,
            TotalFailedUpdates = (SELECT COUNT_BIG(*) FROM #stat_updates WHERE ErrorNumber > 0),
            AnalysisWindowDays = @DaysBack,
            StopReasonDistribution = (
                SELECT STRING_AGG(stop_summary, N', ')
                FROM (
                    SELECT r.StopReason + N': ' + CONVERT(nvarchar(10), COUNT_BIG(*)) AS stop_summary
                    FROM #runs AS r
                    WHERE r.IsKilled = 0
                    AND   r.StopReason IS NOT NULL
                    GROUP BY r.StopReason
                ) AS sr
            ),
            HealthScore = @health_score,
            QSRunCount = (SELECT COUNT_BIG(*) FROM #qs_efficacy WHERE IsQSRun = 1),
            AvgWorkloadCoveragePct = (SELECT AVG(WorkloadCoveragePct) FROM #qs_efficacy WHERE IsQSRun = 1),
            LatestHighCpuFirstQuartilePct = (SELECT TOP (1) HighCpuInFirstQuartilePct FROM #qs_efficacy WHERE IsQSRun = 1 ORDER BY StartTime DESC),
            AvgTotalGB = (SELECT AVG(r2.TotalGB) FROM #runs AS r2 WHERE r2.IsKilled = 0 AND r2.TotalGB IS NOT NULL),
            AvgGBPerMin = (SELECT AVG(CASE WHEN r2.DurationSeconds > 0 THEN CONVERT(decimal(10, 2), r2.TotalGB / (r2.DurationSeconds / 60.0)) ELSE NULL END) FROM #runs AS r2 WHERE r2.IsKilled = 0 AND r2.TotalGB IS NOT NULL AND r2.DurationSeconds > 0),
            ReplicaRole = @ag_replica_role;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 3,
            ResultSetName = N'Run Health Summary',
            RowNum        = 1,
            RowData       = (
                SELECT
                    TotalRuns              = @run_count,
                    CompletedRuns          = @total_completed_runs,
                    KilledRuns             = @killed_count,
                    CompletionPct          = CASE
                                                WHEN @run_count > 0
                                                THEN CONVERT(decimal(5, 1), @total_completed_runs * 100.0 / @run_count)
                                                ELSE 0
                                            END,
                    TimeLimitedRuns        = @time_limit_runs,
                    NaturalEndRuns         = (SELECT COUNT_BIG(*) FROM #runs WHERE StopReason IN (N'COMPLETED', N'PARALLEL_COMPLETE')),
                    /* ksi fix: exclude killed runs with StatsProcessed=0 -- orphan-cleanup creates 48-hour phantom END records that inflate avg */
                    AvgDurationSec         = (SELECT AVG(DurationSeconds) FROM #runs WHERE IsKilled = 0 OR ISNULL(StatsProcessed, 0) > 0),
                    AvgStatsProcessed      = (SELECT AVG(StatsProcessed) FROM #runs WHERE IsKilled = 0),
                    AvgStatsRemaining      = (SELECT AVG(StatsRemaining) FROM #runs WHERE IsKilled = 0),
                    TotalStatUpdates       = @stat_update_count,
                    TotalFailedUpdates     = (SELECT COUNT_BIG(*) FROM #stat_updates WHERE ErrorNumber > 0),
                    AnalysisWindowDays     = @DaysBack,
                    HealthScore            = @health_score,
                    StopReasonDistribution = (
                        SELECT STRING_AGG(stop_summary, N', ')
                        FROM (
                            SELECT r.StopReason + N': ' + CONVERT(nvarchar(10), COUNT_BIG(*)) AS stop_summary
                            FROM #runs AS r
                            WHERE r.IsKilled = 0
                            AND   r.StopReason IS NOT NULL
                            GROUP BY r.StopReason
                        ) AS sr
                    ),
                    QSRunCount = (SELECT COUNT_BIG(*) FROM #qs_efficacy WHERE IsQSRun = 1),
                    AvgWorkloadCoveragePct = (SELECT AVG(WorkloadCoveragePct) FROM #qs_efficacy WHERE IsQSRun = 1),
                    LatestHighCpuFirstQuartilePct = (SELECT TOP (1) HighCpuInFirstQuartilePct FROM #qs_efficacy WHERE IsQSRun = 1 ORDER BY StartTime DESC),
                    AvgTotalGB = (SELECT AVG(r2.TotalGB) FROM #runs AS r2 WHERE r2.IsKilled = 0 AND r2.TotalGB IS NOT NULL),
                    AvgGBPerMin = (SELECT AVG(CASE WHEN r2.DurationSeconds > 0 THEN CONVERT(decimal(10, 2), r2.TotalGB / (r2.DurationSeconds / 60.0)) ELSE NULL END) FROM #runs AS r2 WHERE r2.IsKilled = 0 AND r2.TotalGB IS NOT NULL AND r2.DurationSeconds > 0),
                    ReplicaRole = @ag_replica_role
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            );
    END;

    /*
    ============================================================================
    RESULT SET 4: RUN DETAIL (@ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        SELECT
            r.RunLabel,
            r.StartTime,
            r.EndTime,
            r.DurationSeconds,
            DurationMinutes = r.DurationSeconds / 60,
            r.StopReason,
            r.StatsFound,
            r.StatsProcessed,
            r.StatsSucceeded,
            r.StatsFailed,
            r.StatsRemaining,
            AvgSecPerStat = CASE
                WHEN r.StatsProcessed > 0
                THEN CONVERT(decimal(10, 1), r.DurationSeconds * 1.0 / r.StatsProcessed)
                ELSE NULL
            END,
            r.IsKilled,
            r.[Version],
            r.[Databases],
            r.TimeLimit,
            r.ModificationThreshold,
            r.TieredThresholds,
            r.SortOrder,
            r.QueryStorePriority,
            r.StatsInParallel,
            r.Preset,
            r.LongRunningThresholdMinutes,
            r.MopUpTriggered,
            r.MopUpFound,
            r.MopUpProcessed,
            /* 70hh: TOCTOU skip count per run (NULL on older rows without this element) */
            r.StatsToctou,
            r.TotalGB,
            GBPerMin = CASE WHEN r.DurationSeconds > 0 AND r.TotalGB IS NOT NULL
                THEN CONVERT(decimal(10, 2), r.TotalGB / (r.DurationSeconds / 60.0)) ELSE NULL END,
            WorkloadCoveragePct = e.WorkloadCoveragePct,
            HighCpuInFirstQuartilePct = e.HighCpuInFirstQuartilePct,
            MinutesToHighCpuComplete = e.MinutesToHighCpuComplete
        FROM #runs AS r
        LEFT JOIN #qs_efficacy AS e
            ON e.RunLabel = r.RunLabel
        ORDER BY r.StartTime DESC;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 4,
            ResultSetName = N'Run Detail',
            RowNum        = ROW_NUMBER() OVER (ORDER BY r.StartTime DESC),
            RowData       = (
                SELECT
                    RunLabel                = r2.RunLabel,
                    StartTime               = r2.StartTime,
                    EndTime                 = r2.EndTime,
                    DurationSeconds         = r2.DurationSeconds,
                    DurationMinutes         = r2.DurationSeconds / 60,
                    StopReason              = r2.StopReason,
                    StatsFound              = r2.StatsFound,
                    StatsProcessed          = r2.StatsProcessed,
                    StatsSucceeded          = r2.StatsSucceeded,
                    StatsFailed             = r2.StatsFailed,
                    StatsRemaining          = r2.StatsRemaining,
                    AvgSecPerStat           = CASE
                                                WHEN r2.StatsProcessed > 0
                                                THEN CONVERT(decimal(10, 1), r2.DurationSeconds * 1.0 / r2.StatsProcessed)
                                                ELSE NULL
                                              END,
                    IsKilled                = r2.IsKilled,
                    [Version]               = r2.[Version],
                    [Databases]             = r2.[Databases],
                    TimeLimit               = r2.TimeLimit,
                    ModificationThreshold   = r2.ModificationThreshold,
                    TieredThresholds        = r2.TieredThresholds,
                    SortOrder               = r2.SortOrder,
                    QueryStorePriority      = r2.QueryStorePriority,
                    StatsInParallel         = r2.StatsInParallel,
                    Preset                  = r2.Preset,
                    LongRunningThresholdMinutes = r2.LongRunningThresholdMinutes,
                    MopUpTriggered          = r2.MopUpTriggered,
                    MopUpFound              = r2.MopUpFound,
                    MopUpProcessed          = r2.MopUpProcessed,
                    StatsToctou             = r2.StatsToctou,
                    TotalGB                 = r2.TotalGB,
                    GBPerMin                = CASE WHEN r2.DurationSeconds > 0 AND r2.TotalGB IS NOT NULL
                                                THEN CONVERT(decimal(10, 2), r2.TotalGB / (r2.DurationSeconds / 60.0)) ELSE NULL END,
                    WorkloadCoveragePct     = e2.WorkloadCoveragePct,
                    HighCpuInFirstQuartilePct = e2.HighCpuInFirstQuartilePct,
                    MinutesToHighCpuComplete = e2.MinutesToHighCpuComplete
                FROM #runs AS r2
                LEFT JOIN #qs_efficacy AS e2
                    ON e2.RunLabel = r2.RunLabel
                WHERE r2.RunLabel = r.RunLabel
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #runs AS r;
    END;

    /*
    ============================================================================
    RESULT SET 5: TOP TABLES BY MAINTENANCE COST (@ExpertMode = 1 only)
    ============================================================================
    */
    /* #261: Pre-compute total CPU for WorkloadImpactPct (can't use subquery inside aggregate) */
    DECLARE @total_qs_cpu_ms bigint = (SELECT SUM(ISNULL(su_all.QSTotalCpuMs, 0)) FROM #stat_updates AS su_all WHERE su_all.QSTotalCpuMs IS NOT NULL);

    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        SELECT TOP (@TopN)
            DatabaseName = su.DatabaseName,
            SchemaName = su.SchemaName,
            TableName = su.ObjectName,
            TotalUpdates = COUNT_BIG(*),
            TotalDurationSec = SUM(su.DurationMs) / 1000.0,  /* BUG-05 fix: was /1000 (integer division) */
            AvgDurationMs = AVG(su.DurationMs),
            MaxDurationMs = MAX(su.DurationMs),
            AvgModCounter = AVG(su.ModificationCounter),
            MaxSizeMB = MAX(su.SizeMB),
            MaxRowCount = MAX(su.RowCount_),
            FailCount = SUM(CASE WHEN su.ErrorNumber > 0 THEN 1 ELSE 0 END),
            IsHeap = MAX(CONVERT(integer, ISNULL(su.IsHeap, 0))),
            HasNorecompute = MAX(CONVERT(integer, ISNULL(su.HasNorecompute, 0))),
            DistinctStats = COUNT(DISTINCT su.StatisticsName),
            /* #261: Workload impact from QS data */
            WorkloadImpactPct = CONVERT(decimal(5, 1), 100.0 * SUM(ISNULL(su.QSTotalCpuMs, 0)) / NULLIF(@total_qs_cpu_ms, 0)),
            /* #255: Percentile rank (0.00-1.00) */
            ImpactScore = MAX(wi.ImpactScore)
        FROM #stat_updates AS su
        LEFT JOIN #workload_impact AS wi
            ON wi.DatabaseName = su.DatabaseName
            AND wi.SchemaName  = su.SchemaName
            AND wi.ObjectName  = su.ObjectName
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName
        ORDER BY SUM(su.DurationMs) DESC;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT TOP (@TopN)
            ResultSetID   = 5,
            ResultSetName = N'Top Tables',
            RowNum        = ROW_NUMBER() OVER (ORDER BY SUM(su.DurationMs) DESC),
            RowData       = (
                SELECT
                    DatabaseName     = su2.DatabaseName,
                    SchemaName       = su2.SchemaName,
                    TableName        = su2.ObjectName,
                    TotalUpdates     = COUNT_BIG(*),
                    TotalDurationSec = SUM(su2.DurationMs) / 1000.0,  /* BUG-05 fix */
                    AvgDurationMs    = AVG(su2.DurationMs),
                    MaxDurationMs    = MAX(su2.DurationMs),
                    AvgModCounter    = AVG(su2.ModificationCounter),
                    MaxSizeMB        = MAX(su2.SizeMB),
                    MaxRowCount      = MAX(su2.RowCount_),
                    FailCount        = SUM(CASE WHEN su2.ErrorNumber > 0 THEN 1 ELSE 0 END),
                    IsHeap           = MAX(CONVERT(integer, ISNULL(su2.IsHeap, 0))),
                    HasNorecompute   = MAX(CONVERT(integer, ISNULL(su2.HasNorecompute, 0))),
                    DistinctStats    = COUNT(DISTINCT su2.StatisticsName),
                    WorkloadImpactPct = CONVERT(decimal(5, 1), 100.0 * SUM(ISNULL(su2.QSTotalCpuMs, 0)) / NULLIF(@total_qs_cpu_ms, 0)),
                    ImpactScore      = MAX(wi2.ImpactScore)
                FROM #stat_updates AS su2
                LEFT JOIN #workload_impact AS wi2
                    ON wi2.DatabaseName = su2.DatabaseName
                    AND wi2.SchemaName  = su2.SchemaName
                    AND wi2.ObjectName  = su2.ObjectName
                WHERE su2.DatabaseName = su.DatabaseName
                AND   su2.SchemaName   = su.SchemaName
                AND   su2.ObjectName   = su.ObjectName
                GROUP BY su2.DatabaseName, su2.SchemaName, su2.ObjectName
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #stat_updates AS su
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName
        ORDER BY SUM(su.DurationMs) DESC;
    END;

    /*
    ============================================================================
    RESULT SET 6: FAILING STATISTICS (@ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        SELECT TOP (@TopN)
            DatabaseName = su.DatabaseName,
            SchemaName = su.SchemaName,
            TableName = su.ObjectName,
            StatisticsName = su.StatisticsName,
            FailCount = COUNT_BIG(*),
            DistinctRuns = COUNT(DISTINCT su.RunLabel),
            ErrorNumbers = STUFF((
                SELECT DISTINCT N', ' + CONVERT(nvarchar(20), su2.ErrorNumber)
                FROM #stat_updates AS su2
                WHERE su2.ErrorNumber > 0
                AND   su2.DatabaseName = su.DatabaseName
                AND   su2.SchemaName = su.SchemaName
                AND   su2.ObjectName = su.ObjectName
                AND   su2.StatisticsName = su.StatisticsName
                FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N''),
            LastError = MAX(LEFT(su.ErrorMessage, 500)),
            LastFailDate = MAX(su.StartTime),
            AvgSizeMB = AVG(su.SizeMB)
        FROM #stat_updates AS su
        WHERE su.ErrorNumber > 0
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
        ORDER BY COUNT_BIG(*) DESC;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT TOP (@TopN)
            ResultSetID   = 6,
            ResultSetName = N'Failing Statistics',
            RowNum        = ROW_NUMBER() OVER (ORDER BY COUNT_BIG(*) DESC),
            RowData       = (
                SELECT
                    DatabaseName   = su2.DatabaseName,
                    SchemaName     = su2.SchemaName,
                    TableName      = su2.ObjectName,
                    StatisticsName = su2.StatisticsName,
                    FailCount      = COUNT_BIG(*),
                    DistinctRuns   = COUNT(DISTINCT su2.RunLabel),
                    ErrorNumbers   = STUFF((
                        SELECT DISTINCT N', ' + CONVERT(nvarchar(20), su3.ErrorNumber)
                        FROM #stat_updates AS su3
                        WHERE su3.ErrorNumber > 0
                        AND   su3.DatabaseName   = su2.DatabaseName
                        AND   su3.SchemaName     = su2.SchemaName
                        AND   su3.ObjectName     = su2.ObjectName
                        AND   su3.StatisticsName = su2.StatisticsName
                        FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N''),
                    LastError      = MAX(LEFT(su2.ErrorMessage, 500)),
                    LastFailDate   = MAX(su2.StartTime),
                    AvgSizeMB      = AVG(su2.SizeMB)
                FROM #stat_updates AS su2
                WHERE su2.ErrorNumber > 0
                AND   su2.DatabaseName   = su.DatabaseName
                AND   su2.SchemaName     = su.SchemaName
                AND   su2.ObjectName     = su.ObjectName
                AND   su2.StatisticsName = su.StatisticsName
                GROUP BY su2.DatabaseName, su2.SchemaName, su2.ObjectName, su2.StatisticsName
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #stat_updates AS su
        WHERE su.ErrorNumber > 0
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
        ORDER BY COUNT_BIG(*) DESC;
    END;

    /*
    ============================================================================
    RESULT SET 7: LONG-RUNNING STATISTICS (@ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        SELECT TOP (@TopN)
            DatabaseName = su.DatabaseName,
            SchemaName = su.SchemaName,
            TableName = su.ObjectName,
            StatisticsName = su.StatisticsName,
            UpdateCount = COUNT_BIG(*),
            AvgDurationSec = AVG(su.DurationMs) / 1000.0,  /* BUG-05 fix: was /1000 (integer division) */
            MaxDurationSec = MAX(su.DurationMs) / 1000.0,
            MinDurationSec = MIN(su.DurationMs) / 1000.0,
            AvgSizeMB = AVG(su.SizeMB),
            MaxRowCount = MAX(su.RowCount_),
            AvgSamplePct = AVG(su.EffectiveSamplePct),
            SampleSources = STUFF((
                SELECT DISTINCT N', ' + su2.SampleSource
                FROM #stat_updates AS su2
                WHERE su2.ErrorNumber = 0
                AND   su2.DurationMs > @LongRunningMinutes * 60 * 1000
                AND   su2.DatabaseName = su.DatabaseName
                AND   su2.SchemaName = su.SchemaName
                AND   su2.ObjectName = su.ObjectName
                AND   su2.StatisticsName = su.StatisticsName
                AND   su2.SampleSource IS NOT NULL
                FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N''),
            IsHeap = MAX(CONVERT(integer, ISNULL(su.IsHeap, 0))),
            /* #287: Run context for interpreting why a stat was slow */
            StatsInParallel = STUFF((
                SELECT DISTINCT N', ' + ISNULL(r2.StatsInParallel, N'N')
                FROM #stat_updates AS su3
                INNER JOIN #runs AS r2 ON r2.RunLabel = su3.RunLabel
                WHERE su3.ErrorNumber = 0
                AND   su3.DurationMs > @LongRunningMinutes * 60 * 1000
                AND   su3.DatabaseName   = su.DatabaseName
                AND   su3.SchemaName     = su.SchemaName
                AND   su3.ObjectName     = su.ObjectName
                AND   su3.StatisticsName = su.StatisticsName
                FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N''),
            /* #255: Workload impact percentile */
            ImpactScore = MAX(wi.ImpactScore)
        FROM #stat_updates AS su
        LEFT JOIN #workload_impact AS wi
            ON wi.DatabaseName = su.DatabaseName
            AND wi.SchemaName  = su.SchemaName
            AND wi.ObjectName  = su.ObjectName
        WHERE su.ErrorNumber = 0
        AND   su.DurationMs > @LongRunningMinutes * 60 * 1000
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
        ORDER BY AVG(su.DurationMs) DESC;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT TOP (@TopN)
            ResultSetID   = 7,
            ResultSetName = N'Long-Running Statistics',
            RowNum        = ROW_NUMBER() OVER (ORDER BY AVG(su.DurationMs) DESC),
            RowData       = (
                SELECT
                    DatabaseName   = su2.DatabaseName,
                    SchemaName     = su2.SchemaName,
                    TableName      = su2.ObjectName,
                    StatisticsName = su2.StatisticsName,
                    UpdateCount    = COUNT_BIG(*),
                    AvgDurationSec = AVG(su2.DurationMs) / 1000.0,  /* BUG-05 fix */
                    MaxDurationSec = MAX(su2.DurationMs) / 1000.0,
                    MinDurationSec = MIN(su2.DurationMs) / 1000.0,
                    AvgSizeMB      = AVG(su2.SizeMB),
                    MaxRowCount    = MAX(su2.RowCount_),
                    AvgSamplePct   = AVG(su2.EffectiveSamplePct),
                    SampleSources  = STUFF((
                        SELECT DISTINCT N', ' + su3.SampleSource
                        FROM #stat_updates AS su3
                        WHERE su3.ErrorNumber = 0
                        AND   su3.DurationMs > @LongRunningMinutes * 60 * 1000
                        AND   su3.DatabaseName   = su2.DatabaseName
                        AND   su3.SchemaName     = su2.SchemaName
                        AND   su3.ObjectName     = su2.ObjectName
                        AND   su3.StatisticsName = su2.StatisticsName
                        AND   su3.SampleSource IS NOT NULL
                        FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N''),
                    IsHeap         = MAX(CONVERT(integer, ISNULL(su2.IsHeap, 0))),
                    StatsInParallel = STUFF((
                        SELECT DISTINCT N', ' + ISNULL(r3.StatsInParallel, N'N')
                        FROM #stat_updates AS su4
                        INNER JOIN #runs AS r3 ON r3.RunLabel = su4.RunLabel
                        WHERE su4.ErrorNumber = 0
                        AND   su4.DurationMs > @LongRunningMinutes * 60 * 1000
                        AND   su4.DatabaseName   = su2.DatabaseName
                        AND   su4.SchemaName     = su2.SchemaName
                        AND   su4.ObjectName     = su2.ObjectName
                        AND   su4.StatisticsName = su2.StatisticsName
                        FOR XML PATH(N''), TYPE).value(N'.', N'nvarchar(max)'), 1, 2, N''),
                    ImpactScore    = MAX(wi3.ImpactScore)
                FROM #stat_updates AS su2
                LEFT JOIN #workload_impact AS wi3
                    ON wi3.DatabaseName = su2.DatabaseName
                    AND wi3.SchemaName  = su2.SchemaName
                    AND wi3.ObjectName  = su2.ObjectName
                WHERE su2.ErrorNumber = 0
                AND   su2.DurationMs > @LongRunningMinutes * 60 * 1000
                AND   su2.DatabaseName   = su.DatabaseName
                AND   su2.SchemaName     = su.SchemaName
                AND   su2.ObjectName     = su.ObjectName
                AND   su2.StatisticsName = su.StatisticsName
                GROUP BY su2.DatabaseName, su2.SchemaName, su2.ObjectName, su2.StatisticsName
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #stat_updates AS su
        WHERE su.ErrorNumber = 0
        AND   su.DurationMs > @LongRunningMinutes * 60 * 1000
        GROUP BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
        ORDER BY AVG(su.DurationMs) DESC;
    END;

    /*
    ============================================================================
    RESULT SET 8: PARAMETER CHANGE HISTORY (@ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        SELECT
            RunLabel,
            StartTime,
            [Version],
            TimeLimit,
            ModificationThreshold,
            TieredThresholds,
            ThresholdLogic,
            SortOrder,
            QueryStorePriority,
            StatisticsSample,
            StatsInParallel,
            Preset,
            LongRunningThresholdMinutes,
            LongRunningSamplePercent,
            /* GroupByJoinPattern removed from RS8 (xmxs): column dropped from #runs */
            FilteredStatsMode,
            BatchLimit,
            FailFast
        FROM #runs
        ORDER BY StartTime DESC;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 8,
            ResultSetName = N'Parameter Change History',
            RowNum        = ROW_NUMBER() OVER (ORDER BY r.StartTime DESC),
            RowData       = (
                SELECT
                    RunLabel                    = r2.RunLabel,
                    StartTime                   = r2.StartTime,
                    [Version]                   = r2.[Version],
                    TimeLimit                   = r2.TimeLimit,
                    ModificationThreshold       = r2.ModificationThreshold,
                    TieredThresholds            = r2.TieredThresholds,
                    ThresholdLogic              = r2.ThresholdLogic,
                    SortOrder                   = r2.SortOrder,
                    QueryStorePriority          = r2.QueryStorePriority,
                    StatisticsSample            = r2.StatisticsSample,
                    StatsInParallel             = r2.StatsInParallel,
                    Preset                      = r2.Preset,
                    LongRunningThresholdMinutes = r2.LongRunningThresholdMinutes,
                    LongRunningSamplePercent    = r2.LongRunningSamplePercent,
                    /* GroupByJoinPattern removed (xmxs) */
                    FilteredStatsMode           = r2.FilteredStatsMode,
                    BatchLimit                  = r2.BatchLimit,
                    FailFast                    = r2.FailFast
                FROM #runs AS r2
                WHERE r2.RunLabel = r.RunLabel
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM #runs AS r;
    END;

    /*
    ============================================================================
    RESULT SET 9: OBFUSCATION MAP (conditional, @ExpertMode = 1 only)
    ============================================================================
    */
    IF @Obfuscate = 1 AND @ExpertMode = 1
    BEGIN
        IF @SingleResultSet = 0
        BEGIN
            SELECT
                ObjectType,
                OriginalName,
                ObfuscatedName
            FROM #obfuscation_map
            ORDER BY ObjectType, OriginalName;
        END
        ELSE
        BEGIN
            /* Map excluded from single result set to prevent real names leaking into exportable output.
               Use @ObfuscationMapTable to persist the map, or use multi-result-set mode (default). */
            RAISERROR(N'Obfuscation map excluded from single result set. Use @ObfuscationMapTable to persist the map.', 10, 1) WITH NOWAIT;
        END;
    END;

    /*
    ============================================================================
    RESULT SET 10: EFFICACY TREND (Weekly, broad window -- @ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        /* #269: Per-run top-5 concentration for Top5ConcentrationPct column */
        ;WITH run_concentration AS
        (
            SELECT
                su.RunLabel,
                Top5CpuPct = CASE WHEN SUM(ISNULL(su.QSTotalCpuMs, 0)) = 0 THEN NULL
                    ELSE CONVERT(decimal(5, 1), 100.0 *
                        SUM(CASE WHEN rk.StatRank <= 5 THEN ISNULL(su.QSTotalCpuMs, 0) ELSE 0 END)
                        / NULLIF(SUM(ISNULL(su.QSTotalCpuMs, 0)), 0))
                    END
            FROM #stat_updates AS su
            CROSS APPLY (
                SELECT StatRank = ROW_NUMBER() OVER (
                    PARTITION BY su.RunLabel
                    ORDER BY ISNULL(su.QSTotalCpuMs, 0) DESC, su.ID)
            ) AS rk
            WHERE (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
            AND   su.QSTotalCpuMs IS NOT NULL
            GROUP BY su.RunLabel
        ),
        weekly_data AS
        (
            SELECT
                week_start   = DATEADD(DAY, -(DATEPART(WEEKDAY, e.StartTime) + @@DATEFIRST - 2) % 7, CONVERT(date, e.StartTime)),
                e.RunLabel,
                e.IsQSRun,
                e.HighCpuInFirstQuartilePct,
                e.MinutesToHighCpuComplete,
                e.WorkloadCoveragePct,
                e.CompletionPct,
                e.AvgSecPerStat,
                e.SortOrder,
                rc.Top5CpuPct,
                GBPerMin = CASE WHEN r.DurationSeconds > 0 AND r.TotalGB IS NOT NULL
                    THEN CONVERT(decimal(10, 2), r.TotalGB / (r.DurationSeconds / 60.0)) ELSE NULL END
            FROM #qs_efficacy AS e
            LEFT JOIN run_concentration AS rc ON rc.RunLabel = e.RunLabel
            LEFT JOIN #runs AS r ON r.RunLabel = e.RunLabel
            WHERE e.StartTime >= DATEADD(DAY, -@EfficacyDaysBack, GETDATE())
        ),
        weekly_agg AS
        (
            SELECT
                week_start,
                RunCount                = COUNT_BIG(*),
                SortStrategy            = CASE
                                              WHEN MIN(CONVERT(int, w.IsQSRun)) = 1 THEN N'Query Store CPU'
                                              WHEN MAX(CONVERT(int, w.IsQSRun)) = 0 THEN N'Modification Counter'
                                              ELSE N'Mixed'
                                          END,
                HighCpuFirstQuartilePct  = AVG(w.HighCpuInFirstQuartilePct),
                AvgMinutesToHighCpu     = AVG(w.MinutesToHighCpuComplete),
                WorkloadCoveragePct     = AVG(w.WorkloadCoveragePct),
                CompletionPct           = AVG(w.CompletionPct),
                AvgSecPerStat           = AVG(w.AvgSecPerStat),
                AvgGBPerMin             = AVG(w.GBPerMin),
                Top5ConcentrationPct    = AVG(w.Top5CpuPct)  /* #269 */
            FROM weekly_data AS w
            GROUP BY week_start
        ),
        weekly_ranked AS
        (
            SELECT
                wa.*,
                WeekLabel = N'W' + RIGHT(N'00' + CONVERT(nvarchar(3), ROW_NUMBER() OVER (ORDER BY wa.week_start)), 2),
                prior_composite = LAG(
                    ISNULL(wa.HighCpuFirstQuartilePct, 0) + ISNULL(wa.WorkloadCoveragePct, 0) + ISNULL(wa.CompletionPct, 0)
                ) OVER (ORDER BY wa.week_start),
                current_composite = ISNULL(wa.HighCpuFirstQuartilePct, 0) + ISNULL(wa.WorkloadCoveragePct, 0) + ISNULL(wa.CompletionPct, 0),
                prior_run_count = LAG(wa.RunCount) OVER (ORDER BY wa.week_start)
            FROM weekly_agg AS wa
        )
        SELECT
            WeekStart               = wr.week_start,
            WeekLabel               = wr.WeekLabel,
            RunCount                = wr.RunCount,
            SortStrategy            = wr.SortStrategy,
            HighCpuFirstQuartilePct = wr.HighCpuFirstQuartilePct,
            AvgMinutesToHighCpu     = wr.AvgMinutesToHighCpu,
            WorkloadCoveragePct     = wr.WorkloadCoveragePct,
            CompletionPct           = wr.CompletionPct,
            AvgSecPerStat           = wr.AvgSecPerStat,
            AvgGBPerMin             = wr.AvgGBPerMin,
            TrendDirection          = CASE
                                          WHEN wr.prior_composite IS NULL THEN N'N/A'
                                          WHEN wr.RunCount < 2 OR ISNULL(wr.prior_run_count, 0) < 2 THEN N'INSUFFICIENT_DATA'
                                          WHEN wr.current_composite > wr.prior_composite * 1.02 THEN N'IMPROVING'
                                          WHEN wr.prior_composite > 0
                                               AND (wr.current_composite < wr.prior_composite - 10
                                                    OR wr.current_composite < wr.prior_composite * 0.85)
                                               THEN CASE WHEN wr.SortStrategy = N'Modification Counter'
                                                         THEN N'DEGRADING (workload-driven)'
                                                         ELSE N'DEGRADING'
                                                    END
                                          ELSE CASE WHEN wr.SortStrategy = N'Modification Counter'
                                                    THEN N'STABLE (workload-driven)'
                                                    ELSE N'STABLE'
                                               END
                                      END,
            Top5ConcentrationPct    = wr.Top5ConcentrationPct  /* #269 */
        FROM weekly_ranked AS wr
        ORDER BY wr.week_start;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        /* Use temp table approach for RS10 SingleResultSet to avoid complex nested subquery FOR JSON */
        DECLARE @rs9_json nvarchar(max);

        /* #269: Same run_concentration CTE for SingleResultSet path */
        ;WITH run_concentration_s AS
        (
            SELECT
                su.RunLabel,
                Top5CpuPct = CASE WHEN SUM(ISNULL(su.QSTotalCpuMs, 0)) = 0 THEN NULL
                    ELSE CONVERT(decimal(5, 1), 100.0 *
                        SUM(CASE WHEN rk.StatRank <= 5 THEN ISNULL(su.QSTotalCpuMs, 0) ELSE 0 END)
                        / NULLIF(SUM(ISNULL(su.QSTotalCpuMs, 0)), 0))
                    END
            FROM #stat_updates AS su
            CROSS APPLY (
                SELECT StatRank = ROW_NUMBER() OVER (
                    PARTITION BY su.RunLabel
                    ORDER BY ISNULL(su.QSTotalCpuMs, 0) DESC, su.ID)
            ) AS rk
            WHERE (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
            AND   su.QSTotalCpuMs IS NOT NULL
            GROUP BY su.RunLabel
        ),
        weekly_data_s AS
        (
            SELECT
                week_start   = DATEADD(DAY, -(DATEPART(WEEKDAY, e.StartTime) + @@DATEFIRST - 2) % 7, CONVERT(date, e.StartTime)),
                e.IsQSRun,
                e.HighCpuInFirstQuartilePct,
                e.MinutesToHighCpuComplete,
                e.WorkloadCoveragePct,
                e.CompletionPct,
                e.AvgSecPerStat,
                rc.Top5CpuPct,
                GBPerMin = CASE WHEN r.DurationSeconds > 0 AND r.TotalGB IS NOT NULL
                    THEN CONVERT(decimal(10, 2), r.TotalGB / (r.DurationSeconds / 60.0)) ELSE NULL END
            FROM #qs_efficacy AS e
            LEFT JOIN run_concentration_s AS rc ON rc.RunLabel = e.RunLabel
            LEFT JOIN #runs AS r ON r.RunLabel = e.RunLabel
            WHERE e.StartTime >= DATEADD(DAY, -@EfficacyDaysBack, GETDATE())
        ),
        weekly_agg_s AS
        (
            SELECT
                week_start,
                RunCount                = COUNT_BIG(*),
                SortStrategy            = CASE
                                              WHEN MIN(CONVERT(int, w.IsQSRun)) = 1 THEN N'Query Store CPU'
                                              WHEN MAX(CONVERT(int, w.IsQSRun)) = 0 THEN N'Modification Counter'
                                              ELSE N'Mixed'
                                          END,
                HighCpuFirstQuartilePct  = AVG(w.HighCpuInFirstQuartilePct),
                AvgMinutesToHighCpu     = AVG(w.MinutesToHighCpuComplete),
                WorkloadCoveragePct     = AVG(w.WorkloadCoveragePct),
                CompletionPct           = AVG(w.CompletionPct),
                AvgSecPerStat           = AVG(w.AvgSecPerStat),
                AvgGBPerMin             = AVG(w.GBPerMin),
                Top5ConcentrationPct    = AVG(w.Top5CpuPct)  /* #269 */
            FROM weekly_data_s AS w
            GROUP BY week_start
        ),
        weekly_ranked_s AS
        (
            SELECT
                wa.*,
                WeekLabel = N'W' + RIGHT(N'00' + CONVERT(nvarchar(3), ROW_NUMBER() OVER (ORDER BY wa.week_start)), 2),
                prior_composite = LAG(
                    ISNULL(wa.HighCpuFirstQuartilePct, 0) + ISNULL(wa.WorkloadCoveragePct, 0) + ISNULL(wa.CompletionPct, 0)
                ) OVER (ORDER BY wa.week_start),
                current_composite = ISNULL(wa.HighCpuFirstQuartilePct, 0) + ISNULL(wa.WorkloadCoveragePct, 0) + ISNULL(wa.CompletionPct, 0),
                prior_run_count = LAG(wa.RunCount) OVER (ORDER BY wa.week_start)
            FROM weekly_agg_s AS wa
        )
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 10,
            ResultSetName = N'Efficacy Trend',
            RowNum        = ROW_NUMBER() OVER (ORDER BY wr.week_start),
            RowData       = (
                SELECT
                    WeekStart               = wr.week_start,
                    WeekLabel               = wr.WeekLabel,
                    RunCount                = wr.RunCount,
                    SortStrategy            = wr.SortStrategy,
                    HighCpuFirstQuartilePct = wr.HighCpuFirstQuartilePct,
                    AvgMinutesToHighCpu     = wr.AvgMinutesToHighCpu,
                    WorkloadCoveragePct     = wr.WorkloadCoveragePct,
                    CompletionPct           = wr.CompletionPct,
                    AvgSecPerStat           = wr.AvgSecPerStat,
                    AvgGBPerMin             = wr.AvgGBPerMin,
                    TrendDirection          = CASE
                                                  WHEN wr.prior_composite IS NULL THEN N'N/A'
                                                  WHEN wr.RunCount < 2 OR ISNULL(wr.prior_run_count, 0) < 2 THEN N'INSUFFICIENT_DATA'
                                                  WHEN wr.current_composite > wr.prior_composite * 1.02 THEN N'IMPROVING'
                                                  WHEN wr.prior_composite > 0
                                                       AND (wr.current_composite < wr.prior_composite - 10
                                                            OR wr.current_composite < wr.prior_composite * 0.85)
                                                       THEN CASE WHEN wr.SortStrategy = N'Modification Counter'
                                                                 THEN N'DEGRADING (workload-driven)'
                                                                 ELSE N'DEGRADING'
                                                            END
                                                  ELSE CASE WHEN wr.SortStrategy = N'Modification Counter'
                                                            THEN N'STABLE (workload-driven)'
                                                            ELSE N'STABLE'
                                                       END
                                              END,
                    Top5ConcentrationPct    = wr.Top5ConcentrationPct  /* #269 */
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM weekly_ranked_s AS wr;
    END;

    /*
    ============================================================================
    RESULT SET 11: EFFICACY DETAIL (Per-run, close-up window -- @ExpertMode = 1 only)
    ============================================================================
    */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        ;WITH detail_runs AS
        (
            SELECT
                e.*,
                prior_completion = LAG(e.CompletionPct) OVER (ORDER BY e.StartTime),
                prior_minutes    = LAG(e.MinutesToHighCpuComplete) OVER (ORDER BY e.StartTime)
            FROM #qs_efficacy AS e
            WHERE e.StartTime >= DATEADD(DAY, -@EfficacyDetailDays, GETDATE())
        )
        SELECT
            RunLabel                = dr.RunLabel,
            StartTime               = dr.StartTime,
            SortStrategy            = CASE
                                          WHEN dr.IsQSRun = 1 THEN N'Query Store CPU'
                                          ELSE ISNULL(dr.SortOrder, N'Modification Counter')
                                      END,
            StatsFound              = dr.StatsFound,
            StatsProcessed          = dr.StatsProcessed,
            CompletionPct           = dr.CompletionPct,
            HighCpuInFirstQuartilePct = dr.HighCpuInFirstQuartilePct,
            MinutesToHighCpuComplete = dr.MinutesToHighCpuComplete,
            WorkloadCoveragePct     = dr.WorkloadCoveragePct,
            AvgSecPerStat           = dr.AvgSecPerStat,
            StopReason              = dr.StopReason,
            DeltaVsPrior            = CASE
                                          WHEN dr.prior_completion IS NULL THEN N'(first run in window)'
                                          ELSE
                                              CASE
                                                  WHEN dr.CompletionPct > dr.prior_completion
                                                  THEN N'+' + CONVERT(nvarchar(10), CONVERT(integer, dr.CompletionPct - dr.prior_completion)) + N'% completion'
                                                  WHEN dr.CompletionPct < dr.prior_completion
                                                  THEN CONVERT(nvarchar(10), CONVERT(integer, dr.CompletionPct - dr.prior_completion)) + N'% completion'
                                                  ELSE N'0% completion'
                                              END
                                              + CASE
                                                  WHEN dr.prior_minutes IS NOT NULL AND dr.MinutesToHighCpuComplete IS NOT NULL
                                                  THEN N', ' + CASE
                                                      WHEN dr.MinutesToHighCpuComplete < dr.prior_minutes
                                                      THEN N'-' + CONVERT(nvarchar(20), CONVERT(integer, dr.prior_minutes - dr.MinutesToHighCpuComplete)) + N'min to critical'
                                                      WHEN dr.MinutesToHighCpuComplete > dr.prior_minutes
                                                      THEN N'+' + CONVERT(nvarchar(20), CONVERT(integer, dr.MinutesToHighCpuComplete - dr.prior_minutes)) + N'min to critical'
                                                      ELSE N'0min to critical'
                                                  END
                                                  ELSE N''
                                              END
                                      END
        FROM detail_runs AS dr
        ORDER BY dr.StartTime DESC;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        /* GAP-G fix: Include DeltaVsPrior in SingleResultSet mode (matching direct output).
           Uses correlated subquery with LAG window function via derived table. */
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT
            ResultSetID   = 11,
            ResultSetName = N'Efficacy Detail',
            RowNum        = ROW_NUMBER() OVER (ORDER BY dr.StartTime DESC),
            RowData       = N'{'
                + N'"RunLabel":' + CASE WHEN dr.RunLabel IS NULL THEN N'null' ELSE N'"' + dr.RunLabel + N'"' END
                + N',"StartTime":"' + CONVERT(nvarchar(30), dr.StartTime, 126) + N'"'
                + N',"SortStrategy":"' + CASE WHEN dr.IsQSRun = 1 THEN N'Query Store CPU' ELSE ISNULL(dr.SortOrder, N'Modification Counter') END + N'"'
                + N',"StatsFound":' + ISNULL(CONVERT(nvarchar(10), dr.StatsFound), N'null')
                + N',"StatsProcessed":' + ISNULL(CONVERT(nvarchar(10), dr.StatsProcessed), N'null')
                + N',"CompletionPct":' + ISNULL(CONVERT(nvarchar(10), dr.CompletionPct), N'null')
                + N',"HighCpuInFirstQuartilePct":' + ISNULL(CONVERT(nvarchar(10), dr.HighCpuInFirstQuartilePct), N'null')
                + N',"MinutesToHighCpuComplete":' + ISNULL(CONVERT(nvarchar(20), dr.MinutesToHighCpuComplete), N'null')
                + N',"WorkloadCoveragePct":' + ISNULL(CONVERT(nvarchar(10), dr.WorkloadCoveragePct), N'null')
                + N',"AvgSecPerStat":' + ISNULL(CONVERT(nvarchar(20), dr.AvgSecPerStat), N'null')
                + N',"StopReason":' + CASE WHEN dr.StopReason IS NULL THEN N'null' ELSE N'"' + dr.StopReason + N'"' END
                + N',"DeltaVsPrior":"' + CASE
                    WHEN dr.prior_completion IS NULL THEN N'(first run in window)'
                    ELSE CASE
                        WHEN dr.CompletionPct > dr.prior_completion
                        THEN N'+' + CONVERT(nvarchar(10), CONVERT(integer, dr.CompletionPct - dr.prior_completion)) + N'% completion'
                        WHEN dr.CompletionPct < dr.prior_completion
                        THEN CONVERT(nvarchar(10), CONVERT(integer, dr.CompletionPct - dr.prior_completion)) + N'% completion'
                        ELSE N'0% completion'
                    END
                    + CASE
                        WHEN dr.prior_minutes IS NOT NULL AND dr.MinutesToHighCpuComplete IS NOT NULL
                        THEN N', ' + CASE
                            WHEN dr.MinutesToHighCpuComplete < dr.prior_minutes
                            THEN N'-' + CONVERT(nvarchar(20), CONVERT(integer, dr.prior_minutes - dr.MinutesToHighCpuComplete)) + N'min to critical'
                            WHEN dr.MinutesToHighCpuComplete > dr.prior_minutes
                            THEN N'+' + CONVERT(nvarchar(20), CONVERT(integer, dr.MinutesToHighCpuComplete - dr.prior_minutes)) + N'min to critical'
                            ELSE N'0min to critical'
                        END
                        ELSE N''
                    END
                END + N'"'
                + N'}'
        FROM (
            SELECT
                e.*,
                prior_completion = LAG(e.CompletionPct) OVER (ORDER BY e.StartTime),
                prior_minutes    = LAG(e.MinutesToHighCpuComplete) OVER (ORDER BY e.StartTime)
            FROM #qs_efficacy AS e
            WHERE e.StartTime >= DATEADD(DAY, -@EfficacyDetailDays, GETDATE())
        ) AS dr;
    END;

    /*
    ============================================================================
    RESULT SET 12: HIGH-CPU STAT POSITIONS (Most Recent Run -- @ExpertMode = 1 only)
    ============================================================================
    */
    /* gh-474: Declared at outer scope so both the standalone result-set branch and the
       SingleResultSet branch below can reference it.  Previously only the non-SingleResultSet
       branch declared it, causing the SingleResultSet path to reference an undefined variable. */
    DECLARE @latest_qs_run nvarchar(100) = (
        SELECT TOP (1) e.RunLabel
        FROM #qs_efficacy AS e
        WHERE e.IsQSRun = 1
        ORDER BY e.StartTime DESC
    );

    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        ;WITH rs12_ranked AS
        (
            SELECT
                WorkloadRank        = ROW_NUMBER() OVER (ORDER BY ISNULL(su.QSTotalCpuMs, 0) DESC, su.ID),
                DatabaseName        = su.DatabaseName,
                SchemaName          = su.SchemaName,
                TableName           = su.ObjectName,
                StatisticsName      = su.StatisticsName,
                ProcessingPosition  = ISNULL(su.ProcessingPosition, ROW_NUMBER() OVER (ORDER BY su.ID)),
                TotalQueryCpuMs     = su.QSTotalCpuMs,
                TotalExecutions     = su.QSTotalExecutions,
                PlanCount           = su.QSPlanCount,
                UpdateDurationMs    = su.DurationMs,
                QualifyReason       = su.QualifyReason,
                total_stats         = COUNT_BIG(*) OVER (),
                total_cpu           = SUM(ISNULL(su.QSTotalCpuMs, 0)) OVER ()
            FROM #stat_updates AS su
            WHERE su.RunLabel = @latest_qs_run
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
        )
        SELECT TOP (@TopN)
            WorkloadRank,
            DatabaseName,
            SchemaName,
            TableName,
            StatisticsName,
            ProcessingPosition,
            TotalQueryCpuMs,
            TotalExecutions,
            PlanCount,
            UpdateDurationMs,
            QualifyReason,
            /* #262: Percentile rank and cumulative CPU */
            WorkloadRankPct   = CONVERT(decimal(5, 1), 100.0 * WorkloadRank / NULLIF(total_stats, 0)),
            CumulativeCpuPct  = CONVERT(decimal(5, 1), 100.0 * SUM(ISNULL(TotalQueryCpuMs, 0)) OVER (ORDER BY WorkloadRank) / NULLIF(total_cpu, 0))
        FROM rs12_ranked
        ORDER BY WorkloadRank;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        /* #262: Use temp table approach for RS12 SingleResultSet to compute cumulative correctly */
        ;WITH rs12_ranked_s AS
        (
            SELECT
                su.ID,
                su.RunLabel,
                WorkloadRank        = ROW_NUMBER() OVER (ORDER BY ISNULL(su.QSTotalCpuMs, 0) DESC, su.ID),
                DatabaseName        = su.DatabaseName,
                SchemaName          = su.SchemaName,
                TableName           = su.ObjectName,
                StatisticsName      = su.StatisticsName,
                ProcessingPosition  = ISNULL(su.ProcessingPosition, ROW_NUMBER() OVER (ORDER BY su.ID)),
                TotalQueryCpuMs     = su.QSTotalCpuMs,
                TotalExecutions     = su.QSTotalExecutions,
                PlanCount           = su.QSPlanCount,
                UpdateDurationMs    = su.DurationMs,
                QualifyReason       = su.QualifyReason,
                total_stats         = COUNT_BIG(*) OVER (),
                total_cpu           = SUM(ISNULL(su.QSTotalCpuMs, 0)) OVER ()
            FROM #stat_updates AS su
            WHERE su.RunLabel = @latest_qs_run
            AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
        )
        INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
        SELECT TOP (@TopN)
            ResultSetID   = 12,
            ResultSetName = N'High-CPU Stat Positions',
            RowNum        = r.WorkloadRank,
            RowData       = (
                SELECT
                    WorkloadRank        = r2.WorkloadRank,
                    DatabaseName        = r2.DatabaseName,
                    SchemaName          = r2.SchemaName,
                    TableName           = r2.TableName,
                    StatisticsName      = r2.StatisticsName,
                    ProcessingPosition  = r2.ProcessingPosition,
                    TotalQueryCpuMs     = r2.TotalQueryCpuMs,
                    TotalExecutions     = r2.TotalExecutions,
                    PlanCount           = r2.PlanCount,
                    UpdateDurationMs    = r2.UpdateDurationMs,
                    QualifyReason       = r2.QualifyReason,
                    WorkloadRankPct     = CONVERT(decimal(5, 1), 100.0 * r2.WorkloadRank / NULLIF(r2.total_stats, 0)),
                    CumulativeCpuPct    = CONVERT(decimal(5, 1), 100.0 * SUM(ISNULL(r2.TotalQueryCpuMs, 0)) OVER (ORDER BY r2.WorkloadRank) / NULLIF(r2.total_cpu, 0))
                FROM rs12_ranked_s AS r2
                WHERE r2.ID = r.ID
                FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
            )
        FROM rs12_ranked_s AS r
        ORDER BY r.WorkloadRank;
    END;

    /*
    ============================================================================
    RESULT SET 13: QS PERFORMANCE CORRELATION (Per-stat CPU trend -- @ExpertMode = 1 only)
    Shows how Query Store CPU metrics change for each statistic across runs.
    Leadership takeaway: "Are the queries actually getting faster after we update these statistics?"
    ============================================================================
    */
    /* BUG-B fix: RS13 now includes per-execution CPU normalization columns alongside raw totals */
    /* w5p2 / gh-532: when @i8_data_status <> AVAILABLE the main CTE returns zero rows;
       emit a single informational sentinel row so users can distinguish 'no improvement'
       from 'no data at all'.  The AVAILABLE path is unchanged (existing tests pass). */
    IF @ExpertMode = 1 AND @SingleResultSet = 0
    BEGIN
        IF @i8_data_status = N'AVAILABLE'
        BEGIN
            ;WITH stat_trend AS
            (
                SELECT
                    su.DatabaseName,
                    su.SchemaName,
                    su.ObjectName,
                    su.StatisticsName,
                    su.QSTotalCpuMs,
                    su.QSTotalExecutions,
                    su.QSPlanCount,
                    su.QSTotalMemoryGrantKB,
                    su.QSTotalTempdbPages,
                    cpu_per_exec = CONVERT(decimal(18, 4), su.QSTotalCpuMs * 1.0 / NULLIF(su.QSTotalExecutions, 0)),
                    su.RunLabel,
                    r.StartTime,
                    appearance_num = ROW_NUMBER() OVER (
                        PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                        ORDER BY r.StartTime
                    ),
                    total_appearances = COUNT_BIG(*) OVER (
                        PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                    )
                FROM #stat_updates AS su
                INNER JOIN #runs AS r
                    ON r.RunLabel = su.RunLabel
                WHERE su.QSTotalCpuMs IS NOT NULL
                AND   su.QSTotalCpuMs > 0
                AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
            ),
            first_last AS
            (
                SELECT
                    DatabaseName, SchemaName, ObjectName, StatisticsName,
                    Appearances      = MAX(total_appearances),
                    FirstRunDate     = MAX(CASE WHEN appearance_num = 1 THEN StartTime END),
                    LastRunDate      = MAX(CASE WHEN appearance_num = total_appearances THEN StartTime END),
                    FirstCpuMs       = MAX(CASE WHEN appearance_num = 1 THEN QSTotalCpuMs END),
                    LastCpuMs        = MAX(CASE WHEN appearance_num = total_appearances THEN QSTotalCpuMs END),
                    FirstCpuPerExec  = MAX(CASE WHEN appearance_num = 1 THEN cpu_per_exec END),
                    LastCpuPerExec   = MAX(CASE WHEN appearance_num = total_appearances THEN cpu_per_exec END),
                    FirstExecs       = MAX(CASE WHEN appearance_num = 1 THEN QSTotalExecutions END),
                    LastExecs        = MAX(CASE WHEN appearance_num = total_appearances THEN QSTotalExecutions END),
                    FirstPlans       = MAX(CASE WHEN appearance_num = 1 THEN QSPlanCount END),
                    LastPlans        = MAX(CASE WHEN appearance_num = total_appearances THEN QSPlanCount END),
                    FirstMemoryGrantKB = MAX(CASE WHEN appearance_num = 1 THEN QSTotalMemoryGrantKB END),
                    LastMemoryGrantKB  = MAX(CASE WHEN appearance_num = total_appearances THEN QSTotalMemoryGrantKB END),
                    FirstTempdbPages   = MAX(CASE WHEN appearance_num = 1 THEN QSTotalTempdbPages END),
                    LastTempdbPages    = MAX(CASE WHEN appearance_num = total_appearances THEN QSTotalTempdbPages END)
                FROM stat_trend
                WHERE total_appearances >= 2
                GROUP BY DatabaseName, SchemaName, ObjectName, StatisticsName
            )
            SELECT TOP (@TopN)
                fl.DatabaseName,
                fl.SchemaName,
                TableName               = fl.ObjectName,
                fl.StatisticsName,
                fl.Appearances,
                fl.FirstRunDate,
                fl.LastRunDate,
                fl.FirstCpuMs,
                fl.LastCpuMs,
                CpuChangePct            = CASE WHEN fl.FirstCpuMs > 0
                                               THEN CONVERT(decimal(10, 1), (fl.LastCpuMs - fl.FirstCpuMs) * 100.0 / fl.FirstCpuMs)
                                               ELSE NULL
                                          END,
                FirstCpuPerExec         = CONVERT(decimal(10, 2), fl.FirstCpuPerExec),
                LastCpuPerExec          = CONVERT(decimal(10, 2), fl.LastCpuPerExec),
                CpuPerExecChangePct     = CASE WHEN fl.FirstCpuPerExec > 0
                                               THEN CONVERT(decimal(10, 1), (fl.LastCpuPerExec - fl.FirstCpuPerExec) * 100.0 / fl.FirstCpuPerExec)
                                               ELSE NULL
                                          END,
                CpuTrend                = CASE
                                              WHEN fl.FirstCpuPerExec > 0 AND fl.LastCpuPerExec < fl.FirstCpuPerExec * 0.95 THEN N'IMPROVING'
                                              WHEN fl.FirstCpuPerExec > 0 AND fl.LastCpuPerExec > fl.FirstCpuPerExec * 1.05 THEN N'DEGRADING'
                                              ELSE N'STABLE'
                                          END,
                fl.FirstExecs,
                fl.LastExecs,
                fl.FirstPlans,
                fl.LastPlans,
                ForcedPlanCount         = ISNULL(fp.ForcedPlanCount, 0),
                PlanTrend               = CASE
                                              WHEN fl.LastPlans > fl.FirstPlans AND ISNULL(fp.ForcedPlanCount, 0) > 0
                                                  THEN N'MORE PLANS (forced plan at risk)'
                                              WHEN fl.LastPlans > fl.FirstPlans THEN N'MORE PLANS (possible regression)'
                                              WHEN fl.LastPlans < fl.FirstPlans THEN N'FEWER PLANS (consolidating)'
                                              ELSE N'STABLE'
                                          END,
                fl.FirstMemoryGrantKB,
                fl.LastMemoryGrantKB,
                MemoryGrantChangePct    = CASE WHEN ISNULL(fl.FirstMemoryGrantKB, 0) > 0
                                               THEN CONVERT(decimal(10, 1), (fl.LastMemoryGrantKB - fl.FirstMemoryGrantKB) * 100.0 / fl.FirstMemoryGrantKB)
                                               ELSE NULL
                                          END,
                MemoryGrantTrend        = CASE
                                              WHEN ISNULL(fl.FirstMemoryGrantKB, 0) > 0 AND fl.LastMemoryGrantKB < fl.FirstMemoryGrantKB * 0.95 THEN N'IMPROVING'
                                              WHEN ISNULL(fl.FirstMemoryGrantKB, 0) > 0 AND fl.LastMemoryGrantKB > fl.FirstMemoryGrantKB * 1.05 THEN N'DEGRADING'
                                              WHEN fl.FirstMemoryGrantKB IS NULL OR fl.LastMemoryGrantKB IS NULL THEN NULL
                                              ELSE N'STABLE'
                                          END,
                fl.FirstTempdbPages,
                fl.LastTempdbPages,
                TempdbChangePct         = CASE WHEN ISNULL(fl.FirstTempdbPages, 0) > 0
                                               THEN CONVERT(decimal(10, 1), (fl.LastTempdbPages - fl.FirstTempdbPages) * 100.0 / fl.FirstTempdbPages)
                                               ELSE NULL
                                          END,
                TempdbTrend             = CASE
                                              WHEN ISNULL(fl.FirstTempdbPages, 0) > 0 AND fl.LastTempdbPages < fl.FirstTempdbPages * 0.95 THEN N'IMPROVING'
                                              WHEN ISNULL(fl.FirstTempdbPages, 0) > 0 AND fl.LastTempdbPages > fl.FirstTempdbPages * 1.05 THEN N'DEGRADING'
                                              WHEN fl.FirstTempdbPages IS NULL OR fl.LastTempdbPages IS NULL THEN NULL
                                              ELSE N'STABLE'
                                          END
            FROM first_last AS fl
            LEFT JOIN #forced_plans AS fp
                ON fp.DatabaseName = fl.DatabaseName
                AND fp.ObjectName = fl.ObjectName
            ORDER BY
                CASE
                    WHEN fl.FirstCpuPerExec > 0 AND fl.LastCpuPerExec < fl.FirstCpuPerExec * 0.95 THEN 1
                    WHEN fl.FirstCpuPerExec > 0 AND fl.LastCpuPerExec > fl.FirstCpuPerExec * 1.05 THEN 2
                    ELSE 3
                END,
                ISNULL(fl.FirstCpuMs, 0) DESC;
        END
        ELSE
        BEGIN
            /* w5p2 / gh-532: sparse / no-data path -- return one sentinel row so callers
               can distinguish an empty result from a result with no improvement.
               All numeric/date columns are NULL; the reason is encoded in string columns. */
            DECLARE @rs13_reason nvarchar(max) = CONVERT(nvarchar(max), N'');

            SET @rs13_reason =
                CASE @i8_data_status
                    WHEN N'UNAVAILABLE'
                    THEN N'No QS CPU data captured in any run within the analysis window. '
                        + N'Enable Query Store and configure sp_StatUpdate with @QueryStore = N''CPU''. '
                        + N'ALTER DATABASE [YourDb] SET QUERY_STORE = ON;'
                    WHEN N'INSUFFICIENT_HISTORY'
                    THEN N'Fewer than 2 runs contain matching QS CPU data ('
                        + CONVERT(nvarchar(10), @i8_qs_cpu_runs)
                        + N' QS-CPU run(s) found; need 2+ and at least 1 stat in 2+ runs). '
                        + N'Run sp_StatUpdate with @QueryStore = N''CPU'' across additional maintenance windows.'
                    ELSE N'DataStatus: ' + @i8_data_status
                END;

            SELECT
                DatabaseName            = N'[NO DATA]',
                SchemaName              = N'[NO DATA]',
                TableName               = N'[NO DATA]',
                StatisticsName          = @rs13_reason,
                Appearances             = CONVERT(integer, NULL),
                FirstRunDate            = CONVERT(datetime2(0), NULL),
                LastRunDate             = CONVERT(datetime2(0), NULL),
                FirstCpuMs              = CONVERT(bigint, NULL),
                LastCpuMs               = CONVERT(bigint, NULL),
                CpuChangePct            = CONVERT(decimal(10, 1), NULL),
                FirstCpuPerExec         = CONVERT(decimal(10, 2), NULL),
                LastCpuPerExec          = CONVERT(decimal(10, 2), NULL),
                CpuPerExecChangePct     = CONVERT(decimal(10, 1), NULL),
                CpuTrend                = CONVERT(nvarchar(30), NULL),
                FirstExecs              = CONVERT(bigint, NULL),
                LastExecs               = CONVERT(bigint, NULL),
                FirstPlans              = CONVERT(integer, NULL),
                LastPlans               = CONVERT(integer, NULL),
                ForcedPlanCount         = CONVERT(integer, NULL),
                PlanTrend               = CONVERT(nvarchar(50), NULL),
                FirstMemoryGrantKB      = CONVERT(bigint, NULL),
                LastMemoryGrantKB       = CONVERT(bigint, NULL),
                MemoryGrantChangePct    = CONVERT(decimal(10, 1), NULL),
                MemoryGrantTrend        = CONVERT(nvarchar(30), NULL),
                FirstTempdbPages        = CONVERT(bigint, NULL),
                LastTempdbPages         = CONVERT(bigint, NULL),
                TempdbChangePct         = CONVERT(decimal(10, 1), NULL),
                TempdbTrend             = CONVERT(nvarchar(30), NULL);
        END;
    END
    ELSE IF @ExpertMode = 1
    BEGIN
        /* w5p2 / gh-532: single-result-set path -- same AVAILABLE / not-AVAILABLE split */
        IF @i8_data_status = N'AVAILABLE'
        BEGIN
            INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
            SELECT
                ResultSetID   = 13,
                ResultSetName = N'QS Performance Correlation',
                RowNum        = ROW_NUMBER() OVER (
                                    ORDER BY
                                        CASE
                                            WHEN fl.FirstCpuPerExec > 0 AND fl.LastCpuPerExec < fl.FirstCpuPerExec * 0.95 THEN 1
                                            WHEN fl.FirstCpuPerExec > 0 AND fl.LastCpuPerExec > fl.FirstCpuPerExec * 1.05 THEN 2
                                            ELSE 3
                                        END,
                                        ISNULL(fl.FirstCpuMs, 0) DESC
                                ),
                RowData       = (
                    SELECT
                        DatabaseName        = fl2.DatabaseName,
                        SchemaName          = fl2.SchemaName,
                        TableName           = fl2.ObjectName,
                        StatisticsName      = fl2.StatisticsName,
                        Appearances         = fl2.Appearances,
                        FirstCpuMs          = fl2.FirstCpuMs,
                        LastCpuMs           = fl2.LastCpuMs,
                        CpuChangePct        = CASE WHEN fl2.FirstCpuMs > 0
                                                   THEN CONVERT(decimal(10, 1), (fl2.LastCpuMs - fl2.FirstCpuMs) * 100.0 / fl2.FirstCpuMs)
                                                   ELSE NULL
                                              END,
                        FirstCpuPerExec     = CONVERT(decimal(10, 2), fl2.FirstCpuPerExec),
                        LastCpuPerExec      = CONVERT(decimal(10, 2), fl2.LastCpuPerExec),
                        CpuPerExecChangePct = CASE WHEN fl2.FirstCpuPerExec > 0
                                                   THEN CONVERT(decimal(10, 1), (fl2.LastCpuPerExec - fl2.FirstCpuPerExec) * 100.0 / fl2.FirstCpuPerExec)
                                                   ELSE NULL
                                              END,
                        CpuTrend            = CASE
                                                 WHEN fl2.FirstCpuPerExec > 0 AND fl2.LastCpuPerExec < fl2.FirstCpuPerExec * 0.95 THEN N'IMPROVING'
                                                 WHEN fl2.FirstCpuPerExec > 0 AND fl2.LastCpuPerExec > fl2.FirstCpuPerExec * 1.05 THEN N'DEGRADING'
                                                 ELSE N'STABLE'
                                             END,
                        ForcedPlanCount     = fl2.ForcedPlanCount,
                        PlanTrend           = CASE
                                                 WHEN fl2.LastPlans > fl2.FirstPlans AND fl2.ForcedPlanCount > 0
                                                     THEN N'MORE PLANS (forced plan at risk)'
                                                 WHEN fl2.LastPlans > fl2.FirstPlans THEN N'MORE PLANS (possible regression)'
                                                 WHEN fl2.LastPlans < fl2.FirstPlans THEN N'FEWER PLANS (consolidating)'
                                                 ELSE N'STABLE'
                                             END,
                        FirstMemoryGrantKB    = fl2.FirstMemoryGrantKB,
                        LastMemoryGrantKB     = fl2.LastMemoryGrantKB,
                        MemoryGrantChangePct  = CASE WHEN ISNULL(fl2.FirstMemoryGrantKB, 0) > 0
                                                     THEN CONVERT(decimal(10, 1), (fl2.LastMemoryGrantKB - fl2.FirstMemoryGrantKB) * 100.0 / fl2.FirstMemoryGrantKB)
                                                     ELSE NULL
                                                END,
                        MemoryGrantTrend      = CASE
                                                    WHEN ISNULL(fl2.FirstMemoryGrantKB, 0) > 0 AND fl2.LastMemoryGrantKB < fl2.FirstMemoryGrantKB * 0.95 THEN N'IMPROVING'
                                                    WHEN ISNULL(fl2.FirstMemoryGrantKB, 0) > 0 AND fl2.LastMemoryGrantKB > fl2.FirstMemoryGrantKB * 1.05 THEN N'DEGRADING'
                                                    WHEN fl2.FirstMemoryGrantKB IS NULL OR fl2.LastMemoryGrantKB IS NULL THEN NULL
                                                    ELSE N'STABLE'
                                                END,
                        FirstTempdbPages      = fl2.FirstTempdbPages,
                        LastTempdbPages        = fl2.LastTempdbPages,
                        TempdbChangePct       = CASE WHEN ISNULL(fl2.FirstTempdbPages, 0) > 0
                                                     THEN CONVERT(decimal(10, 1), (fl2.LastTempdbPages - fl2.FirstTempdbPages) * 100.0 / fl2.FirstTempdbPages)
                                                     ELSE NULL
                                                END,
                        TempdbTrend           = CASE
                                                    WHEN ISNULL(fl2.FirstTempdbPages, 0) > 0 AND fl2.LastTempdbPages < fl2.FirstTempdbPages * 0.95 THEN N'IMPROVING'
                                                    WHEN ISNULL(fl2.FirstTempdbPages, 0) > 0 AND fl2.LastTempdbPages > fl2.FirstTempdbPages * 1.05 THEN N'DEGRADING'
                                                    WHEN fl2.FirstTempdbPages IS NULL OR fl2.LastTempdbPages IS NULL THEN NULL
                                                    ELSE N'STABLE'
                                                END
                    FROM (SELECT fl.DatabaseName, fl.SchemaName, fl.ObjectName, fl.StatisticsName,
                                 fl.Appearances, fl.FirstCpuMs, fl.LastCpuMs, fl.FirstCpuPerExec, fl.LastCpuPerExec,
                                 fl.FirstPlans, fl.LastPlans, fl.ForcedPlanCount,
                                 fl.FirstMemoryGrantKB, fl.LastMemoryGrantKB,
                                 fl.FirstTempdbPages, fl.LastTempdbPages) AS fl2
                    FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
                )
            FROM
            (
                SELECT TOP (@TopN)
                    su_fl.DatabaseName, su_fl.SchemaName, su_fl.ObjectName, su_fl.StatisticsName,
                    Appearances     = COUNT_BIG(*),
                    FirstCpuMs      = MAX(CASE WHEN su_fl.rn = 1 THEN su_fl.QSTotalCpuMs END),
                    LastCpuMs       = MAX(CASE WHEN su_fl.rn = su_fl.cnt THEN su_fl.QSTotalCpuMs END),
                    FirstCpuPerExec = MAX(CASE WHEN su_fl.rn = 1 THEN su_fl.cpu_per_exec END),
                    LastCpuPerExec  = MAX(CASE WHEN su_fl.rn = su_fl.cnt THEN su_fl.cpu_per_exec END),
                    FirstPlans      = MAX(CASE WHEN su_fl.rn = 1 THEN su_fl.QSPlanCount END),
                    LastPlans       = MAX(CASE WHEN su_fl.rn = su_fl.cnt THEN su_fl.QSPlanCount END),
                    ForcedPlanCount = MAX(ISNULL(fp.ForcedPlanCount, 0)),
                    FirstMemoryGrantKB = MAX(CASE WHEN su_fl.rn = 1 THEN su_fl.QSTotalMemoryGrantKB END),
                    LastMemoryGrantKB  = MAX(CASE WHEN su_fl.rn = su_fl.cnt THEN su_fl.QSTotalMemoryGrantKB END),
                    FirstTempdbPages   = MAX(CASE WHEN su_fl.rn = 1 THEN su_fl.QSTotalTempdbPages END),
                    LastTempdbPages    = MAX(CASE WHEN su_fl.rn = su_fl.cnt THEN su_fl.QSTotalTempdbPages END)
                FROM
                (
                    SELECT
                        su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName,
                        su.QSTotalCpuMs,
                        su.QSPlanCount,
                        su.QSTotalMemoryGrantKB,
                        su.QSTotalTempdbPages,
                        cpu_per_exec = CONVERT(decimal(18, 4), su.QSTotalCpuMs * 1.0 / NULLIF(su.QSTotalExecutions, 0)),
                        rn  = ROW_NUMBER() OVER (
                                  PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                                  ORDER BY r.StartTime
                              ),
                        cnt = COUNT_BIG(*) OVER (
                                  PARTITION BY su.DatabaseName, su.SchemaName, su.ObjectName, su.StatisticsName
                              )
                    FROM #stat_updates AS su
                    INNER JOIN #runs AS r ON r.RunLabel = su.RunLabel
                    WHERE su.QSTotalCpuMs IS NOT NULL AND su.QSTotalCpuMs > 0
                    AND   (su.ErrorNumber = 0 OR su.ErrorNumber IS NULL)
                ) AS su_fl
                LEFT JOIN #forced_plans AS fp
                    ON fp.DatabaseName = su_fl.DatabaseName
                    AND fp.ObjectName = su_fl.ObjectName
                WHERE su_fl.cnt >= 2
                GROUP BY su_fl.DatabaseName, su_fl.SchemaName, su_fl.ObjectName, su_fl.StatisticsName
                ORDER BY MAX(CASE WHEN su_fl.rn = 1 THEN su_fl.QSTotalCpuMs END) DESC
            ) AS fl;
        END
        ELSE
        BEGIN
            /* w5p2 / gh-532: sentinel row in single-result-set mode */
            DECLARE @rs13_srs_reason nvarchar(max) = CONVERT(nvarchar(max), N'');

            SET @rs13_srs_reason =
                CASE @i8_data_status
                    WHEN N'UNAVAILABLE'
                    THEN N'No QS CPU data captured in any run within the analysis window. '
                        + N'Enable Query Store and configure sp_StatUpdate with @QueryStore = N''CPU''. '
                        + N'ALTER DATABASE [YourDb] SET QUERY_STORE = ON;'
                    WHEN N'INSUFFICIENT_HISTORY'
                    THEN N'Fewer than 2 runs contain matching QS CPU data ('
                        + CONVERT(nvarchar(10), @i8_qs_cpu_runs)
                        + N' QS-CPU run(s) found; need 2+ and at least 1 stat in 2+ runs). '
                        + N'Run sp_StatUpdate with @QueryStore = N''CPU'' across additional maintenance windows.'
                    ELSE N'DataStatus: ' + @i8_data_status
                END;

            INSERT INTO #single_rs (ResultSetID, ResultSetName, RowNum, RowData)
            SELECT
                ResultSetID   = 13,
                ResultSetName = N'QS Performance Correlation',
                RowNum        = 1,
                RowData       = (
                    SELECT
                        DatabaseName            = N'[NO DATA]',
                        SchemaName              = N'[NO DATA]',
                        TableName               = N'[NO DATA]',
                        StatisticsName          = @rs13_srs_reason,
                        Appearances             = CONVERT(integer, NULL),
                        FirstCpuMs              = CONVERT(bigint, NULL),
                        LastCpuMs               = CONVERT(bigint, NULL),
                        CpuChangePct            = CONVERT(decimal(10, 1), NULL),
                        FirstCpuPerExec         = CONVERT(decimal(10, 2), NULL),
                        LastCpuPerExec          = CONVERT(decimal(10, 2), NULL),
                        CpuPerExecChangePct     = CONVERT(decimal(10, 1), NULL),
                        CpuTrend                = CONVERT(nvarchar(30), NULL),
                        ForcedPlanCount         = CONVERT(integer, NULL),
                        PlanTrend               = CONVERT(nvarchar(50), NULL),
                        FirstMemoryGrantKB      = CONVERT(bigint, NULL),
                        LastMemoryGrantKB       = CONVERT(bigint, NULL),
                        MemoryGrantChangePct    = CONVERT(decimal(10, 1), NULL),
                        MemoryGrantTrend        = CONVERT(nvarchar(30), NULL),
                        FirstTempdbPages        = CONVERT(bigint, NULL),
                        LastTempdbPages         = CONVERT(bigint, NULL),
                        TempdbChangePct         = CONVERT(decimal(10, 1), NULL),
                        TempdbTrend             = CONVERT(nvarchar(30), NULL)
                    FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
                );
        END;
    END;

    /*
    ============================================================================
    FINAL OUTPUT (single result set mode only)
    ============================================================================
    */
    IF @SingleResultSet = 1
    BEGIN
        SELECT
            ResultSetID,
            ResultSetName,
            RowNum,
            RowData
        FROM #single_rs
        ORDER BY ResultSetID, RowNum;
    END;

    DROP TABLE IF EXISTS #single_rs;

    IF @Debug = 1
    BEGIN
        SET @debug_elapsed_ms = DATEDIFF(MILLISECOND, @debug_timer, SYSDATETIME());
        DECLARE @debug_rec_count integer;
        SELECT @debug_rec_count = COUNT_BIG(*) FROM #recommendations;
        RAISERROR(N'', 10, 1) WITH NOWAIT;
        RAISERROR(N'DEBUG: === Execution Summary ===', 10, 1) WITH NOWAIT;
        RAISERROR(N'DEBUG: Total elapsed: %i ms', 10, 1, @debug_elapsed_ms) WITH NOWAIT;
        RAISERROR(N'DEBUG: Runs: %i  Stat updates: %i  Recommendations: %i',
            10, 1, @run_count, @stat_update_count, @debug_rec_count) WITH NOWAIT;
        RAISERROR(N'DEBUG: QS efficacy rows: %i  Workload impact objects: %i',
            10, 1, @qs_efficacy_count, @workload_impact_count) WITH NOWAIT;
    END;

    /*
    ============================================================================
    CLEANUP
    ============================================================================
    */
    DROP TABLE IF EXISTS #runs;
    DROP TABLE IF EXISTS #stat_updates;
    DROP TABLE IF EXISTS #recommendations;
    DROP TABLE IF EXISTS #obfuscation_map;
    DROP TABLE IF EXISTS #executive_dashboard;
    DROP TABLE IF EXISTS #qs_efficacy;

    RETURN;
END;
GO