The clutter view had no viewer and told every reader the capture mode was uncollected: the web server tab and the Viewer's Query Store Clutter grid now read the same rows, and the config arm reads the V137 column instead of stubbing it

[erikdarlingdata]

get_query_store_clutter shipped in #3814 with no viewer and with its config arm hard-coded to query_capture_mode: null, capture_mode_known: false beside a note saying the column would land with the V137 rung. The rung had already landed: V137 (#3796) created collect.query_store_health.query_capture_mode, the shared collector fills it hourly, get_query_store_health publishes it on both SKUs, and both desktop Viewers' Query Store grids already render it. The clutter view was the only surface left telling a reader the mode was uncollected, and it said so inside the recommendation an operator would act on. This lane builds the two missing viewers and reads the column.

The reader and the composition move to .Storage

DarlingQueryStoreClutterReader and QueryStoreClutter move from the service's Mcp/ folder to PerformanceMonitor.Darling.Storage, beside the DarlingPg*Reader family and for the reason that folder exists (#2530, stated in its own csproj): the web page reads the MCP tool over HTTP, the WPF Viewer reads the store directly, and the alternative to a shared reader is a second copy of four statements carrying a window floor, a discrete-median definition that has to agree with percentile_disc, and a replica gate read off one engine bit. A copy that drifts on any of those calls a database Critical on one surface and Healthy on the other, and the copy that drifted is never the one being read.

The move is otherwise mechanical: namespace and visibility, the two command helpers that stayed behind swapped for .Storage's own spellings (StorageCommandDeadlines.McpReadSeconds, and a local naive-UTC binder with the Kind=Unspecified reasoning the DarlingPg* readers carry), and the deadline consequently 30 s rather than 20 s — the constant every shared reader serving both front ends already uses. .Storage gains a PerformanceMonitor.Common project reference, because the composition speaks the band canon (HealthSeverity) and the readonly_reason decode, and restating either here would be the duplication this move exists to avoid. The two lock files that carry a performancemonitor.darling.storage entry gain the one dependency line --locked-mode needs.

The config arm reads the capture mode

ConfigSql selects one more existing column; ConfigRow carries it; the payload publishes query_capture_mode with capture_mode_known beside it, and the server-level flag is the AND over the rows, so one database still on a pre-rung capture makes it false rather than being averaged away. A NULL is published as never asked and never as the engine's NONE, which is a mode a store can really be in.

QueryStoreClutter.CaptureModeClause is the one sentence both churn recommendations end on, written from the mode the row carries: ALL beside churn is the switch-to-AUTO case, AUTO beside it points at the workload, CUSTOM is AUTO with thresholds this row does not collect, NONE means the churn is inside the queries already held, and anything else is printed verbatim rather than mapped onto a default. No band moves — the mode steers the wording and never the verdict, which is pinned so a capture mode cannot become a threshold nobody published.

Web

One fanout of get_query_store_clutter on the Queries tab, after Query Store Regressions, feeding three panels: the per-database rows, the per-server non-sleep QDS_* wait block, and the Query Store memory clerk. One fetch because the read composes four arms over two raw hypertables and three descriptors would pay for that three times on one tab. The verdict cell is coloured off the band the server computed — the page re-derives no threshold — with the reason tokens beside it so the colour is never the only evidence, and the recommendation cell is the server's own prose behind a disclosure. include_fleet_median is deliberately not requested: it walks the two raw hypertables fleet-wide, and a server tab is a per-server question.

Viewer

A Query Store Clutter sub-tab in the Queries group, between Query Store Regressions and Plan Corrections, loaded by its named index constant through the existing sub-tab dispatch. ViewerDataService.QueryStoreClutter.cs calls the five shared arms and the shared composition and contains no SQL at all; what it adds is the projection, because the grid cannot bind a nullable record graph — each arm flattened with the absences rendered as the em-dash every other Viewer grid uses for "not measured". Selecting a row prints its recommendation whole, and the per-server overhead block sits in its own expander labelled per-server, with the sleep waits the collection filter drops named from the shared list rather than restated.

Every measured column binds a nullable number with StringFormat for the value and TargetNullValue for the absence, rather than a pre-formatted string. A DataGrid sorts on the binding's path, so text columns would sort 9 above 1,234 and 0.9 above 0.10 on the one grid in the Viewer whose purpose is to rank by magnitude — and it would look like a working sort. The em-dash an unmeasured arm shows is the binding's, so the absence still reads like every other absent cell without becoming text or becoming a zero; the timestamp column binds the converted DateTime for the same reason.

The grid takes no default SortDescription, unlike the grids beside it, and that is the decision rather than the omission: the composition orders rows worst-first by band, then the read-cost share, then plans per query, and the nearest single-column stand-in — the Verdict text descending — sorts alphabetically into Warning, Unknown, Healthy, Critical. That is the ranking reversed at the top of a grid whose job is to put the worst database first, and it would look like a working sort. The arrival order is the ranking, and it is left alone until the user sorts a column themselves.

Replicas

A database whose readonly_reason carries the readable-secondary bit stays in the grid on both surfaces with excluded set and excluded_reason naming the architecture — Excluded / Excluded Because columns in the Viewer, excluded_reason on the web row. Dropping the row would leave an operator who knows the database exists unable to tell "not cluttered" from "not shown", and file the second as the first. The projection's only filter is the tab's database filter, applied to the composed rows rather than inside the read so the per-server denominators keep meaning what they mean; that is pinned as the exact filter expression rather than as a count of Where calls, because the overhead projection has a filter of its own and a count would be satisfied by moving the wrong one into the right total.

Censuses

Both censuses the brief flagged are PostgreSQL-scoped and are unchanged, re-derived rather than asserted. ServerPageTabsTests.KnownUnreadable counts PostgreSQL collectors with no served get_pg_* read: 29 PostgreSQL collectors in CollectorCatalog, 35 served get_pg_* reads, all 35 resolving through CollectorForRead onto 28 distinct collectors, leaving 1 (pg_database_size_stats) — the constant's current value. ViewerCollectorCoverageTests' allow-list is the same single entry: 71 catalog tables against 71 ViewerDataService*.cs files plus the 29 shared readers they name, 0 uncovered and 0 stale. This lane adds a SQL Server read and no PostgreSQL collector, so neither number moves; DarlingQueryStoreClutterReader is now inside the coverage scan's follow set, which adds coverage and removes nothing.

Tests

QueryStoreClutterViewerSurfacesTests pins both surfaces as source, and its assertions are mostly negative: the Viewer reader contains no SQL, neither surface words a remedy of its own, neither restates a sleep-wait name, every Queries sub-tab constant matches its position in the XAML. The positive half is what a screenshot would catch; the negative half is what nothing would. QueryStoreClutterTests gains a table over all four capture modes, the pre-rung null and the no-config case, and a pin that the mode moves neither the verdict nor the reason tokens. Two existing pins move with the change rather than around it. QueryStoreClutterTests' ConfigSql shape pin anchored capture_time on the line break that followed it, to tell the projected column from the one in the ORDER BY; appending query_capture_mode moved that break, so the anchor is rewritten to carry three facts at once — capture_time is projected, the mode follows it, and the mode is the LAST projected column, which is what makes the reader's ordinal 12 the mode rather than a shift of every ordinal before it. And RepoFileAdoptionTests' LF-reader roster gains the new test file at its sorted position, with the reason it needs LF beside it: its pins slice regions out of ViewerServerTab.xaml and server-tabs.js between anchors several lines apart.

The live PostgreSQL rig now plants three capture-mode states — ALL on the newest capture with a pre-rung NULL on the older one for the same database, AUTO elsewhere, and a NULL that keeps the server-level flag false for a real reason rather than because nothing was ever written.

Closes #3797