From d2a2d6fc3ff26795f51aa9ad1899f1965b7b8f60 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Fri, 16 Oct 2026 16:42:21 +0200
Subject: [PATCH 01/14] perf: the two-keys patterns of the level keys probe run
 behind a gate of phrases

The keys probe ran two regexps that scan the rest of the line after a level key
over every line of a window that holds one, which is every line of a body-only
window: 320 CPU-ms of 1h of rows, the heaviest probe of the first view of a
window. Only a line holding two level keys can match them, so they now run
behind a filter that passes the lines in which one key name occurs twice
(a sequence of the phrase after itself) or two of the names occur, answered
from VictoriaLogs' token index: 50 CPU-ms. The gate is a superset of the
patterns, never a second decision; the probe's verdict is the patterns'.
---
 .../proxy/detected_level_keys_gate_test.go    | 324 ++++++++++++++++++
 .../ordered_json_filter_pushdown_test.go      |  22 +-
 internal/proxy/ordered_json_metric.go         |  38 +-
 .../detected_level_keys_gate_test.go          | 137 ++++++++
 4 files changed, 516 insertions(+), 5 deletions(-)
 create mode 100644 internal/proxy/detected_level_keys_gate_test.go
 create mode 100644 test/e2e-compat/detected_level_keys_gate_test.go

diff --git a/internal/proxy/detected_level_keys_gate_test.go b/internal/proxy/detected_level_keys_gate_test.go
new file mode 100644
index 000000000..d3c8881d7
--- /dev/null
+++ b/internal/proxy/detected_level_keys_gate_test.go
@@ -0,0 +1,324 @@
+package proxy
+
+import (
+	"context"
+	"math/rand"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+// vlIsTokenRune is VictoriaLogs' isTokenRune (lib/logstorage/tokenizer.go): an
+// ASCII letter, digit or underscore, or a Unicode letter or digit.
+func vlIsTokenRune(c rune) bool {
+	if c < utf8.RuneSelf {
+		return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '_'
+	}
+	return unicode.IsLetter(c) || unicode.IsDigit(c) || c == '_'
+}
+
+// vlPhrasePos is VictoriaLogs' getPhrasePos (lib/logstorage/filter_phrase.go,
+// identical in v1.40, v1.47 and v1.52): the first position of the phrase that
+// has no token rune beside it where the phrase starts or ends with one, an
+// invalid UTF-8 byte counting as a token rune.
+func vlPhrasePos(s, phrase string) int {
+	if len(phrase) == 0 {
+		return 0
+	}
+	if len(phrase) > len(s) {
+		return -1
+	}
+	r := rune(phrase[0])
+	if r >= utf8.RuneSelf {
+		r, _ = utf8.DecodeRuneInString(phrase)
+	}
+	startsWithToken := vlIsTokenRune(r)
+	r = rune(phrase[len(phrase)-1])
+	if r >= utf8.RuneSelf {
+		r, _ = utf8.DecodeLastRuneInString(phrase)
+	}
+	endsWithToken := vlIsTokenRune(r)
+	pos := 0
+	for {
+		n := strings.Index(s[pos:], phrase)
+		if n < 0 {
+			return -1
+		}
+		pos += n
+		if startsWithToken && pos > 0 {
+			r := rune(s[pos-1])
+			if r >= utf8.RuneSelf {
+				r, _ = utf8.DecodeLastRuneInString(s[:pos])
+			}
+			if r == utf8.RuneError || vlIsTokenRune(r) {
+				pos++
+				continue
+			}
+		}
+		if endsWithToken && pos+len(phrase) < len(s) {
+			r := rune(s[pos+len(phrase)])
+			if r >= utf8.RuneSelf {
+				r, _ = utf8.DecodeRuneInString(s[pos+len(phrase):])
+			}
+			if r == utf8.RuneError || vlIsTokenRune(r) {
+				pos++
+				continue
+			}
+		}
+		return pos
+	}
+}
+
+// vlSequence is VictoriaLogs' matchSequence (filter_sequence.go): each phrase
+// is searched after the end of the one before.
+func vlSequence(s string, phrases []string) bool {
+	for _, phrase := range phrases {
+		n := vlPhrasePos(s, phrase)
+		if n < 0 {
+			return false
+		}
+		s = s[n+len(phrase):]
+	}
+	return true
+}
+
+// twiceGateMatches evaluates the text of a gate over one line, through the
+// fake VictoriaLogs' filter evaluator: the phrases and sequences are read out
+// of the text, not taken from the key list, so a gate that lists less than the
+// patterns is seen.
+func twiceGateMatches(t testing.TB, gate, line string) bool {
+	return fakeLogsQLMatch(t, gate, map[string]string{"_msg": line})
+}
+
+var (
+	// the patterns of detectedLevelKeysRisk that need two level keys
+	twiceJSONKeys   = regexp.MustCompile(detectedLevelJSONKey + `(?s:.*)` + detectedLevelJSONKey)
+	twiceLogfmtKeys = regexp.MustCompile(detectedLevelLogfmtKey + `(?s:.*)` + detectedLevelLogfmtKey)
+)
+
+func twicePatternMatches(line string) bool {
+	return twiceJSONKeys.MatchString(line) || twiceLogfmtKeys.MatchString(line)
+}
+
+// twiceGateCorpus returns lines for the superset test: every ordered pair of
+// level keys (the key list itself, so a name added later is covered) in the
+// JSON and the logfmt shapes with each whitespace and separator that matters,
+// then random lines made of the keys, their near spellings and every kind of
+// byte around them.
+func twiceGateCorpus(random int) []string {
+	var lines []string
+	jsonShapes := []string{
+		`{"%s":"x","%s":"y"}`, `{"%s" : 1, "%s"	:2}`, `{"m":"q","%s":"x","k":{"%s":"y"}}`,
+		`  {"%s":"x"} {"%s":"y"}`, "{\"%s\"\n:\"x\",\r\n\"%s\":\"y\"}", `{"%s":"%s"}`, `{"a":"%s","b":"%s"}`,
+	}
+	logfmtShapes := []string{
+		"%s=1 %s=2", "x %s=1\t%s=2", "%s=1\n%s=2", "%s=1\r%s=2", "%s=1\f%s=2", "a=b %s=\"%s=x\"", "%s=%s",
+		"%s=1 %s", "%s %s=1",
+	}
+	for _, a := range detectedLevelKeyNames {
+		for _, b := range detectedLevelKeyNames {
+			for _, shape := range append(append([]string(nil), jsonShapes...), logfmtShapes...) {
+				lines = append(lines, strings.Replace(strings.Replace(shape, "%s", a, 1), "%s", b, 1))
+			}
+		}
+	}
+	rng := rand.New(rand.NewSource(11))
+	var seps []string
+	for b := 0; b < 128; b++ {
+		seps = append(seps, string(rune(b)))
+	}
+	for _, c := range "\"=: \t\n{}" { // the characters around a key, drawn often so that most lines match
+		for k := 0; k < 10; k++ {
+			seps = append(seps, string(c))
+		}
+	}
+	seps = append(seps, "\u00a0", "\u2028", "\u0085", "é", "ж", "€", "\xff", "\xc2", "\ufffd")
+	words := append([]string(nil), detectedLevelKeyNames...)
+	for _, name := range detectedLevelKeyNames {
+		words = append(words, name+"s", "x"+name, name+"2", strings.ToUpper(name), name+"é", "é"+name, strings.ReplaceAll(name, "_", "-"))
+	}
+	// the shapes of a key, drawn often so that many lines hold two of them
+	forms := []string{`"%s":`, `"%s"  :`, " %s=", "\t%s=", "%s=", `"%s"`}
+	for i := 0; i < random; i++ {
+		var sb strings.Builder
+		for j, n := 0, 1+rng.Intn(5); j < n; j++ {
+			sb.WriteString(seps[rng.Intn(len(seps))])
+			if rng.Intn(3) == 0 {
+				sb.WriteString(seps[rng.Intn(len(seps))])
+			}
+			if rng.Intn(2) == 0 {
+				sb.WriteString(strings.Replace(forms[rng.Intn(len(forms))], "%s", words[rng.Intn(len(words))], 1))
+			} else {
+				sb.WriteString(words[rng.Intn(len(words))])
+			}
+		}
+		sb.WriteString(seps[rng.Intn(len(seps))])
+		lines = append(lines, sb.String())
+	}
+	return lines
+}
+
+// firstTwiceGateMiss returns a line the patterns match and the gate does not,
+// and how many lines the patterns matched.
+func firstTwiceGateMiss(t testing.TB, gate string, lines []string) (miss string, matched int) {
+	for _, line := range lines {
+		if !twicePatternMatches(line) {
+			continue
+		}
+		matched++
+		if miss == "" && !twiceGateMatches(t, gate, line) {
+			miss = line
+		}
+	}
+	return miss, matched
+}
+
+// The gate in front of the two-keys patterns is a superset of them: any line
+// they match holds two level keys as phrases of VictoriaLogs' tokenizer, so
+// the verdict of the probe is the patterns', never the gate's. Every ordered
+// pair of the key names is covered by lines of both shapes, and random lines
+// around them. The gate is evaluated from its text, with the phrase and
+// sequence rules of VictoriaLogs written out from filter_phrase.go and
+// filter_sequence.go.
+// conformance: severity-detected-level-derivation
+func TestTwiceGateIsASupersetOfTheKeyPatterns(t *testing.T) {
+	gate := detectedLevelTwiceGate()
+	lines := twiceGateCorpus(300000)
+	miss, matched := firstTwiceGateMiss(t, gate, lines)
+	if miss != "" {
+		t.Fatalf("the patterns match %q and the gate does not", miss)
+	}
+	n := len(detectedLevelKeyNames)
+	if want := n * n * 6; matched < want || matched < 5000 {
+		t.Fatalf("only %d lines matched the patterns (at least %d expected); the corpus is too tame", matched, want)
+	}
+}
+
+// The gate is no trivial one: a line with one level key, or with a key and no
+// second one, is rejected (that is the cost it removes), and lines that the
+// patterns reject but that hold two keys are let through (the patterns decide).
+// conformance: severity-detected-level-derivation
+func TestTwiceGateRejectsSingleKeys(t *testing.T) {
+	gate := detectedLevelTwiceGate()
+	for line, want := range map[string]bool{
+		`{"level":"info","msg":"x"}`:                         false,
+		`ts=1 level=info msg=hello`:                          false,
+		`just a line`:                                        false,
+		`{"level":"info","severity":"warn"}`:                 true,
+		`{"level":"info","level":"warn"}`:                    true,
+		`{"log.level":"info","SeverityText":"warn"}`:         true,
+		"level=info\tlvl=warn":                               true,
+		`{"a":"level","b":"level"}`:                          true, // two phrases: the patterns reject it
+		`level levels`:                                       false,
+		`{"log":{"level":"info"},"msg":"log.level"}`:         true,
+		`{"severity_text":"info","Severity_Text":"warn"}`:    true,
+		`{"SEVERITY_TEXT":"info","severity_text":"warn"}`:    true,
+		`{"msg":"xlevel and level2 and severity_texts"}`:     false,
+		`{"level":"info"} {"level":"warn"} \u006cevel=error`: true,
+	} {
+		if got := twiceGateMatches(t, gate, line); got != want {
+			t.Errorf("gate over %q = %v, want %v", line, got, want)
+		}
+	}
+}
+
+// A gate that lists less than the patterns reads is caught by the corpus: each
+// mutation of the gate text narrows it, and the superset test must see a line
+// it drops.
+// conformance: severity-detected-level-derivation
+func TestTwiceGateNarrowedIsCaught(t *testing.T) {
+	gate := detectedLevelTwiceGate()
+	lines := twiceGateCorpus(20000)
+	if miss, _ := firstTwiceGateMiss(t, gate, lines); miss != "" {
+		t.Fatalf("the unmutated gate misses %q", miss)
+	}
+	selfPair := regexp.MustCompile(`_msg:seq\("[^"]*","[^"]*"\) or `)
+	crossPair := regexp.MustCompile(`\(_msg:"[^"]*" \([^()]*\)\)( or )?`)
+	mutations := map[string]string{
+		"no same-key sequences":    selfPair.ReplaceAllString(gate, ""),
+		"no pairs of two keys":     crossPair.ReplaceAllString(gate, ""),
+		"sequences reversed":       strings.Replace(gate, `_msg:seq("level","level")`, `_msg:seq("level","LEVEL")`, 1),
+		"last key dropped":         strings.ReplaceAll(strings.ReplaceAll(gate, `_msg:seq("SEVERITY_TEXT","SEVERITY_TEXT")`, `_msg:seq("lvl","lvl")`), ` or _msg:"SEVERITY_TEXT"`, ""),
+		"a key misspelt":           strings.ReplaceAll(gate, `"Lvl"`, `"Lvls"`),
+		"phrases lose their words": strings.ReplaceAll(gate, `"Severity_Text"`, `"Severity"`),
+	}
+	for name, mutated := range mutations {
+		if mutated == gate {
+			t.Errorf("%s: the mutation did not change the gate", name)
+			continue
+		}
+		if miss, _ := firstTwiceGateMiss(t, mutated, lines); miss == "" {
+			t.Errorf("%s: no line of the corpus is dropped by the narrowed gate", name)
+		}
+	}
+}
+
+// FuzzTwiceGateIsASupersetOfTheKeyPatterns lets the fuzzer look for a line
+// the two-keys patterns match and the gate does not.
+// conformance: severity-detected-level-derivation
+func FuzzTwiceGateIsASupersetOfTheKeyPatterns(f *testing.F) {
+	for _, line := range twiceGateCorpus(0)[:400] {
+		f.Add(line)
+	}
+	f.Add("\xfflevel=1 level=2")
+	f.Add("{\"log.level\":1,\"level\":2}")
+	gate := detectedLevelTwiceGate()
+	f.Fuzz(func(t *testing.T, line string) {
+		if twicePatternMatches(line) && !twiceGateMatches(t, gate, line) {
+			t.Fatalf("the patterns match %q and the gate does not", line)
+		}
+	})
+}
+
+// The probe puts the gate in front of both two-keys patterns and in front of
+// nothing else, and the query still fits VictoriaLogs' default query length
+// (-search.maxQueryLen, 16 KiB) after a long selector of 6.7 KB, the longest
+// the detected_level chain itself fits (TestPrunedChainWithWitnessFitsTheQueryLimit).
+// conformance: severity-detected-level-derivation
+func TestKeysRiskProbeGatesTheTwoKeyPatterns(t *testing.T) {
+	var queries []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_ = r.ParseForm()
+		queries = append(queries, r.Form.Get("query"))
+	}))
+	defer srv.Close()
+	p := newSlidingTestProxy(t, srv.URL)
+	var names []string
+	for i := 0; i < 7; i++ {
+		names = append(names, strings.Repeat("n", 120)+string(rune('0'+i)))
+	}
+	base := `app:~"` + strings.Repeat(strings.Join(names, "|")+"|", 8) + `x"`
+	if len(base) < 6000 {
+		t.Fatalf("base of %d bytes", len(base))
+	}
+	if risky, err := p.detectedLevelKeysRisk(context.Background(), base, time.Unix(1700000000, 0), time.Unix(1700003600, 0)); err != nil || risky {
+		t.Fatalf("risky=%v err=%v", risky, err)
+	}
+	if len(queries) != 1 {
+		t.Fatalf("%d queries", len(queries))
+	}
+	q, gate := queries[0], detectedLevelTwiceGate()
+	if len(q) > vlDefaultMaxQueryLen {
+		t.Fatalf("the probe is %d bytes, VictoriaLogs accepts %d", len(q), vlDefaultMaxQueryLen)
+	}
+	if n := strings.Count(q, gate); n != 1 {
+		t.Fatalf("the gate occurs %d times in %s", n, q)
+	}
+	// the gate stands in front of the two patterns that need two keys, and of
+	// no other branch
+	twiceJSON := `_msg:~` + `"` + `\"(?:`
+	at := strings.Index(q, gate)
+	after := q[at+len(gate):]
+	if !strings.HasPrefix(after, ` ((_msg:~"^[`) || strings.Count(after, "(?s:.*)") != 2 {
+		t.Fatalf("the gate is not in front of the two-key patterns: %s", after)
+	}
+	ungated := strings.Replace(q, gate+" ", "", 1)
+	if strings.Contains(ungated, "seq(") || !strings.Contains(ungated, twiceJSON) {
+		t.Fatalf("removing the gate leaves %s", ungated)
+	}
+}
diff --git a/internal/proxy/ordered_json_filter_pushdown_test.go b/internal/proxy/ordered_json_filter_pushdown_test.go
index b55c5a02e..bc4fc60b2 100644
--- a/internal/proxy/ordered_json_filter_pushdown_test.go
+++ b/internal/proxy/ordered_json_filter_pushdown_test.go
@@ -285,17 +285,35 @@ func (f *fakeLogsQLFilter) fieldFilter() bool {
 	case strings.HasPrefix(f.src[f.pos:], "!"):
 		f.pos++
 		return value != f.quoted()
+	case strings.HasPrefix(f.src[f.pos:], "seq("):
+		// seq("a","b"): the phrases in this order, each after the one before.
+		f.pos += len("seq(")
+		var phrases []string
+		for {
+			phrases = append(phrases, f.quoted())
+			f.skipSpace()
+			if f.pos < len(f.src) && f.src[f.pos] == ',' {
+				f.pos++
+				continue
+			}
+			break
+		}
+		if f.pos >= len(f.src) || f.src[f.pos] != ')' {
+			f.t.Errorf("fake VL: expected ) closing seq at %d in %q", f.pos, f.src)
+			return false
+		}
+		f.pos++
+		return vlSequence(value, phrases)
 	default:
 		// A word or phrase, or with a trailing * a word prefix. VictoriaLogs'
 		// tokenizer takes every Unicode letter and digit and the underscore
 		// as word runes (isTokenRune).
 		word := f.quoted()
-		boundary := `[\p{L}\p{Nd}_]`
 		if strings.HasPrefix(f.src[f.pos:], "*") {
 			f.pos++
 			return regexp.MustCompile(`(^|[^\p{L}\p{Nd}_])` + regexp.QuoteMeta(word)).MatchString(value)
 		}
-		return regexp.MustCompile(`(^|[^\p{L}\p{Nd}_])`+regexp.QuoteMeta(word)+`([^\p{L}\p{Nd}_]|$)`).MatchString(value) && boundary != ""
+		return vlPhrasePos(value, word) >= 0
 	}
 }
 
diff --git a/internal/proxy/ordered_json_metric.go b/internal/proxy/ordered_json_metric.go
index 70c2ece9d..33be61068 100644
--- a/internal/proxy/ordered_json_metric.go
+++ b/internal/proxy/ordered_json_metric.go
@@ -577,6 +577,28 @@ func logsqlWordPrefilter(words []string) string {
 	return "(" + strings.Join(alts, " or ") + ")"
 }
 
+// logsqlTwiceFilter renders a filter that passes every line holding two
+// occurrences of the phrases: one phrase twice (seq, which finds the second
+// after the first) or two of them (both present). Occurrences that a regexp
+// "key ... key" matches are such, so the filter is a superset of it, answered
+// from VictoriaLogs' token index and a substring search where the regexp
+// would run over every line that holds one key.
+func logsqlTwiceFilter(phrases []string) string {
+	var alts []string
+	for i, a := range phrases {
+		quoted := strconv.Quote(a)
+		alts = append(alts, "_msg:seq("+quoted+","+quoted+")")
+		var rest []string
+		for _, b := range phrases[i+1:] {
+			rest = append(rest, "_msg:"+strconv.Quote(b))
+		}
+		if len(rest) > 0 {
+			alts = append(alts, "(_msg:"+quoted+" ("+strings.Join(rest, " or ")+"))")
+		}
+	}
+	return "(" + strings.Join(alts, " or ") + ")"
+}
+
 // orderedJSONSpellingPrefilter renders the filters every line holding a key
 // Loki reads into one of the labels from another spelling passes. Such a key
 // differs from the label only where the label has underscores (a sanitized
@@ -1614,18 +1636,28 @@ func detectedLevelStoredFilter() string {
 // which the chain does not unpack. A line starting with a brace is read for
 // quoted keys, any other for logfmt keys. The patterns also match a mention
 // inside a longer string, a superset that only costs the raw evaluator.
+// The two-keys patterns run behind detectedLevelTwiceGate: they scan the rest
+// of every line that holds a level key, which is every line of a body-only
+// window, and only a line with two of them can match.
 func (p *Proxy) detectedLevelKeysRisk(ctx context.Context, base string, start, end time.Time) (bool, error) {
 	const closed = `\}[\s\v\x{85}\p{Z}]*$`
 	braced := strconv.Quote(translator.BracedLineRegexp)
 	twice := func(key string) string { return key + `(?s:.*)` + key }
 	query := base + detectedLevelStoredFilter() + " | filter " + detectedLevelWordFilter() +
-		" ((_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelJSONKey)) + ")" +
+		" ((" + detectedLevelTwiceGate() + " ((_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelJSONKey)) + ")" +
+		" or (-_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelLogfmtKey)) + ")))" +
 		" or (_msg:~" + braced + " _msg:~" + strconv.Quote(detectedLevelJSONKey+`\s*"[^"\\]*\\`) + ")" +
-		" or (_msg:~" + braced + " -_msg:~" + strconv.Quote(closed) + " _msg:~" + strconv.Quote(detectedLevelLogfmtKey) + ")" +
-		" or (-_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelLogfmtKey)) + ")) | limit 1"
+		" or (_msg:~" + braced + " -_msg:~" + strconv.Quote(closed) + " _msg:~" + strconv.Quote(detectedLevelLogfmtKey) + ")) | limit 1"
 	return p.statsPushdownRiskExists(ctx, query, start, end)
 }
 
+// detectedLevelTwiceGate passes the lines that hold two level keys, a superset
+// of both two-keys patterns of detectedLevelKeysRisk: each occurrence they
+// match is a key name between non-word characters (a quote, a space, the
+// start of the line, an equals sign), which is a phrase of the name for
+// VictoriaLogs, and the two do not overlap.
+func detectedLevelTwiceGate() string { return logsqlTwiceFilter(detectedLevelKeyNames) }
+
 // detectedLevelUnpackRisk reports whether a selected JSON line mentions a
 // level key that unpack_json yields no value for: a key nested other than
 // under log (Loki reads level keys at depth 0 and 1), a line VictoriaLogs
diff --git a/test/e2e-compat/detected_level_keys_gate_test.go b/test/e2e-compat/detected_level_keys_gate_test.go
new file mode 100644
index 000000000..8e647c23d
--- /dev/null
+++ b/test/e2e-compat/detected_level_keys_gate_test.go
@@ -0,0 +1,137 @@
+//go:build e2e
+
+package e2e_compat
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+	"time"
+)
+
+// levelKeysProbeLines are the lines the gate in front of the keys probe's
+// two-keys patterns is run over, one stream each: lines the gate rejects,
+// lines it lets through and the patterns reject, and lines the patterns match.
+// risky is the verdict of the probe, which is the patterns' (and the other
+// two branches') whatever the gate lets through.
+var levelKeysProbeLines = []struct {
+	name, msg string
+	risky     bool
+}{
+	{"one JSON key", `{"level":"info","msg":"x"}`, false},
+	{"one logfmt key", "ts=1 level=info msg=hi", false},
+	{"JSON key twice", `{"level":"info","level":"warn"}`, true},
+	{"JSON level and severity", `{"level":"info","severity":"warn"}`, true},
+	{"JSON dotted key and SeverityText", `{"log.level":"info","SeverityText":"warn"}`, true},
+	{"JSON nested key", `{"level":"a","k":{"level":"b"}}`, true},
+	{"JSON Level and LEVEL", `{"Level":"a","LEVEL":"b"}`, true},
+	{"JSON severity_text spellings", `{"severity_text":"a","Severity_Text":"b"}`, true},
+	{"JSON severity_text and SEVERITY_TEXT", `{"severity_text":"a","SEVERITY_TEXT":"b"}`, true},
+	{"JSON lvl and Lvl", `{"lvl":"a","Lvl":"b"}`, true},
+	{"words in a message, no key twice", `{"msg":"the level was high","severity":"x"}`, false},
+	{"two words, one key", `{"msg":"level level","level":"x"}`, false},
+	{"key and a longer word", `{"level":"info","é":"level","k":"levels"}`, false},
+	{"logfmt key twice", "level=info level=warn", true},
+	{"logfmt tab separated", "level=info\tlvl=warn", true},
+	{"logfmt newline separated", "level=info\nseverity=warn", true},
+	{"logfmt second key in a quoted value", `level=info msg="level=debug"`, false},
+	{"escape in a level value", `{"level":"a\u0041"}`, true},
+	{"brace without its closing brace and a logfmt key", `{"level":"info"} tail level=1`, true},
+}
+
+// extractLevelTwiceGate returns the gate of a recorded keys probe: the
+// parenthesised alternation that starts with its first sequence.
+func extractLevelTwiceGate(t *testing.T, query string) (gate string, start int) {
+	t.Helper()
+	start = strings.Index(query, `(_msg:seq("`)
+	if start < 0 {
+		t.Fatalf("no twice gate in %s", query)
+	}
+	depth := 0
+	for i := start; i < len(query); i++ {
+		switch query[i] {
+		case '(':
+			depth++
+		case ')':
+			if depth--; depth == 0 {
+				return query[start : i+1], start
+			}
+		}
+	}
+	t.Fatalf("unbalanced gate in %s", query)
+	return "", 0
+}
+
+// The gate in front of the keys probe's two-keys patterns changes no verdict:
+// the probe the proxy sent, and the same probe without the gate, give the same
+// answer on each line of the fixture, one line to a stream, on this
+// VictoriaLogs version. A verdict over the whole window would pass as soon as
+// one risky line was in it.
+// conformance: semantics/json-metric-detected-level-derivation
+func TestRangeMetricCompatibilityDetectedLevelKeysGate(t *testing.T) {
+	now := time.Now()
+	s0 := now.Add(-9 * time.Hour).Truncate(time.Hour)
+	apps := make([]string, len(levelKeysProbeLines))
+	fixture := map[string][]jsonVolumeStreamLine{}
+	for i, line := range levelKeysProbeLines {
+		apps[i] = fmt.Sprintf("level-keys-gate-%02d-%d", i, now.UnixNano())
+		fixture[apps[i]] = []jsonVolumeStreamLine{{ts: s0.Add(10 * time.Second), msg: line.msg}}
+	}
+	ingestJSONVolumeFixture(t, fixture)
+	start, end := s0, s0.Add(2*time.Minute)
+
+	// The probe is whatever the proxy sends: captured for a line that clears
+	// every guard, then asked of each stream with its base.
+	route, rec := newJSONVolumeRouteProxy(t)
+	rec.reset()
+	query := `sum by (detected_level) (count_over_time({app="` + apps[0] + `"} | json | drop __error__ [1m]))`
+	slidingRangeSeries(t, route, query, start, end, time.Minute, nil)
+	var template string
+	for _, call := range rec.reset() {
+		if strings.HasPrefix(call, "/select/logsql/query ") && strings.Contains(call, "(?s:.*)") && strings.Contains(call, `(_msg:seq("`) {
+			template = strings.TrimPrefix(call, "/select/logsql/query ")
+		}
+	}
+	base := `app:="` + apps[0] + `"`
+	if !strings.HasPrefix(template, base+" ") {
+		t.Fatalf("keys probe not found among the calls, or it does not start with %s: %q", base, template)
+	}
+	gate, at := extractLevelTwiceGate(t, template)
+	if !strings.Contains(template[at+len(gate):], "(?s:.*)") {
+		t.Fatalf("the gate does not stand in front of the two-keys patterns: %s", template)
+	}
+	ungated := template[:at] + template[at+len(gate)+1:]
+	if strings.Contains(ungated, "seq(") || strings.Count(ungated, "(?s:.*)") != 2 {
+		t.Fatalf("the ungated probe lost more than the gate: %s", ungated)
+	}
+
+	asks := func(probe, app string) bool {
+		probe = strings.Replace(probe, base, `app:="`+app+`"`, 1)
+		form := url.Values{"query": {probe}, "start": {start.UTC().Format(time.RFC3339Nano)}, "end": {end.UTC().Format(time.RFC3339Nano)}}
+		status, body := hardeningRequest(t, http.MethodPost, vlURL+"/select/logsql/query", form.Encode(), map[string]string{"Content-Type": "application/x-www-form-urlencoded"})
+		if status != http.StatusOK {
+			t.Fatalf("VictoriaLogs %d: %s", status, body)
+		}
+		return strings.TrimSpace(string(body)) != ""
+	}
+	risky := 0
+	for i, line := range levelKeysProbeLines {
+		t.Run(line.name, func(t *testing.T) {
+			gated, plain := asks(template, apps[i]), asks(ungated, apps[i])
+			if gated != plain {
+				t.Errorf("gated probe says risky=%v, the ungated one %v, for %q", gated, plain, line.msg)
+			}
+			if gated != line.risky {
+				t.Errorf("probe says risky=%v for %q, expected %v", gated, line.msg, line.risky)
+			}
+		})
+		if line.risky {
+			risky++
+		}
+	}
+	if risky == 0 || risky == len(levelKeysProbeLines) {
+		t.Fatalf("the fixture holds %d risky lines of %d", risky, len(levelKeysProbeLines))
+	}
+}

From 1c9314d5abd91bace266ea40d1d0e441f72db89c Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Fri, 16 Oct 2026 19:39:25 +0200
Subject: [PATCH 02/14] fix: a selector too long for the gated keys probe gets
 the probe without the gate

The gate adds 2.5 KB to the keys probe, so a selector of 11.8 KB to 14.3 KB,
which fit VictoriaLogs' 16 KiB query length before, would have had its probe
refused. The gate only narrows what the patterns run on, so the text without it
gives the same verdict.
---
 .../proxy/detected_level_keys_gate_test.go    | 18 ++++++
 .../detected_level_long_selector_test.go      | 62 +++++++++++++++++++
 internal/proxy/ordered_json_metric.go         | 23 +++++--
 3 files changed, 99 insertions(+), 4 deletions(-)
 create mode 100644 internal/proxy/detected_level_long_selector_test.go

diff --git a/internal/proxy/detected_level_keys_gate_test.go b/internal/proxy/detected_level_keys_gate_test.go
index d3c8881d7..c69e80fc0 100644
--- a/internal/proxy/detected_level_keys_gate_test.go
+++ b/internal/proxy/detected_level_keys_gate_test.go
@@ -321,4 +321,22 @@ func TestKeysRiskProbeGatesTheTwoKeyPatterns(t *testing.T) {
 	if strings.Contains(ungated, "seq(") || !strings.Contains(ungated, twiceJSON) {
 		t.Fatalf("removing the gate leaves %s", ungated)
 	}
+	if plain := detectedLevelKeysQuery(base, false); strings.Contains(plain, "seq(") || strings.Count(plain, "(?s:.*)") != 2 || len(plain)+len(gate) > len(q)+2 {
+		t.Fatalf("the probe without the gate: %s", plain)
+	}
+
+	// A selector that fits VictoriaLogs' query length only without the gate (the
+	// gate adds 2.5 KB) gets the probe without it: the same patterns, so the same
+	// verdict, where the gated text would be refused.
+	queries = nil
+	long := `app:~"` + strings.Repeat("n", 12500) + `"`
+	if len(detectedLevelKeysQuery(long, true)) <= vlDefaultMaxQueryLen || len(detectedLevelKeysQuery(long, false)) > vlDefaultMaxQueryLen {
+		t.Fatalf("the long base of %d bytes does not separate the two texts (%d, %d)", len(long), len(detectedLevelKeysQuery(long, true)), len(detectedLevelKeysQuery(long, false)))
+	}
+	if risky, err := p.detectedLevelKeysRisk(context.Background(), long, time.Unix(1700000000, 0), time.Unix(1700003600, 0)); err != nil || risky {
+		t.Fatalf("risky=%v err=%v", risky, err)
+	}
+	if len(queries) != 1 || strings.Contains(queries[0], "seq(") || len(queries[0]) > vlDefaultMaxQueryLen {
+		t.Fatalf("a long selector should send the probe without the gate within %d bytes: %d queries, %d bytes", vlDefaultMaxQueryLen, len(queries), len(queries[0]))
+	}
 }
diff --git a/internal/proxy/detected_level_long_selector_test.go b/internal/proxy/detected_level_long_selector_test.go
new file mode 100644
index 000000000..8d3f7bdd1
--- /dev/null
+++ b/internal/proxy/detected_level_long_selector_test.go
@@ -0,0 +1,62 @@
+package proxy
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// scanFixture is a window of JSON lines without any level, in a stream that has
+// a detected_level label or not.
+func scanFixture(s0 time.Time, streamLevel bool) []pushdownRow {
+	stream := map[string]string{"app": "api", "env": "prod"}
+	if streamLevel {
+		stream["detected_level"] = "warn"
+	}
+	var rows []pushdownRow
+	for i := 0; i < 30; i++ {
+		rows = append(rows, pushdownRow{ts: s0.Add(time.Duration(i+1) * 10 * time.Second), stream: stream, msg: `{"msg":"x","n":` + strconv.Itoa(i) + `}`})
+	}
+	return rows
+}
+
+// A selector of 12.5 KB, in the band where the keys probe fits VictoriaLogs'
+// 16 KiB query length only without its gate (the gate adds 2.5 KB), still gets
+// every request of the pushdown within the limit and the answer of the
+// shorter selector: no probe is refused.
+// conformance: semantics/json-metric-detected-level-derivation
+func TestLongSelectorKeepsEveryRequestWithinTheQueryLimit(t *testing.T) {
+	s0 := time.Unix(1700000400, 0).UTC()
+	end := s0.Add(6 * time.Minute)
+	var names []string
+	for i := 0; len(strings.Join(names, "|")) < 12500; i++ {
+		names = append(names, strings.Repeat("n", 100)+strconv.Itoa(i))
+	}
+	selector := `{env="prod", app=~"api|` + strings.Join(names, "|") + `"}`
+	query := `sum by (detected_level) (count_over_time(` + selector + ` | json | drop __error__ [5m]))`
+	srv, fake := newPushdownFakeVL(t, scanFixture(s0, false), nil)
+	fake.presence = true
+	p := newFilterPushdownProxy(t, srv.URL)
+	fake.stored = p.labelTranslator.ToVL
+	code, got, body := detectedLevelQuery(t, p, query, end, end, time.Minute)
+	if code != http.StatusOK || len(got) == 0 {
+		t.Fatalf("status %d %.200s %v", code, body, got)
+	}
+	fake.mu.Lock()
+	defer fake.mu.Unlock()
+	longest, keys := 0, 0
+	for _, q := range append(append(append([]string(nil), fake.stats...), fake.guards...), fake.presenceCalls...) {
+		longest = max(longest, len(q))
+		if strings.Contains(q, "(?s:.*)") && !strings.Contains(q, "unpack_json") { // the keys probe, not the unpack probe
+			keys++
+			if strings.Contains(q, "seq(") {
+				t.Errorf("the keys probe of a long selector kept its gate (%d bytes)", len(q))
+			}
+		}
+	}
+	if longest > vlDefaultMaxQueryLen || longest < 12500 || keys != 1 {
+		t.Fatalf("longest request %d bytes (limit %d), keys probes %d", longest, vlDefaultMaxQueryLen, keys)
+	}
+}
diff --git a/internal/proxy/ordered_json_metric.go b/internal/proxy/ordered_json_metric.go
index 33be61068..4897bd48f 100644
--- a/internal/proxy/ordered_json_metric.go
+++ b/internal/proxy/ordered_json_metric.go
@@ -1640,15 +1640,30 @@ func detectedLevelStoredFilter() string {
 // of every line that holds a level key, which is every line of a body-only
 // window, and only a line with two of them can match.
 func (p *Proxy) detectedLevelKeysRisk(ctx context.Context, base string, start, end time.Time) (bool, error) {
+	query := detectedLevelKeysQuery(base, true)
+	if len(query) > vlDefaultMaxQueryLen {
+		// The gate only narrows what the patterns run on, so a selector too long
+		// for the gated text gets the probe without it: the same verdict.
+		query = detectedLevelKeysQuery(base, false)
+	}
+	return p.statsPushdownRiskExists(ctx, query, start, end)
+}
+
+// detectedLevelKeysQuery is the probe of detectedLevelKeysRisk, with the two-keys
+// patterns behind detectedLevelTwiceGate or not.
+func detectedLevelKeysQuery(base string, gated bool) string {
 	const closed = `\}[\s\v\x{85}\p{Z}]*$`
 	braced := strconv.Quote(translator.BracedLineRegexp)
 	twice := func(key string) string { return key + `(?s:.*)` + key }
-	query := base + detectedLevelStoredFilter() + " | filter " + detectedLevelWordFilter() +
-		" ((" + detectedLevelTwiceGate() + " ((_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelJSONKey)) + ")" +
-		" or (-_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelLogfmtKey)) + ")))" +
+	twoKeys := "((_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelJSONKey)) + ")" +
+		" or (-_msg:~" + braced + " _msg:~" + strconv.Quote(twice(detectedLevelLogfmtKey)) + "))"
+	if gated {
+		twoKeys = "(" + detectedLevelTwiceGate() + " " + twoKeys + ")"
+	}
+	return base + detectedLevelStoredFilter() + " | filter " + detectedLevelWordFilter() +
+		" (" + twoKeys +
 		" or (_msg:~" + braced + " _msg:~" + strconv.Quote(detectedLevelJSONKey+`\s*"[^"\\]*\\`) + ")" +
 		" or (_msg:~" + braced + " -_msg:~" + strconv.Quote(closed) + " _msg:~" + strconv.Quote(detectedLevelLogfmtKey) + ")) | limit 1"
-	return p.statsPushdownRiskExists(ctx, query, start, end)
 }
 
 // detectedLevelTwiceGate passes the lines that hold two level keys, a superset

From 329a0ac10c54ce28cdc03121a4a1289a3dbd2628 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Fri, 16 Oct 2026 22:22:26 +0200
Subject: [PATCH 03/14] perf: the probes of the labels run once for the
 stored-level query and the chain

A plan that groups by a label and reads detected_level asks twice on rows with
no stored level, and the verdict of its label probes (main's partial-parse probe
among them) was remembered under a key that told the two asks apart, so the
same query ran twice in a first view. The label probes and the level probes are
remembered apart now: the chain takes the verdict of the label probes from the
stored-level query and asks only for the level probes. The verdict is risky if
either is.
---
 .../proxy/detected_level_label_probes_test.go |  62 +++++++
 .../ordered_json_filter_pushdown_test.go      |   4 +-
 internal/proxy/ordered_json_metric.go         | 155 ++++++++++--------
 .../proxy/ordered_json_stats_pushdown_test.go |   4 +-
 test/e2e-compat/json_detected_level_test.go   |   5 +-
 5 files changed, 159 insertions(+), 71 deletions(-)
 create mode 100644 internal/proxy/detected_level_label_probes_test.go

diff --git a/internal/proxy/detected_level_label_probes_test.go b/internal/proxy/detected_level_label_probes_test.go
new file mode 100644
index 000000000..c912f6b74
--- /dev/null
+++ b/internal/proxy/detected_level_label_probes_test.go
@@ -0,0 +1,62 @@
+package proxy
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+)
+
+func countPartialParseProbes(guards []string) int {
+	n := 0
+	for _, g := range guards {
+		if strings.Contains(g, "unpack_json fields (level) keep_original_fields | filter (level:=") {
+			n++
+		}
+	}
+	return n
+}
+
+// A plan that groups by a label and reads detected_level asks twice on rows with
+// no stored level: the stored-level query, then the chain. The probes of the
+// label (main's partial-parse probe) are the same query both times and are
+// remembered apart from the level probes, so the chain takes their verdict from
+// the attempt: one request on a cold window, none on the next ask, and a line
+// that makes the label risky still sends the query to the raw-row evaluator.
+// conformance: semantics/json-metric-detected-level-derivation
+func TestLabelProbesRunOnceForTheAttemptAndTheChain(t *testing.T) {
+	s0 := time.Unix(1700000400, 0).UTC()
+	end := s0.Add(6 * time.Minute)
+	const query = `sum by (level, detected_level) (count_over_time({env="prod"} | json | drop __error__ [5m]))`
+	srv, fake := newPushdownFakeVL(t, scanFixture(s0, false), nil)
+	fake.presence = true
+	p := newFilterPushdownProxy(t, srv.URL)
+	fake.stored = p.labelTranslator.ToVL
+	for i, want := range []int{1, 1} { // the second ask of the same window adds none
+		if code, got, body := detectedLevelQuery(t, p, query, end, end, time.Minute); code != http.StatusOK || len(got) == 0 {
+			t.Fatalf("ask %d: status %d %.200s %v", i, code, body, got)
+		}
+		fake.mu.Lock()
+		n, raw := countPartialParseProbes(fake.guards), fake.raw
+		fake.mu.Unlock()
+		if n != want || raw != 0 {
+			t.Fatalf("ask %d: %d partial-parse probes (want %d), %d raw requests", i, n, want, raw)
+		}
+	}
+
+	// A line VictoriaLogs does not parse as Loki does (text after the closing brace) is
+	// found by the label probe, whichever ask runs it.
+	rows := append(scanFixture(s0, false), pushdownRow{ts: s0.Add(5 * time.Minute), stream: map[string]string{"app": "api", "env": "prod"}, msg: `{"level":"warn"} trailing`})
+	srv, fake = newPushdownFakeVL(t, rows, nil)
+	fake.presence = true
+	p = newFilterPushdownProxy(t, srv.URL)
+	fake.stored = p.labelTranslator.ToVL
+	if code, _, body := detectedLevelQuery(t, p, query, end, end, time.Minute); code != http.StatusOK {
+		t.Fatalf("status %d %.200s", code, body)
+	}
+	fake.mu.Lock()
+	defer fake.mu.Unlock()
+	if fake.raw == 0 {
+		t.Fatalf("the risky line did not send the query to the raw-row evaluator (%d partial-parse probes)", countPartialParseProbes(fake.guards))
+	}
+}
diff --git a/internal/proxy/ordered_json_filter_pushdown_test.go b/internal/proxy/ordered_json_filter_pushdown_test.go
index bc4fc60b2..b814b6a59 100644
--- a/internal/proxy/ordered_json_filter_pushdown_test.go
+++ b/internal/proxy/ordered_json_filter_pushdown_test.go
@@ -836,8 +836,8 @@ func TestOrderedJSONFilterPushdownUsesStatsBuckets(t *testing.T) {
 					stats = nil
 				} else {
 					// Some do not: the stored-level attempt, with its label probes,
-					// then the chain with the level probes.
-					guards += tc.guards - levelProbes
+					// then the chain with the level probes; the chain takes the
+					// label probes' verdict from the attempt.
 					stats = chain
 				}
 			}
diff --git a/internal/proxy/ordered_json_metric.go b/internal/proxy/ordered_json_metric.go
index 4897bd48f..77d11c39e 100644
--- a/internal/proxy/ordered_json_metric.go
+++ b/internal/proxy/ordered_json_metric.go
@@ -1706,70 +1706,13 @@ const statsPushdownRiskSettle = 5 * time.Minute
 // remembering the window already found free of risky lines per tenant, query
 // and field set, so a refresh or a wider range checks only the uncovered part
 // (coveredWindowProbe). A window with a risky line is never cached.
+//
+// The probes of the labels (parse differences of the grouped fields) and the
+// level probes (lines the detected_level pipes read differently) are
+// remembered apart: the stored-level attempt and the chain, which the same
+// request asks one after the other, share the label probes, and only the chain
+// asks for the level probes. A verdict is risky if either is.
 func (p *Proxy) cachedStatsPushdownRisk(ctx context.Context, parser, base string, fields []string, stored map[string]string, errorFilters []string, levelRisk bool, start, end time.Time) (bool, error) {
-	check := func(from, to time.Time) (bool, error) {
-		// The probes run beside each other; one round trip.
-		type result struct {
-			risky bool
-			err   error
-		}
-		probes := []func(context.Context) (bool, error){
-			func(ctx context.Context) (bool, error) {
-				if len(errorFilters) == 0 {
-					return false, nil
-				}
-				return p.statsPushdownStoredFieldRisk(ctx, parser, base, errorFilters, stored, from, to)
-			},
-		}
-		if levelRisk {
-			probes = append(probes,
-				func(ctx context.Context) (bool, error) { return p.detectedLevelStreamRisk(ctx, base, from, to) },
-				func(ctx context.Context) (bool, error) { return p.detectedLevelKeysRisk(ctx, base, from, to) },
-				func(ctx context.Context) (bool, error) { return p.detectedLevelUnpackRisk(ctx, base, from, to) })
-		}
-		// A plan that only derives detected_level has no label to probe.
-		fieldParser := parser
-		if len(fields) == 0 {
-			fieldParser = ""
-		}
-		if fieldParser != "" {
-			probes = append(probes, func(ctx context.Context) (bool, error) {
-				return p.extractedBothKeysRisk(ctx, fieldParser, base, fields, from, to)
-			})
-		}
-		switch fieldParser {
-		case "json":
-			probes = append(probes,
-				func(ctx context.Context) (bool, error) {
-					return p.orderedJSONPartialParseRisk(ctx, base, fields, stored, from, to)
-				},
-				func(ctx context.Context) (bool, error) {
-					return p.orderedJSONKeySpellingRisk(ctx, base, fields, stored, from, to)
-				})
-		case "logfmt":
-			probes = append(probes, func(ctx context.Context) (bool, error) {
-				return p.logfmtParseRisk(ctx, base, fields, stored, from, to)
-			})
-		}
-		// The first risky verdict (or error) decides; the other probes are
-		// cancelled rather than waited for.
-		probeCtx, cancel := context.WithCancel(ctx)
-		defer cancel()
-		results := make(chan result, len(probes))
-		for _, probe := range probes {
-			go func() {
-				risky, err := probe(probeCtx)
-				results <- result{risky, err}
-			}()
-		}
-		for range probes {
-			r := <-results
-			if r.err != nil || r.risky {
-				return r.risky, r.err
-			}
-		}
-		return false, nil
-	}
 	spelled := make([]string, len(fields))
 	for i, field := range fields {
 		spelled[i] = field
@@ -1777,14 +1720,96 @@ func (p *Proxy) cachedStatsPushdownRisk(ctx context.Context, parser, base string
 			spelled[i] += "=" + vl
 		}
 	}
-	key := "stats-pushdown-risk:v4:" + getOrgID(ctx) + ":" + parser + ":" + strings.Join(spelled, ",") + ":" + strings.Join(errorFilters, ",") + ":" + strconv.FormatBool(levelRisk) + ":" + base
+	labels := func(ctx context.Context) (bool, error) {
+		key := "stats-pushdown-risk:v5:" + getOrgID(ctx) + ":" + parser + ":" + strings.Join(spelled, ",") + ":" + strings.Join(errorFilters, ",") + ":" + base
+		return p.rememberedRisk(ctx, key, start, end, func(from, to time.Time) []func(context.Context) (bool, error) {
+			probes := []func(context.Context) (bool, error){
+				func(ctx context.Context) (bool, error) {
+					if len(errorFilters) == 0 {
+						return false, nil
+					}
+					return p.statsPushdownStoredFieldRisk(ctx, parser, base, errorFilters, stored, from, to)
+				},
+			}
+			// A plan that only derives detected_level has no label to probe.
+			fieldParser := parser
+			if len(fields) == 0 {
+				fieldParser = ""
+			}
+			if fieldParser != "" {
+				probes = append(probes, func(ctx context.Context) (bool, error) {
+					return p.extractedBothKeysRisk(ctx, fieldParser, base, fields, from, to)
+				})
+			}
+			switch fieldParser {
+			case "json":
+				probes = append(probes,
+					func(ctx context.Context) (bool, error) {
+						return p.orderedJSONPartialParseRisk(ctx, base, fields, stored, from, to)
+					},
+					func(ctx context.Context) (bool, error) {
+						return p.orderedJSONKeySpellingRisk(ctx, base, fields, stored, from, to)
+					})
+			case "logfmt":
+				probes = append(probes, func(ctx context.Context) (bool, error) {
+					return p.logfmtParseRisk(ctx, base, fields, stored, from, to)
+				})
+			}
+			return probes
+		})
+	}
+	if !levelRisk {
+		return labels(ctx)
+	}
+	levels := func(ctx context.Context) (bool, error) {
+		key := "stats-pushdown-risk:v5:level:" + getOrgID(ctx) + ":" + base
+		return p.rememberedRisk(ctx, key, start, end, func(from, to time.Time) []func(context.Context) (bool, error) {
+			return []func(context.Context) (bool, error){
+				func(ctx context.Context) (bool, error) { return p.detectedLevelStreamRisk(ctx, base, from, to) },
+				func(ctx context.Context) (bool, error) { return p.detectedLevelKeysRisk(ctx, base, from, to) },
+				func(ctx context.Context) (bool, error) { return p.detectedLevelUnpackRisk(ctx, base, from, to) },
+			}
+		})
+	}
+	return anyRisk(ctx, []func(context.Context) (bool, error){labels, levels})
+}
+
+// rememberedRisk runs the probes of the parts of [start, end] that the verdict
+// under key does not cover (coveredWindowProbe).
+func (p *Proxy) rememberedRisk(ctx context.Context, key string, start, end time.Time, probes func(from, to time.Time) []func(context.Context) (bool, error)) (bool, error) {
 	_, risky, err := p.coveredWindowProbe(ctx, key, start, end, func(from, to time.Time, _ string) (string, bool, error) {
-		risky, err := check(from, to)
+		risky, err := anyRisk(ctx, probes(from, to))
 		return "", risky, err
 	})
 	return risky, err
 }
 
+// anyRisk runs the probes beside each other, one round trip. The first risky
+// verdict (or error) decides; the other probes are cancelled rather than
+// waited for.
+func anyRisk(ctx context.Context, probes []func(context.Context) (bool, error)) (bool, error) {
+	type result struct {
+		risky bool
+		err   error
+	}
+	probeCtx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	results := make(chan result, len(probes))
+	for _, probe := range probes {
+		go func() {
+			risky, err := probe(probeCtx)
+			results <- result{risky, err}
+		}()
+	}
+	for range probes {
+		r := <-results
+		if r.err != nil || r.risky {
+			return r.risky, r.err
+		}
+	}
+	return false, nil
+}
+
 // statsPushdownRiskExists runs a `| limit 1` risk query over [start, end] and
 // reports whether it matched a line.
 func (p *Proxy) statsPushdownRiskExists(ctx context.Context, query string, start, end time.Time) (bool, error) {
diff --git a/internal/proxy/ordered_json_stats_pushdown_test.go b/internal/proxy/ordered_json_stats_pushdown_test.go
index 711de4502..5ac4f88d5 100644
--- a/internal/proxy/ordered_json_stats_pushdown_test.go
+++ b/internal/proxy/ordered_json_stats_pushdown_test.go
@@ -472,8 +472,6 @@ func TestOrderedJSONLogsVolumeUsesStatsBuckets(t *testing.T) {
 			}
 			if !strings.Contains(tc.query, "by (level") {
 				guards-- // no label to probe: only the detected_level probes run
-			} else if strings.Contains(tc.query, "detected_level") {
-				guards++ // the stored-level attempt (a row has no stored level) probes the label on its own
 			}
 			chain := chainStatsCalls(fake.statsCalls)
 			if fake.rawCalls != 0 || len(chain) != 1 || len(fake.guardCalls) != guards {
@@ -646,7 +644,7 @@ func TestLevelVolumePlainAndLogfmtUseStatsBuckets(t *testing.T) {
 		stats         string
 	}{
 		{`sum by (level, detected_level) (count_over_time({app="api"} | drop __error__[1m]))`, "", 0, "| delete __dl, __dl_*, __j_*, __l_* | stats by (level, detected_level) count() as c"},
-		{`sum by (level, detected_level) (count_over_time({app="api"} | logfmt | drop __error__[1m]))`, "logfmt", 2 + levelProbes, "unpack_logfmt fields (level) keep_original_fields | stats by (level, detected_level) count() as c"},
+		{`sum by (level, detected_level) (count_over_time({app="api"} | logfmt | drop __error__[1m]))`, "logfmt", 1 + levelProbes, "unpack_logfmt fields (level) keep_original_fields | stats by (level, detected_level) count() as c"},
 	} {
 		t.Run(tc.query, func(t *testing.T) {
 			srv, fake := newJSONVolumeFakeVL(t, lines)
diff --git a/test/e2e-compat/json_detected_level_test.go b/test/e2e-compat/json_detected_level_test.go
index 98419bcf0..663dfad8d 100644
--- a/test/e2e-compat/json_detected_level_test.go
+++ b/test/e2e-compat/json_detected_level_test.go
@@ -383,7 +383,10 @@ func isStoredLevelAttempt(call string) bool {
 // send, given the probes of its parsed labels (plain), the three of the chain
 // (level), the stored-level attempts and the chain stats requests it made: the
 // attempt alone answered (the labels' probes only), the attempt then the chain
-// (both sets), or the chain alone (a remembered verdict).
+// (both sets; the labels' probes ask once when the proxy remembers verdicts,
+// as in production, and twice when it has no cache, as in these in-process
+// proxies, which the unit tests count exactly), or the chain alone (a
+// remembered verdict).
 func levelStatsOutcome(plain, level, attempts, stats int) (lo, hi int, ok bool) {
 	switch {
 	case attempts == 1 && stats == 0:

From 9f9d9f007a41a22e1b74779cd5fcf64ef22c6d18 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Fri, 16 Oct 2026 22:44:41 +0200
Subject: [PATCH 04/14] test: the e2e of the keys gate writes to VictoriaLogs
 only

Its probes read nothing else, and the shared helper pushes the lines to Loki and
flushes it, which other tests of the suite do not expect of a test that runs
before them.
---
 .../detected_level_keys_gate_test.go          | 39 ++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/test/e2e-compat/detected_level_keys_gate_test.go b/test/e2e-compat/detected_level_keys_gate_test.go
index 8e647c23d..a433a9c11 100644
--- a/test/e2e-compat/detected_level_keys_gate_test.go
+++ b/test/e2e-compat/detected_level_keys_gate_test.go
@@ -3,6 +3,7 @@
 package e2e_compat
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/url"
@@ -64,6 +65,42 @@ func extractLevelTwiceGate(t *testing.T, query string) (gate string, start int)
 	return "", 0
 }
 
+// ingestVictoriaLogsLines writes the lines of each app into VictoriaLogs only
+// (one stream per app) and waits until they are searchable. The probes under
+// test read nothing else, and a test that pushed them to Loki too would leave
+// Loki's ingesters and index in a state the other tests of the suite do not
+// expect (ingestJSONVolumeFixture flushes it).
+func ingestVictoriaLogsLines(t *testing.T, apps map[string][]jsonVolumeStreamLine) {
+	t.Helper()
+	for app, lines := range apps {
+		var rows strings.Builder
+		for _, line := range lines {
+			row, _ := json.Marshal(map[string]string{"_time": line.ts.UTC().Format(time.RFC3339Nano), "_msg": line.msg, "app": app})
+			rows.Write(row)
+			rows.WriteByte('\n')
+		}
+		status, body := hardeningRequest(t, http.MethodPost, vlURL+"/insert/jsonline?_stream_fields=app", rows.String(), map[string]string{"Content-Type": "application/stream+json"})
+		if status != http.StatusOK {
+			t.Fatalf("VictoriaLogs ingest: %d %s", status, body)
+		}
+	}
+	forceVLFlush(t)
+	deadline := time.Now().Add(60 * time.Second)
+	for app, lines := range apps {
+		for {
+			form := url.Values{"query": {`app:=` + fmt.Sprintf("%q", app) + ` | stats count() as n`}, "start": {lines[0].ts.Add(-time.Hour).UTC().Format(time.RFC3339Nano)}, "end": {lines[0].ts.Add(time.Hour).UTC().Format(time.RFC3339Nano)}}
+			_, body := hardeningRequest(t, http.MethodPost, vlURL+"/select/logsql/query", form.Encode(), map[string]string{"Content-Type": "application/x-www-form-urlencoded"})
+			if strings.Contains(string(body), fmt.Sprintf(`"n":"%d"`, len(lines))) {
+				break
+			}
+			if time.Now().After(deadline) {
+				t.Fatalf("%s: %d lines never became searchable in VictoriaLogs", app, len(lines))
+			}
+			time.Sleep(200 * time.Millisecond)
+		}
+	}
+}
+
 // The gate in front of the keys probe's two-keys patterns changes no verdict:
 // the probe the proxy sent, and the same probe without the gate, give the same
 // answer on each line of the fixture, one line to a stream, on this
@@ -79,7 +116,7 @@ func TestRangeMetricCompatibilityDetectedLevelKeysGate(t *testing.T) {
 		apps[i] = fmt.Sprintf("level-keys-gate-%02d-%d", i, now.UnixNano())
 		fixture[apps[i]] = []jsonVolumeStreamLine{{ts: s0.Add(10 * time.Second), msg: line.msg}}
 	}
-	ingestJSONVolumeFixture(t, fixture)
+	ingestVictoriaLogsLines(t, fixture)
 	start, end := s0, s0.Add(2*time.Minute)
 
 	// The probe is whatever the proxy sends: captured for a line that clears

From ea28a2a4782ca7951a4e07eb8d411fcd44efa8e1 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 00:08:05 +0200
Subject: [PATCH 05/14] test: A/B results of the first-view cuts against main
 and against main before #760, in both measurement orders

---
 .../ab/results/2026-10-16-dlfirstview-1h.json |  231 +++
 .../2026-10-16-dlfirstview-control-1h.json    |  707 +++++++++
 .../2026-10-16-dlfirstview-d-capped-1h.json   |   61 +
 .../2026-10-16-dlfirstview-d-capped-long.json |   85 ++
 .../2026-10-16-dlfirstview-dl6-capped-1h.json |   61 +
 ...026-10-16-dlfirstview-dl6-capped-long.json |   85 ++
 .../results/2026-10-16-dlfirstview-long.json  |  375 +++++
 .../2026-10-16-dlfirstview-bodyonly-1h.json   |  231 +++
 .../2026-10-16-dlfirstview-bodyonly-d-1h.json |   61 +
 ...026-10-16-dlfirstview-bodyonly-d-long.json |   85 ++
 ...026-10-16-dlfirstview-bodyonly-dl6-1h.json |   61 +
 ...6-10-16-dlfirstview-bodyonly-dl6-long.json |   85 ++
 .../2026-10-16-dlfirstview-bodyonly-long.json |  375 +++++
 ...10-16-dlfirstview-bodyonly-swapped-1h.json |  231 +++
 ...-16-dlfirstview-bodyonly-swapped-d-1h.json |   61 +
 ...6-dlfirstview-bodyonly-swapped-d-long.json |   85 ++
 ...6-dlfirstview-bodyonly-swapped-dl6-1h.json |   61 +
 ...dlfirstview-bodyonly-swapped-dl6-long.json |   85 ++
 ...-16-dlfirstview-bodyonly-swapped-long.json |  375 +++++
 ...0-16-dlfirstview-bodyonly-vlonly-d-1h.json |   56 +
 ...6-dlfirstview-bodyonly-vlonly-dlv5-1h.json |   56 +
 ...irstview-bodyonly-vlonly-swapped-d-1h.json |   56 +
 ...tview-bodyonly-vlonly-swapped-dlv5-1h.json |   56 +
 .../2026-10-16-dlfirstview-swapped-1h.json    |  231 +++
 ...-10-16-dlfirstview-swapped-control-1h.json |  707 +++++++++
 .../2026-10-16-dlfirstview-swapped-d-1h.json  |   61 +
 ...2026-10-16-dlfirstview-swapped-d-long.json |   85 ++
 ...2026-10-16-dlfirstview-swapped-dl6-1h.json |   61 +
 ...26-10-16-dlfirstview-swapped-dl6-long.json |   85 ++
 .../2026-10-16-dlfirstview-swapped-long.json  |  375 +++++
 ...iew-vs-before760-bodyonly-vlonly-d-1h.json |   56 +
 ...-vs-before760-bodyonly-vlonly-dlv5-1h.json |   56 +
 ...efore760-bodyonly-vlonly-swapped-d-1h.json |   56 +
 ...re760-bodyonly-vlonly-swapped-dlv5-1h.json |   56 +
 .../registry/generated/perf-evidence.json     | 1336 ++++++++---------
 conformance/reports/performance.md            |   25 +-
 36 files changed, 6134 insertions(+), 681 deletions(-)
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-1h.json
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-control-1h.json
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-d-capped-1h.json
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-d-capped-long.json
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-dl6-capped-1h.json
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-dl6-capped-long.json
 create mode 100644 bench/ab/results/2026-10-16-dlfirstview-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-dlv5-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-dlv5-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-control-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-long.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-dlv5-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-d-1h.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-dlv5-1h.json

diff --git a/bench/ab/results/2026-10-16-dlfirstview-1h.json b/bench/ab/results/2026-10-16-dlfirstview-1h.json
new file mode 100644
index 000000000..f9ae01b83
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-1h.json
@@ -0,0 +1,231 @@
+{
+ "label": "dlfirstview-1h",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 6
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "1h",
+   "p50": {
+    "base": 0.54,
+    "pr": 0.554,
+    "loki": 0.015
+   },
+   "p95": {
+    "base": 0.555,
+    "pr": 0.566,
+    "loki": 0.017
+   },
+   "cold": {
+    "base": 0.517,
+    "pr": 0.536,
+    "loki": 0.202
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 64.95,
+    "pr": 64.95,
+    "loki": 64.95
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.97
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 2.231,
+    "pr": 2.209,
+    "loki": 0.026
+   },
+   "p95": {
+    "base": 2.241,
+    "pr": 2.281,
+    "loki": 0.033
+   },
+   "cold": {
+    "base": 2.208,
+    "pr": 2.246,
+    "loki": 0.411
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 36.25,
+    "pr": 32.78,
+    "loki": 32.78
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.538,
+    "pr": 0.526,
+    "loki": 0.01
+   },
+   "p95": {
+    "base": 0.618,
+    "pr": 0.54,
+    "loki": 0.013
+   },
+   "cold": {
+    "base": 0.523,
+    "pr": 0.529,
+    "loki": 0.097
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 25.08,
+    "pr": 25.08,
+    "loki": 25.08
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.02
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.052,
+    "pr": 0.037,
+    "loki": 0.007
+   },
+   "p95": {
+    "base": 0.058,
+    "pr": 0.052,
+    "loki": 0.009
+   },
+   "cold": {
+    "base": 0.037,
+    "pr": 0.023,
+    "loki": 0.103
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 27.69,
+    "pr": 27.69,
+    "loki": 27.69
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.41
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.009,
+    "pr": 0.009,
+    "loki": 0.022
+   },
+   "p95": {
+    "base": 0.012,
+    "pr": 0.01,
+    "loki": 0.031
+   },
+   "cold": {
+    "base": 0.007,
+    "pr": 0.006,
+    "loki": 0.423
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 12.5,
+    "pr": 12.5,
+    "loki": 12.5
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "1h",
+   "p50": {
+    "base": 0.013,
+    "pr": 0.011,
+    "loki": 0.018
+   },
+   "p95": {
+    "base": 0.018,
+    "pr": 0.017,
+    "loki": 0.025
+   },
+   "cold": {
+    "base": 0.011,
+    "pr": 0.006,
+    "loki": 0.403
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 11.26,
+    "pr": 11.26,
+    "loki": 11.26
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.18
+  }
+ ]
+}
diff --git a/bench/ab/results/2026-10-16-dlfirstview-control-1h.json b/bench/ab/results/2026-10-16-dlfirstview-control-1h.json
new file mode 100644
index 000000000..8370c514d
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-control-1h.json
@@ -0,0 +1,707 @@
+{
+ "label": "dlfirstview-control-1h",
+ "date": "2026-10-16",
+ "set": "control",
+ "description": "Shapes a change must not slow down or alter. Run on every performance-relevant PR.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 20
+ },
+ "result_differs_from_reference": 1,
+ "result_differs_preexisting": 1,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "logs plain",
+   "range": "1h",
+   "p50": {
+    "base": 0.025,
+    "pr": 0.021,
+    "loki": 0.025
+   },
+   "p95": {
+    "base": 0.032,
+    "pr": 0.023,
+    "loki": 0.029
+   },
+   "cold": {
+    "base": 0.026,
+    "pr": 0.023,
+    "loki": 0.026
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 18.11,
+    "pr": 18.11,
+    "loki": 18.11
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.19
+  },
+  {
+   "shape": "logs | json",
+   "range": "1h",
+   "p50": {
+    "base": 0.04,
+    "pr": 0.036,
+    "loki": 0.043
+   },
+   "p95": {
+    "base": 0.043,
+    "pr": 0.043,
+    "loki": 0.044
+   },
+   "cold": {
+    "base": 0.024,
+    "pr": 0.022,
+    "loki": 0.054
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 21.39,
+    "pr": 25.78,
+    "loki": 25.78
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.11
+  },
+  {
+   "shape": "logs | logfmt",
+   "range": "1h",
+   "p50": {
+    "base": 0.057,
+    "pr": 0.099,
+    "loki": 0.032
+   },
+   "p95": {
+    "base": 0.073,
+    "pr": 0.101,
+    "loki": 0.034
+   },
+   "cold": {
+    "base": 0.032,
+    "pr": 0.036,
+    "loki": 0.036
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 43.2,
+    "pr": 43.2,
+    "loki": 43.2
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.58
+  },
+  {
+   "shape": "json volume no filters",
+   "range": "1h",
+   "p50": {
+    "base": 0.056,
+    "pr": 0.093,
+    "loki": 0.026
+   },
+   "p95": {
+    "base": 0.061,
+    "pr": 0.1,
+    "loki": 0.032
+   },
+   "cold": {
+    "base": 0.037,
+    "pr": 0.1,
+    "loki": 0.421
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 61.18,
+    "pr": 61.18,
+    "loki": 61.18
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.6
+  },
+  {
+   "shape": "logfmt volume",
+   "range": "1h",
+   "p50": {
+    "base": 0.135,
+    "pr": 0.122,
+    "loki": 0.043
+   },
+   "p95": {
+    "base": 0.153,
+    "pr": 0.173,
+    "loki": 0.044
+   },
+   "cold": {
+    "base": 0.098,
+    "pr": 0.066,
+    "loki": 0.605
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 67.58,
+    "pr": 67.58,
+    "loki": 67.58
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.11
+  },
+  {
+   "shape": "plain volume",
+   "range": "1h",
+   "p50": {
+    "base": 0.013,
+    "pr": 0.009,
+    "loki": 0.024
+   },
+   "p95": {
+    "base": 0.017,
+    "pr": 0.014,
+    "loki": 0.035
+   },
+   "cold": {
+    "base": 0.011,
+    "pr": 0.006,
+    "loki": 0.341
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 62.19,
+    "pr": 62.19,
+    "loki": 62.19
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.44
+  },
+  {
+   "shape": "stream-label count by app",
+   "range": "1h",
+   "p50": {
+    "base": 0.013,
+    "pr": 0.015,
+    "loki": 0.019
+   },
+   "p95": {
+    "base": 0.016,
+    "pr": 0.02,
+    "loki": 0.026
+   },
+   "cold": {
+    "base": 0.02,
+    "pr": 0.012,
+    "loki": 0.319
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 10.52,
+    "pr": 8.45,
+    "loki": 8.45
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.87
+  },
+  {
+   "shape": "ungrouped rate",
+   "range": "1h",
+   "p50": {
+    "base": 0.007,
+    "pr": 0.008,
+    "loki": 0.046
+   },
+   "p95": {
+    "base": 0.008,
+    "pr": 0.011,
+    "loki": 0.053
+   },
+   "cold": {
+    "base": 0.008,
+    "pr": 0.005,
+    "loki": 0.338
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 9.57,
+    "pr": 9.57,
+    "loki": 9.57
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.88
+  },
+  {
+   "shape": "bytes_over_time by app",
+   "range": "1h",
+   "p50": {
+    "base": 0.029,
+    "pr": 0.032,
+    "loki": 0.04
+   },
+   "p95": {
+    "base": 0.035,
+    "pr": 0.036,
+    "loki": 0.044
+   },
+   "cold": {
+    "base": 0.034,
+    "pr": 0.023,
+    "loki": 0.354
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 27.19,
+    "pr": 27.19,
+    "loki": 27.19
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.91
+  },
+  {
+   "shape": "topk rate by app",
+   "range": "1h",
+   "p50": {
+    "base": 0.022,
+    "pr": 0.02,
+    "loki": 0.044
+   },
+   "p95": {
+    "base": 0.03,
+    "pr": 0.022,
+    "loki": 0.051
+   },
+   "cold": {
+    "base": 0.017,
+    "pr": 0.02,
+    "loki": 0.338
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 27.19,
+    "pr": 27.19,
+    "loki": 16.36
+   },
+   "parity_vs_reference": "differs",
+   "baseline_parity_vs_reference": "differs",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.1
+  },
+  {
+   "shape": "detected_level volume",
+   "range": "1h",
+   "p50": {
+    "base": 0.021,
+    "pr": 0.025,
+    "loki": 0.021
+   },
+   "p95": {
+    "base": 0.027,
+    "pr": 0.034,
+    "loki": 0.03
+   },
+   "cold": {
+    "base": 0.026,
+    "pr": 0.029,
+    "loki": 0.334
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 37.84,
+    "pr": 37.84,
+    "loki": 37.84
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.84
+  },
+  {
+   "shape": "by service_name",
+   "range": "1h",
+   "p50": {
+    "base": 0.015,
+    "pr": 0.015,
+    "loki": 0.02
+   },
+   "p95": {
+    "base": 0.025,
+    "pr": 0.023,
+    "loki": 0.023
+   },
+   "cold": {
+    "base": 0.018,
+    "pr": 0.013,
+    "loki": 0.337
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 13.06,
+    "pr": 13.06,
+    "loki": 13.06
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "drilldown level volume",
+   "range": "1h",
+   "p50": {
+    "base": 0.011,
+    "pr": 0.007,
+    "loki": 0.015
+   },
+   "p95": {
+    "base": 0.015,
+    "pr": 0.011,
+    "loki": 0.026
+   },
+   "cold": {
+    "base": 0.009,
+    "pr": 0.01,
+    "loki": 0.345
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 7.91,
+    "pr": 7.91,
+    "loki": 7.91
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.57
+  },
+  {
+   "shape": "drilldown service landing",
+   "range": "1h",
+   "p50": {
+    "base": 0.014,
+    "pr": 0.017,
+    "loki": 0.016
+   },
+   "p95": {
+    "base": 0.02,
+    "pr": 0.021,
+    "loki": 0.022
+   },
+   "cold": {
+    "base": 0.015,
+    "pr": 0.019,
+    "loki": 0.343
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 14.08,
+    "pr": 14.08,
+    "loki": 14.08
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.82
+  },
+  {
+   "shape": "drilldown detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.021,
+    "pr": 0.019,
+    "loki": 0.017
+   },
+   "p95": {
+    "base": 0.03,
+    "pr": 0.03,
+    "loki": 0.022
+   },
+   "cold": {
+    "base": 0.029,
+    "pr": 0.019,
+    "loki": 0.343
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 25.93,
+    "pr": 25.93,
+    "loki": 25.93
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.11
+  },
+  {
+   "shape": "json rate by level (no filter, no drop)",
+   "range": "1h",
+   "p50": {
+    "base": 0.003,
+    "pr": 0.002,
+    "loki": 0.054
+   },
+   "p95": {
+    "base": 0.003,
+    "pr": 0.005,
+    "loki": 0.068
+   },
+   "cold": {
+    "base": 0.005,
+    "pr": 0.002,
+    "loki": 0.078
+   },
+   "status": {
+    "base": "400",
+    "pr": "400",
+    "loki": "400"
+   },
+   "vl_cpu_max": {
+    "base": 17.2,
+    "pr": 17.2,
+    "loki": 17.2
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "logfmt count by level, filter, drop",
+   "range": "1h",
+   "p50": {
+    "base": 0.2,
+    "pr": 0.245,
+    "loki": 0.039
+   },
+   "p95": {
+    "base": 0.254,
+    "pr": 0.294,
+    "loki": 0.041
+   },
+   "cold": {
+    "base": 0.177,
+    "pr": 0.273,
+    "loki": 0.546
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 117.31,
+    "pr": 117.31,
+    "loki": 117.31
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.82
+  },
+  {
+   "shape": "instant ungrouped rate",
+   "range": "instant",
+   "p50": {
+    "base": 0.004,
+    "pr": 0.007,
+    "loki": 0.031
+   },
+   "p95": {
+    "base": 0.007,
+    "pr": 0.008,
+    "loki": 0.048
+   },
+   "cold": {
+    "base": 0.005,
+    "pr": 0.007,
+    "loki": 0.044
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 108.82,
+    "pr": 108.82,
+    "loki": 108.82
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.57
+  },
+  {
+   "shape": "instant json volume",
+   "range": "instant",
+   "p50": {
+    "base": 0.197,
+    "pr": 0.215,
+    "loki": 0.05
+   },
+   "p95": {
+    "base": 0.204,
+    "pr": 0.222,
+    "loki": 0.052
+   },
+   "cold": {
+    "base": 0.217,
+    "pr": 0.215,
+    "loki": 0.046
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 11.56,
+    "pr": 18.4,
+    "loki": 18.4
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.92
+  },
+  {
+   "shape": "instant json filtered",
+   "range": "instant",
+   "p50": {
+    "base": 0.166,
+    "pr": 0.175,
+    "loki": 0.032
+   },
+   "p95": {
+    "base": 0.176,
+    "pr": 0.178,
+    "loki": 0.038
+   },
+   "cold": {
+    "base": 0.166,
+    "pr": 0.179,
+    "loki": 0.03
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 18.4,
+    "pr": 18.4,
+    "loki": 18.4
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.95
+  }
+ ]
+}
diff --git a/bench/ab/results/2026-10-16-dlfirstview-d-capped-1h.json b/bench/ab/results/2026-10-16-dlfirstview-d-capped-1h.json
new file mode 100644
index 000000000..19842fd27
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-d-capped-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-d-capped-1h",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "base": 0.118,
+    "pr": 0.088,
+    "loki": 0.067
+   },
+   "p95": {
+    "base": 0.128,
+    "pr": 0.1,
+    "loki": 0.084
+   },
+   "cold": {
+    "base": 0.073,
+    "pr": 0.1,
+    "loki": 0.891
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 69.02,
+    "pr": 69.02,
+    "loki": 69.02
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.34
+  }
+ ]
+}
diff --git a/bench/ab/results/2026-10-16-dlfirstview-d-capped-long.json b/bench/ab/results/2026-10-16-dlfirstview-d-capped-long.json
new file mode 100644
index 000000000..5978af7d4
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-d-capped-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-d-capped-long",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "6h",
+   "p50": {
+    "base": 0.641,
+    "pr": 0.697
+   },
+   "p95": {
+    "base": 0.7,
+    "pr": 0.789
+   },
+   "cold": {
+    "base": 0.661,
+    "pr": 0.679
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 168.92,
+    "pr": 168.92
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.92
+  },
+  {
+   "shape": "D volume, no filters",
+   "range": "24h",
+   "p50": {
+    "base": 2.479,
+    "pr": 2.508
+   },
+   "p95": {
+    "base": 2.564,
+    "pr": 2.584
+   },
+   "cold": {
+    "base": 2.782,
+    "pr": 2.677
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 201.23,
+    "pr": 201.23
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  }
+ ]
+}
diff --git a/bench/ab/results/2026-10-16-dlfirstview-dl6-capped-1h.json b/bench/ab/results/2026-10-16-dlfirstview-dl6-capped-1h.json
new file mode 100644
index 000000000..3b24d5d5b
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-dl6-capped-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-dl6-capped-1h",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "1h",
+   "p50": {
+    "base": 0.288,
+    "pr": 0.3,
+    "loki": 0.022
+   },
+   "p95": {
+    "base": 0.382,
+    "pr": 0.384,
+    "loki": 0.075
+   },
+   "cold": {
+    "base": 0.561,
+    "pr": 0.595,
+    "loki": 0.658
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 104.97,
+    "pr": 142.65,
+    "loki": 142.65
+   },
+   "parity_vs_reference": "same series, sum \u00b10.25%",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.96
+  }
+ ]
+}
diff --git a/bench/ab/results/2026-10-16-dlfirstview-dl6-capped-long.json b/bench/ab/results/2026-10-16-dlfirstview-dl6-capped-long.json
new file mode 100644
index 000000000..26fa7c166
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-dl6-capped-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-dl6-capped-long",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "6h",
+   "p50": {
+    "base": 1.653,
+    "pr": 1.693
+   },
+   "p95": {
+    "base": 1.709,
+    "pr": 1.784
+   },
+   "cold": {
+    "base": 3.768,
+    "pr": 3.496
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 199.03,
+    "pr": 198.21
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.98
+  },
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "24h",
+   "p50": {
+    "base": 6.594,
+    "pr": 6.536
+   },
+   "p95": {
+    "base": 6.617,
+    "pr": 6.579
+   },
+   "cold": {
+    "base": 12.795,
+    "pr": 12.604
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 204.59,
+    "pr": 220.45
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  }
+ ]
+}
diff --git a/bench/ab/results/2026-10-16-dlfirstview-long.json b/bench/ab/results/2026-10-16-dlfirstview-long.json
new file mode 100644
index 000000000..bdc26d39d
--- /dev/null
+++ b/bench/ab/results/2026-10-16-dlfirstview-long.json
@@ -0,0 +1,375 @@
+{
+ "label": "dlfirstview-long",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 12
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "6h",
+   "p50": {
+    "base": 3.08,
+    "pr": 3.039
+   },
+   "p95": {
+    "base": 3.119,
+    "pr": 3.063
+   },
+   "cold": {
+    "base": 3.118,
+    "pr": 3.118
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 66.49,
+    "pr": 49.56
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "24h",
+   "p50": {
+    "base": 9.382,
+    "pr": 9.395
+   },
+   "p95": {
+    "base": 9.403,
+    "pr": 9.427
+   },
+   "cold": {
+    "base": 9.609,
+    "pr": 9.401
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 103.4,
+    "pr": 86.41
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 7.627,
+    "pr": 7.65
+   },
+   "p95": {
+    "base": 7.637,
+    "pr": 7.669
+   },
+   "cold": {
+    "base": 7.628,
+    "pr": 7.517
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 34.78,
+    "pr": 34.19
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 7.698,
+    "pr": 7.687
+   },
+   "p95": {
+    "base": 7.707,
+    "pr": 7.691
+   },
+   "cold": {
+    "base": 7.679,
+    "pr": 7.594
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 36.14,
+    "pr": 34.32
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 3.202,
+    "pr": 3.181
+   },
+   "p95": {
+    "base": 3.206,
+    "pr": 3.201
+   },
+   "cold": {
+    "base": 3.162,
+    "pr": 3.214
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 57.76,
+    "pr": 49.37
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 9.973,
+    "pr": 9.907
+   },
+   "p95": {
+    "base": 10.015,
+    "pr": 9.979
+   },
+   "cold": {
+    "base": 9.694,
+    "pr": 9.725
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 49.89,
+    "pr": 204.33
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 0.2,
+    "pr": 0.174
+   },
+   "p95": {
+    "base": 0.203,
+    "pr": 0.178
+   },
+   "cold": {
+    "base": 0.142,
+    "pr": 0.181
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 203.64,
+    "pr": 203.64
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.15
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 0.74,
+    "pr": 0.792
+   },
+   "p95": {
+    "base": 0.783,
+    "pr": 0.793
+   },
+   "cold": {
+    "base": 0.907,
+    "pr": 0.792
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 166.57,
+    "pr": 166.57
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.93
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 0.028,
+    "pr": 0.04
+   },
+   "p95": {
+    "base": 0.031,
+    "pr": 0.053
+   },
+   "cold": {
+    "base": 0.029,
+    "pr": 0.029
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 148.99,
+    "pr": 148.99
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.7
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 0.199,
+    "pr": 0.23
+   },
+   "p95": {
+    "base": 0.202,
+    "pr": 0.271
+   },
+   "cold": {
+    "base": 0.156,
+    "pr": 0.188
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 95.84,
+    "pr": 95.84
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.87
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "6h",
+   "p50": {
+    "base": 0.034,
+    "pr": 0.028
+   },
+   "p95": {
+    "base": 0.038,
+    "pr": 0.03
+   },
+   "cold": {
+    "base": 0.025,
+    "pr": 0.041
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 89.91,
+    "pr": 89.91
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.21
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "24h",
+   "p50": {
+    "base": 0.2,
+    "pr": 0.19
+   },
+   "p95": {
+    "base": 0.2,
+    "pr": 0.198
+   },
+   "cold": {
+    "base": 0.18,
+    "pr": 0.166
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 107.28,
+    "pr": 107.28
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.05
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-1h.json
new file mode 100644
index 000000000..f0e89493b
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-1h.json
@@ -0,0 +1,231 @@
+{
+ "label": "dlfirstview-bodyonly-1h",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 6
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "1h",
+   "p50": {
+    "base": 0.512,
+    "pr": 0.51,
+    "loki": 0.006
+   },
+   "p95": {
+    "base": 0.525,
+    "pr": 0.522,
+    "loki": 0.006
+   },
+   "cold": {
+    "base": 0.538,
+    "pr": 0.522,
+    "loki": 0.074
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 62.99,
+    "pr": 62.99,
+    "loki": 62.99
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 2.291,
+    "pr": 2.294,
+    "loki": 0.018
+   },
+   "p95": {
+    "base": 2.294,
+    "pr": 2.326,
+    "loki": 0.022
+   },
+   "cold": {
+    "base": 2.21,
+    "pr": 2.26,
+    "loki": 0.277
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 31.9,
+    "pr": 35.8,
+    "loki": 31.9
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.534,
+    "pr": 0.55,
+    "loki": 0.009
+   },
+   "p95": {
+    "base": 0.559,
+    "pr": 0.567,
+    "loki": 0.012
+   },
+   "cold": {
+    "base": 0.54,
+    "pr": 0.532,
+    "loki": 0.079
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 23.64,
+    "pr": 23.64,
+    "loki": 23.64
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.97
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.042,
+    "pr": 0.036,
+    "loki": 0.006
+   },
+   "p95": {
+    "base": 0.044,
+    "pr": 0.037,
+    "loki": 0.014
+   },
+   "cold": {
+    "base": 0.023,
+    "pr": 0.028,
+    "loki": 0.085
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 22.93,
+    "pr": 22.93,
+    "loki": 22.93
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.17
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.063,
+    "pr": 0.088,
+    "loki": 0.019
+   },
+   "p95": {
+    "base": 0.097,
+    "pr": 0.091,
+    "loki": 0.019
+   },
+   "cold": {
+    "base": 0.278,
+    "pr": 0.178,
+    "loki": 0.298
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 75.24,
+    "pr": 75.24,
+    "loki": 75.24
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.72
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "1h",
+   "p50": {
+    "base": 0.083,
+    "pr": 0.091,
+    "loki": 0.013
+   },
+   "p95": {
+    "base": 0.09,
+    "pr": 0.102,
+    "loki": 0.014
+   },
+   "cold": {
+    "base": 0.069,
+    "pr": 0.091,
+    "loki": 0.291
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 55.93,
+    "pr": 55.93,
+    "loki": 55.93
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.91
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-1h.json
new file mode 100644
index 000000000..82b91f0b3
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-bodyonly-d-1h",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "base": 0.12,
+    "pr": 0.084,
+    "loki": 0.062
+   },
+   "p95": {
+    "base": 0.135,
+    "pr": 0.09,
+    "loki": 0.071
+   },
+   "cold": {
+    "base": 0.517,
+    "pr": 0.295,
+    "loki": 0.692
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 153.86,
+    "pr": 153.86,
+    "loki": 153.86
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.43
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-long.json
new file mode 100644
index 000000000..1f0ba17c5
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-d-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-bodyonly-d-long",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "6h",
+   "p50": {
+    "base": 0.688,
+    "pr": 0.692
+   },
+   "p95": {
+    "base": 0.696,
+    "pr": 0.696
+   },
+   "cold": {
+    "base": 2.78,
+    "pr": 1.806
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 220.15,
+    "pr": 174.81
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  },
+  {
+   "shape": "D volume, no filters",
+   "range": "24h",
+   "p50": {
+    "base": 2.797,
+    "pr": 2.838
+   },
+   "p95": {
+    "base": 2.801,
+    "pr": 2.881
+   },
+   "cold": {
+    "base": 6.796,
+    "pr": 4.271
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 203.22,
+    "pr": 203.54
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-1h.json
new file mode 100644
index 000000000..08e69f31c
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-bodyonly-dl6-1h",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 1,
+ "result_differs_preexisting": 1,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "1h",
+   "p50": {
+    "base": 0.277,
+    "pr": 0.278,
+    "loki": 0.017
+   },
+   "p95": {
+    "base": 0.325,
+    "pr": 0.3,
+    "loki": 0.02
+   },
+   "cold": {
+    "base": 0.656,
+    "pr": 0.49,
+    "loki": 0.256
+   },
+   "status": {
+    "base": "200",
+    "pr": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "base": 116.88,
+    "pr": 119.89,
+    "loki": 119.89
+   },
+   "parity_vs_reference": "differs",
+   "baseline_parity_vs_reference": "differs",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-long.json
new file mode 100644
index 000000000..387310eb2
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-dl6-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-bodyonly-dl6-long",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "6h",
+   "p50": {
+    "base": 1.582,
+    "pr": 1.513
+   },
+   "p95": {
+    "base": 1.593,
+    "pr": 1.515
+   },
+   "cold": {
+    "base": 3.297,
+    "pr": 3.477
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 203.84,
+    "pr": 199.31
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.05
+  },
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "24h",
+   "p50": {
+    "base": 6.168,
+    "pr": 6.297
+   },
+   "p95": {
+    "base": 6.185,
+    "pr": 6.374
+   },
+   "cold": {
+    "base": 11.797,
+    "pr": 11.608
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 204.7,
+    "pr": 202.01
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.98
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-long.json
new file mode 100644
index 000000000..cba58d416
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-long.json
@@ -0,0 +1,375 @@
+{
+ "label": "dlfirstview-bodyonly-long",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 12
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "6h",
+   "p50": {
+    "base": 3.327,
+    "pr": 3.303
+   },
+   "p95": {
+    "base": 3.439,
+    "pr": 3.321
+   },
+   "cold": {
+    "base": 3.36,
+    "pr": 3.392
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 83.13,
+    "pr": 54.04
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "24h",
+   "p50": {
+    "base": 10.169,
+    "pr": 10.367
+   },
+   "p95": {
+    "base": 10.207,
+    "pr": 10.44
+   },
+   "cold": {
+    "base": 10.241,
+    "pr": 10.115
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 76.37,
+    "pr": 87.23
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 8.052,
+    "pr": 7.93
+   },
+   "p95": {
+    "base": 8.07,
+    "pr": 7.967
+   },
+   "cold": {
+    "base": 7.999,
+    "pr": 8.026
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 37.42,
+    "pr": 41.77
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 7.939,
+    "pr": 7.979
+   },
+   "p95": {
+    "base": 7.946,
+    "pr": 8.026
+   },
+   "cold": {
+    "base": 8.055,
+    "pr": 7.92
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 36.07,
+    "pr": 203.79
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 3.192,
+    "pr": 3.203
+   },
+   "p95": {
+    "base": 3.201,
+    "pr": 3.238
+   },
+   "cold": {
+    "base": 3.187,
+    "pr": 3.218
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 45.82,
+    "pr": 55.68
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 9.974,
+    "pr": 9.893
+   },
+   "p95": {
+    "base": 10.024,
+    "pr": 9.972
+   },
+   "cold": {
+    "base": 10.004,
+    "pr": 9.928
+   },
+   "status": {
+    "base": "502",
+    "pr": "502"
+   },
+   "vl_cpu_max": {
+    "base": 96.26,
+    "pr": 85.14
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 0.184,
+    "pr": 0.193
+   },
+   "p95": {
+    "base": 0.184,
+    "pr": 0.193
+   },
+   "cold": {
+    "base": 0.208,
+    "pr": 0.189
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 83.68,
+    "pr": 83.68
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.95
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 1.04,
+    "pr": 0.952
+   },
+   "p95": {
+    "base": 1.168,
+    "pr": 1.18
+   },
+   "cold": {
+    "base": 0.885,
+    "pr": 0.812
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 201.27,
+    "pr": 201.27
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.09
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "6h",
+   "p50": {
+    "base": 0.698,
+    "pr": 0.687
+   },
+   "p95": {
+    "base": 0.7,
+    "pr": 0.692
+   },
+   "cold": {
+    "base": 1.969,
+    "pr": 1.192
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 202.2,
+    "pr": 202.2
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.02
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "24h",
+   "p50": {
+    "base": 2.696,
+    "pr": 2.73
+   },
+   "p95": {
+    "base": 2.702,
+    "pr": 2.767
+   },
+   "cold": {
+    "base": 6.5,
+    "pr": 3.988
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 199.09,
+    "pr": 215.73
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "6h",
+   "p50": {
+    "base": 0.68,
+    "pr": 0.65
+   },
+   "p95": {
+    "base": 0.694,
+    "pr": 0.69
+   },
+   "cold": {
+    "base": 0.693,
+    "pr": 0.608
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 198.45,
+    "pr": 146.73
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.05
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "24h",
+   "p50": {
+    "base": 2.758,
+    "pr": 2.691
+   },
+   "p95": {
+    "base": 2.785,
+    "pr": 2.691
+   },
+   "cold": {
+    "base": 2.676,
+    "pr": 2.685
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 201.95,
+    "pr": 199.72
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.02
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-1h.json
new file mode 100644
index 000000000..558a3fd59
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-1h.json
@@ -0,0 +1,231 @@
+{
+ "label": "dlfirstview-bodyonly-swapped-1h",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 6
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.51,
+    "base": 0.497,
+    "loki": 0.009
+   },
+   "p95": {
+    "pr": 0.515,
+    "base": 0.512,
+    "loki": 0.011
+   },
+   "cold": {
+    "pr": 0.513,
+    "base": 0.531,
+    "loki": 0.068
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 59.13,
+    "base": 59.13,
+    "loki": 59.13
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.97
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 2.181,
+    "base": 2.167,
+    "loki": 0.022
+   },
+   "p95": {
+    "pr": 2.191,
+    "base": 2.191,
+    "loki": 0.023
+   },
+   "cold": {
+    "pr": 2.179,
+    "base": 2.191,
+    "loki": 0.307
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 31.48,
+    "base": 32.44,
+    "loki": 31.18
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.515,
+    "base": 0.52,
+    "loki": 0.015
+   },
+   "p95": {
+    "pr": 0.524,
+    "base": 0.526,
+    "loki": 0.018
+   },
+   "cold": {
+    "pr": 0.513,
+    "base": 0.516,
+    "loki": 0.075
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 31.18,
+    "base": 24.4,
+    "loki": 24.4
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.045,
+    "base": 0.037,
+    "loki": 0.007
+   },
+   "p95": {
+    "pr": 0.057,
+    "base": 0.043,
+    "loki": 0.01
+   },
+   "cold": {
+    "pr": 0.023,
+    "base": 0.038,
+    "loki": 0.099
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 27.49,
+    "base": 31.82,
+    "loki": 31.82
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.82
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.064,
+    "base": 0.098,
+    "loki": 0.022
+   },
+   "p95": {
+    "pr": 0.066,
+    "base": 0.116,
+    "loki": 0.033
+   },
+   "cold": {
+    "pr": 0.131,
+    "base": 0.385,
+    "loki": 0.341
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 57.65,
+    "base": 59.22,
+    "loki": 59.22
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.53
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.057,
+    "base": 0.093,
+    "loki": 0.022
+   },
+   "p95": {
+    "pr": 0.069,
+    "base": 0.104,
+    "loki": 0.023
+   },
+   "cold": {
+    "pr": 0.038,
+    "base": 0.09,
+    "loki": 0.314
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 59.22,
+    "base": 59.22,
+    "loki": 59.22
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.63
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-1h.json
new file mode 100644
index 000000000..14106066a
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-bodyonly-swapped-d-1h",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "pr": 0.133,
+    "base": 0.135,
+    "loki": 0.057
+   },
+   "p95": {
+    "pr": 0.138,
+    "base": 0.185,
+    "loki": 0.059
+   },
+   "cold": {
+    "pr": 0.33,
+    "base": 0.498,
+    "loki": 0.78
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 59.97,
+    "base": 152.53,
+    "loki": 152.53
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.02
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-long.json
new file mode 100644
index 000000000..c88a6783f
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-d-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-bodyonly-swapped-d-long",
+ "date": "2026-10-17",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "6h",
+   "p50": {
+    "pr": 0.696,
+    "base": 0.744
+   },
+   "p95": {
+    "pr": 0.702,
+    "base": 0.773
+   },
+   "cold": {
+    "pr": 2.104,
+    "base": 2.856
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 205.89,
+    "base": 205.89
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.07
+  },
+  {
+   "shape": "D volume, no filters",
+   "range": "24h",
+   "p50": {
+    "pr": 3.037,
+    "base": 3.046
+   },
+   "p95": {
+    "pr": 3.075,
+    "base": 3.089
+   },
+   "cold": {
+    "pr": 4.58,
+    "base": 7.184
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 208.03,
+    "base": 200.95
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-1h.json
new file mode 100644
index 000000000..cf74f3703
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-bodyonly-swapped-dl6-1h",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 1,
+ "result_differs_preexisting": 1,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.289,
+    "base": 0.287,
+    "loki": 0.025
+   },
+   "p95": {
+    "pr": 0.352,
+    "base": 0.3,
+    "loki": 0.03
+   },
+   "cold": {
+    "pr": 0.634,
+    "base": 0.583,
+    "loki": 0.293
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 153.79,
+    "base": 153.79,
+    "loki": 153.79
+   },
+   "parity_vs_reference": "differs",
+   "baseline_parity_vs_reference": "differs",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-long.json
new file mode 100644
index 000000000..844b0e959
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-dl6-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-bodyonly-swapped-dl6-long",
+ "date": "2026-10-17",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "6h",
+   "p50": {
+    "pr": 1.724,
+    "base": 1.665
+   },
+   "p95": {
+    "pr": 1.779,
+    "base": 1.705
+   },
+   "cold": {
+    "pr": 3.789,
+    "base": 3.692
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 200.31,
+    "base": 200.24
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.97
+  },
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "24h",
+   "p50": {
+    "pr": 6.572,
+    "base": 6.505
+   },
+   "p95": {
+    "pr": 6.675,
+    "base": 6.674
+   },
+   "cold": {
+    "pr": 12.705,
+    "base": 12.396
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 204.69,
+    "base": 208.33
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-long.json
new file mode 100644
index 000000000..4c0a1cede
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-swapped-long.json
@@ -0,0 +1,375 @@
+{
+ "label": "dlfirstview-bodyonly-swapped-long",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 12
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "6h",
+   "p50": {
+    "pr": 3.058,
+    "base": 3.08
+   },
+   "p95": {
+    "pr": 3.071,
+    "base": 3.124
+   },
+   "cold": {
+    "pr": 3.182,
+    "base": 3.061
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 76.49,
+    "base": 48.63
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "24h",
+   "p50": {
+    "pr": 9.597,
+    "base": 9.62
+   },
+   "p95": {
+    "pr": 9.65,
+    "base": 9.633
+   },
+   "cold": {
+    "pr": 9.795,
+    "base": 9.515
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 103.52,
+    "base": 90.62
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 7.635,
+    "base": 7.614
+   },
+   "p95": {
+    "pr": 7.647,
+    "base": 7.658
+   },
+   "cold": {
+    "pr": 7.609,
+    "base": 7.575
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 34.43,
+    "base": 30.96
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 7.66,
+    "base": 7.775
+   },
+   "p95": {
+    "pr": 7.701,
+    "base": 7.84
+   },
+   "cold": {
+    "pr": 7.616,
+    "base": 7.683
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 32.24,
+    "base": 203.49
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 3.186,
+    "base": 3.149
+   },
+   "p95": {
+    "pr": 3.245,
+    "base": 3.16
+   },
+   "cold": {
+    "pr": 3.095,
+    "base": 3.131
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 203.49,
+    "base": 45.81
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 10.045,
+    "base": 9.872
+   },
+   "p95": {
+    "pr": 10.062,
+    "base": 9.932
+   },
+   "cold": {
+    "pr": 9.953,
+    "base": 9.878
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 202.76,
+    "base": 90.3
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 0.202,
+    "base": 0.182
+   },
+   "p95": {
+    "pr": 0.206,
+    "base": 0.195
+   },
+   "cold": {
+    "pr": 0.158,
+    "base": 0.286
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 114.51,
+    "base": 114.51
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.9
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 0.795,
+    "base": 0.8
+   },
+   "p95": {
+    "pr": 0.802,
+    "base": 0.807
+   },
+   "cold": {
+    "pr": 0.895,
+    "base": 0.986
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 160.77,
+    "base": 160.77
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 0.732,
+    "base": 0.692
+   },
+   "p95": {
+    "pr": 0.769,
+    "base": 0.697
+   },
+   "cold": {
+    "pr": 1.294,
+    "base": 2.001
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 198.95,
+    "base": 198.95
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.95
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 2.833,
+    "base": 2.907
+   },
+   "p95": {
+    "pr": 2.883,
+    "base": 3.001
+   },
+   "cold": {
+    "pr": 4.209,
+    "base": 6.886
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 199.61,
+    "base": 203.0
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.03
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "6h",
+   "p50": {
+    "pr": 0.692,
+    "base": 0.736
+   },
+   "p95": {
+    "pr": 0.767,
+    "base": 0.786
+   },
+   "cold": {
+    "pr": 0.7,
+    "base": 0.684
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 198.68,
+    "base": 158.36
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.06
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "24h",
+   "p50": {
+    "pr": 2.896,
+    "base": 2.888
+   },
+   "p95": {
+    "pr": 2.987,
+    "base": 2.894
+   },
+   "cold": {
+    "pr": 2.778,
+    "base": 2.998
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 199.43,
+    "base": 202.07
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-d-1h.json
new file mode 100644
index 000000000..fd6c56988
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-d-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-bodyonly-vlonly-d-1h",
+ "date": "2026-10-17",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "base": 0.097,
+    "pr": 0.098
+   },
+   "p95": {
+    "base": 0.187,
+    "pr": 0.118
+   },
+   "cold": {
+    "base": 0.439,
+    "pr": 0.367
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 160.91,
+    "pr": 160.91
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-dlv5-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-dlv5-1h.json
new file mode 100644
index 000000000..97be13fc9
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-dlv5-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-bodyonly-vlonly-dlv5-1h",
+ "date": "2026-10-17",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.097,
+    "pr": 0.092
+   },
+   "p95": {
+    "base": 0.136,
+    "pr": 0.105
+   },
+   "cold": {
+    "base": 0.195,
+    "pr": 0.093
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 97.04,
+    "pr": 97.04
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.05
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-d-1h.json
new file mode 100644
index 000000000..62d8c1247
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-d-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-bodyonly-vlonly-swapped-d-1h",
+ "date": "2026-10-17",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "pr": 0.095,
+    "base": 0.102
+   },
+   "p95": {
+    "pr": 0.183,
+    "base": 0.195
+   },
+   "cold": {
+    "pr": 0.317,
+    "base": 0.585
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 159.7,
+    "base": 159.7
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.07
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-dlv5-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-dlv5-1h.json
new file mode 100644
index 000000000..4483aa71d
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-bodyonly-vlonly-swapped-dlv5-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-bodyonly-vlonly-swapped-dlv5-1h",
+ "date": "2026-10-17",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.092,
+    "base": 0.098
+   },
+   "p95": {
+    "pr": 0.107,
+    "base": 0.175
+   },
+   "cold": {
+    "pr": 0.085,
+    "base": 0.278
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 97.97,
+    "base": 97.97
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.07
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-1h.json
new file mode 100644
index 000000000..933d74fc1
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-1h.json
@@ -0,0 +1,231 @@
+{
+ "label": "dlfirstview-swapped-1h",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 6
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.51,
+    "base": 0.526,
+    "loki": 0.015
+   },
+   "p95": {
+    "pr": 0.533,
+    "base": 0.53,
+    "loki": 0.02
+   },
+   "cold": {
+    "pr": 0.522,
+    "base": 0.511,
+    "loki": 0.118
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 62.13,
+    "base": 62.13,
+    "loki": 62.13
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.03
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 2.3,
+    "base": 2.308,
+    "loki": 0.019
+   },
+   "p95": {
+    "pr": 2.359,
+    "base": 2.423,
+    "loki": 0.022
+   },
+   "cold": {
+    "pr": 2.285,
+    "base": 2.352,
+    "loki": 0.218
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 33.78,
+    "base": 40.62,
+    "loki": 33.92
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.542,
+    "base": 0.548,
+    "loki": 0.009
+   },
+   "p95": {
+    "pr": 0.543,
+    "base": 0.575,
+    "loki": 0.012
+   },
+   "cold": {
+    "pr": 0.556,
+    "base": 0.539,
+    "loki": 0.059
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 33.92,
+    "base": 33.75,
+    "loki": 33.75
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.042,
+    "base": 0.037,
+    "loki": 0.007
+   },
+   "p95": {
+    "pr": 0.047,
+    "base": 0.045,
+    "loki": 0.01
+   },
+   "cold": {
+    "pr": 0.023,
+    "base": 0.021,
+    "loki": 0.059
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 30.73,
+    "base": 30.73,
+    "loki": 23.73
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.88
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.008,
+    "base": 0.007,
+    "loki": 0.021
+   },
+   "p95": {
+    "pr": 0.011,
+    "base": 0.009,
+    "loki": 0.028
+   },
+   "cold": {
+    "pr": 0.006,
+    "base": 0.006,
+    "loki": 0.226
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 20.66,
+    "base": 20.66,
+    "loki": 20.66
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.88
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.009,
+    "base": 0.007,
+    "loki": 0.014
+   },
+   "p95": {
+    "pr": 0.013,
+    "base": 0.01,
+    "loki": 0.016
+   },
+   "cold": {
+    "pr": 0.007,
+    "base": 0.006,
+    "loki": 0.216
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 7.7,
+    "base": 7.7,
+    "loki": 7.7
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.78
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-control-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-control-1h.json
new file mode 100644
index 000000000..d68adb714
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-control-1h.json
@@ -0,0 +1,707 @@
+{
+ "label": "dlfirstview-swapped-control-1h",
+ "date": "2026-10-16",
+ "set": "control",
+ "description": "Shapes a change must not slow down or alter. Run on every performance-relevant PR.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 20
+ },
+ "result_differs_from_reference": 1,
+ "result_differs_preexisting": 1,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "logs plain",
+   "range": "1h",
+   "p50": {
+    "pr": 0.025,
+    "base": 0.024,
+    "loki": 0.024
+   },
+   "p95": {
+    "pr": 0.026,
+    "base": 0.026,
+    "loki": 0.027
+   },
+   "cold": {
+    "pr": 0.036,
+    "base": 0.024,
+    "loki": 0.019
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 16.91,
+    "base": 16.91,
+    "loki": 16.91
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.96
+  },
+  {
+   "shape": "logs | json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.041,
+    "base": 0.034,
+    "loki": 0.031
+   },
+   "p95": {
+    "pr": 0.051,
+    "base": 0.038,
+    "loki": 0.036
+   },
+   "cold": {
+    "pr": 0.033,
+    "base": 0.037,
+    "loki": 0.027
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 24.51,
+    "base": 25.1,
+    "loki": 25.1
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.83
+  },
+  {
+   "shape": "logs | logfmt",
+   "range": "1h",
+   "p50": {
+    "pr": 0.046,
+    "base": 0.082,
+    "loki": 0.026
+   },
+   "p95": {
+    "pr": 0.062,
+    "base": 0.1,
+    "loki": 0.031
+   },
+   "cold": {
+    "pr": 0.076,
+    "base": 0.098,
+    "loki": 0.025
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 43.46,
+    "base": 43.46,
+    "loki": 43.46
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.78
+  },
+  {
+   "shape": "json volume no filters",
+   "range": "1h",
+   "p50": {
+    "pr": 0.065,
+    "base": 0.089,
+    "loki": 0.022
+   },
+   "p95": {
+    "pr": 0.075,
+    "base": 0.096,
+    "loki": 0.024
+   },
+   "cold": {
+    "pr": 0.043,
+    "base": 0.102,
+    "loki": 0.219
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 50.3,
+    "base": 50.3,
+    "loki": 50.3
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.37
+  },
+  {
+   "shape": "logfmt volume",
+   "range": "1h",
+   "p50": {
+    "pr": 0.097,
+    "base": 0.123,
+    "loki": 0.027
+   },
+   "p95": {
+    "pr": 0.173,
+    "base": 0.128,
+    "loki": 0.028
+   },
+   "cold": {
+    "pr": 0.079,
+    "base": 0.094,
+    "loki": 0.336
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 59.79,
+    "base": 59.79,
+    "loki": 59.79
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.27
+  },
+  {
+   "shape": "plain volume",
+   "range": "1h",
+   "p50": {
+    "pr": 0.007,
+    "base": 0.011,
+    "loki": 0.021
+   },
+   "p95": {
+    "pr": 0.01,
+    "base": 0.011,
+    "loki": 0.025
+   },
+   "cold": {
+    "pr": 0.006,
+    "base": 0.012,
+    "loki": 0.204
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 6.14,
+    "base": 6.94,
+    "loki": 6.94
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.57
+  },
+  {
+   "shape": "stream-label count by app",
+   "range": "1h",
+   "p50": {
+    "pr": 0.011,
+    "base": 0.01,
+    "loki": 0.018
+   },
+   "p95": {
+    "pr": 0.012,
+    "base": 0.012,
+    "loki": 0.021
+   },
+   "cold": {
+    "pr": 0.009,
+    "base": 0.016,
+    "loki": 0.193
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 6.94,
+    "base": 6.94,
+    "loki": 6.94
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.91
+  },
+  {
+   "shape": "ungrouped rate",
+   "range": "1h",
+   "p50": {
+    "pr": 0.005,
+    "base": 0.008,
+    "loki": 0.037
+   },
+   "p95": {
+    "pr": 0.006,
+    "base": 0.012,
+    "loki": 0.04
+   },
+   "cold": {
+    "pr": 0.005,
+    "base": 0.006,
+    "loki": 0.19
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 5.2,
+    "base": 6.07,
+    "loki": 6.07
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.6
+  },
+  {
+   "shape": "bytes_over_time by app",
+   "range": "1h",
+   "p50": {
+    "pr": 0.024,
+    "base": 0.023,
+    "loki": 0.041
+   },
+   "p95": {
+    "pr": 0.026,
+    "base": 0.024,
+    "loki": 0.048
+   },
+   "cold": {
+    "pr": 0.022,
+    "base": 0.025,
+    "loki": 0.234
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 20.88,
+    "base": 20.88,
+    "loki": 20.88
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.96
+  },
+  {
+   "shape": "topk rate by app",
+   "range": "1h",
+   "p50": {
+    "pr": 0.019,
+    "base": 0.019,
+    "loki": 0.036
+   },
+   "p95": {
+    "pr": 0.02,
+    "base": 0.022,
+    "loki": 0.043
+   },
+   "cold": {
+    "pr": 0.018,
+    "base": 0.02,
+    "loki": 0.21
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 15.36,
+    "base": 15.36,
+    "loki": 15.36
+   },
+   "parity_vs_reference": "differs",
+   "baseline_parity_vs_reference": "differs",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "detected_level volume",
+   "range": "1h",
+   "p50": {
+    "pr": 0.019,
+    "base": 0.019,
+    "loki": 0.018
+   },
+   "p95": {
+    "pr": 0.024,
+    "base": 0.021,
+    "loki": 0.02
+   },
+   "cold": {
+    "pr": 0.026,
+    "base": 0.029,
+    "loki": 0.18
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 21.91,
+    "base": 21.91,
+    "loki": 21.91
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "by service_name",
+   "range": "1h",
+   "p50": {
+    "pr": 0.014,
+    "base": 0.014,
+    "loki": 0.017
+   },
+   "p95": {
+    "pr": 0.018,
+    "base": 0.02,
+    "loki": 0.02
+   },
+   "cold": {
+    "pr": 0.014,
+    "base": 0.014,
+    "loki": 0.182
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 16.89,
+    "base": 16.89,
+    "loki": 16.89
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "drilldown level volume",
+   "range": "1h",
+   "p50": {
+    "pr": 0.01,
+    "base": 0.007,
+    "loki": 0.013
+   },
+   "p95": {
+    "pr": 0.012,
+    "base": 0.01,
+    "loki": 0.014
+   },
+   "cold": {
+    "pr": 0.006,
+    "base": 0.009,
+    "loki": 0.174
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 9.41,
+    "base": 9.41,
+    "loki": 9.41
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.7
+  },
+  {
+   "shape": "drilldown service landing",
+   "range": "1h",
+   "p50": {
+    "pr": 0.013,
+    "base": 0.013,
+    "loki": 0.012
+   },
+   "p95": {
+    "pr": 0.014,
+    "base": 0.017,
+    "loki": 0.012
+   },
+   "cold": {
+    "pr": 0.011,
+    "base": 0.011,
+    "loki": 0.196
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 15.05,
+    "base": 15.05,
+    "loki": 15.05
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "drilldown detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.019,
+    "base": 0.019,
+    "loki": 0.01
+   },
+   "p95": {
+    "pr": 0.024,
+    "base": 0.021,
+    "loki": 0.019
+   },
+   "cold": {
+    "pr": 0.019,
+    "base": 0.02,
+    "loki": 0.184
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 20.6,
+    "base": 20.6,
+    "loki": 20.6
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "json rate by level (no filter, no drop)",
+   "range": "1h",
+   "p50": {
+    "pr": 0.002,
+    "base": 0.003,
+    "loki": 0.051
+   },
+   "p95": {
+    "pr": 0.002,
+    "base": 0.005,
+    "loki": 0.056
+   },
+   "cold": {
+    "pr": 0.005,
+    "base": 0.002,
+    "loki": 0.054
+   },
+   "status": {
+    "pr": "400",
+    "base": "400",
+    "loki": "400"
+   },
+   "vl_cpu_max": {
+    "pr": 11.31,
+    "base": 11.31,
+    "loki": 11.31
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "logfmt count by level, filter, drop",
+   "range": "1h",
+   "p50": {
+    "pr": 0.171,
+    "base": 0.198,
+    "loki": 0.025
+   },
+   "p95": {
+    "pr": 0.198,
+    "base": 0.265,
+    "loki": 0.025
+   },
+   "cold": {
+    "pr": 0.152,
+    "base": 0.287,
+    "loki": 0.307
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 100.2,
+    "base": 100.2,
+    "loki": 100.2
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.16
+  },
+  {
+   "shape": "instant ungrouped rate",
+   "range": "instant",
+   "p50": {
+    "pr": 0.005,
+    "base": 0.005,
+    "loki": 0.032
+   },
+   "p95": {
+    "pr": 0.006,
+    "base": 0.008,
+    "loki": 0.04
+   },
+   "cold": {
+    "pr": 0.013,
+    "base": 0.006,
+    "loki": 0.032
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 15.86,
+    "base": 15.86,
+    "loki": 15.86
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "instant json volume",
+   "range": "instant",
+   "p50": {
+    "pr": 0.19,
+    "base": 0.195,
+    "loki": 0.041
+   },
+   "p95": {
+    "pr": 0.202,
+    "base": 0.198,
+    "loki": 0.043
+   },
+   "cold": {
+    "pr": 0.22,
+    "base": 0.211,
+    "loki": 0.041
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 16.93,
+    "base": 16.93,
+    "loki": 16.93
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.03
+  },
+  {
+   "shape": "instant json filtered",
+   "range": "instant",
+   "p50": {
+    "pr": 0.155,
+    "base": 0.155,
+    "loki": 0.03
+   },
+   "p95": {
+    "pr": 0.158,
+    "base": 0.175,
+    "loki": 0.034
+   },
+   "cold": {
+    "pr": 0.161,
+    "base": 0.165,
+    "loki": 0.034
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 17.64,
+    "base": 17.64,
+    "loki": 17.64
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-1h.json
new file mode 100644
index 000000000..bbc96b8dd
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-swapped-d-1h",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "pr": 0.128,
+    "base": 0.086,
+    "loki": 0.067
+   },
+   "p95": {
+    "pr": 0.132,
+    "base": 0.091,
+    "loki": 0.076
+   },
+   "cold": {
+    "pr": 0.072,
+    "base": 0.095,
+    "loki": 0.587
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 67.94,
+    "base": 67.94,
+    "loki": 67.94
+   },
+   "parity_vs_reference": "same",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.67
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-long.json
new file mode 100644
index 000000000..3932c2580
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-d-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-swapped-d-long",
+ "date": "2026-10-16",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "6h",
+   "p50": {
+    "pr": 0.591,
+    "base": 0.585
+   },
+   "p95": {
+    "pr": 0.595,
+    "base": 0.588
+   },
+   "cold": {
+    "pr": 0.895,
+    "base": 0.703
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 181.57,
+    "base": 181.57
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  },
+  {
+   "shape": "D volume, no filters",
+   "range": "24h",
+   "p50": {
+    "pr": 2.393,
+    "base": 2.385
+   },
+   "p95": {
+    "pr": 2.397,
+    "base": 2.387
+   },
+   "cold": {
+    "pr": 2.583,
+    "base": 2.497
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 201.58,
+    "base": 202.95
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-1h.json
new file mode 100644
index 000000000..7ee198b0e
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-1h.json
@@ -0,0 +1,61 @@
+{
+ "label": "dlfirstview-swapped-dl6-1h",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 5,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "1h",
+   "p50": {
+    "pr": 0.273,
+    "base": 0.294,
+    "loki": 0.017
+   },
+   "p95": {
+    "pr": 0.284,
+    "base": 0.302,
+    "loki": 0.019
+   },
+   "cold": {
+    "pr": 0.583,
+    "base": 0.601,
+    "loki": 0.217
+   },
+   "status": {
+    "pr": "200",
+    "base": "200",
+    "loki": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 140.88,
+    "base": 140.88,
+    "loki": 140.88
+   },
+   "parity_vs_reference": "same series, sum \u00b10.27%",
+   "baseline_parity_vs_reference": "same",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.08
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-long.json
new file mode 100644
index 000000000..33f0fd2ba
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-dl6-long.json
@@ -0,0 +1,85 @@
+{
+ "label": "dlfirstview-swapped-dl6-long",
+ "date": "2026-10-16",
+ "set": "metric-latency-gap",
+ "description": "Shapes the metric latency work targets: the parse-risk probes of the | json stats pushdown (breakdowns and volumes by underscore labels), label filters before the parser (Logs Drilldown pages with a level filter selected) and Explore volumes with a level filter. Run with the json-filter-pushdown set.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 2
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "6h",
+   "p50": {
+    "pr": 1.596,
+    "base": 1.601
+   },
+   "p95": {
+    "pr": 1.597,
+    "base": 1.602
+   },
+   "cold": {
+    "pr": 3.499,
+    "base": 3.492
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 199.45,
+    "base": 199.0
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DL6 explore volume, level filter before json",
+   "range": "24h",
+   "p50": {
+    "pr": 7.094,
+    "base": 6.907
+   },
+   "p95": {
+    "pr": 7.188,
+    "base": 6.915
+   },
+   "cold": {
+    "pr": 12.297,
+    "base": 12.273
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 203.55,
+    "base": 203.55
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.97
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-long.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-long.json
new file mode 100644
index 000000000..cdd8ea212
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-swapped-long.json
@@ -0,0 +1,375 @@
+{
+ "label": "dlfirstview-swapped-long",
+ "date": "2026-10-16",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 3,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 12
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "6h",
+   "p50": {
+    "pr": 3.256,
+    "base": 3.226
+   },
+   "p95": {
+    "pr": 3.27,
+    "base": 3.241
+   },
+   "cold": {
+    "pr": 3.449,
+    "base": 3.267
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 106.62,
+    "base": 41.18
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.99
+  },
+  {
+   "shape": "DLV1 drilldown logs volume, json",
+   "range": "24h",
+   "p50": {
+    "pr": 10.155,
+    "base": 10.245
+   },
+   "p95": {
+    "pr": 10.205,
+    "base": 10.279
+   },
+   "cold": {
+    "pr": 10.31,
+    "base": 10.286
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 74.6,
+    "base": 92.38
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 8.128,
+    "base": 8.223
+   },
+   "p95": {
+    "pr": 8.139,
+    "base": 8.243
+   },
+   "cold": {
+    "pr": 8.126,
+    "base": 8.131
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 35.0,
+    "base": 39.86
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV2 json error filter, detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 8.121,
+    "base": 7.986
+   },
+   "p95": {
+    "pr": 8.143,
+    "base": 8.008
+   },
+   "cold": {
+    "pr": 8.054,
+    "base": 8.076
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 35.48,
+    "base": 46.66
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 3.247,
+    "base": 3.236
+   },
+   "p95": {
+    "pr": 3.251,
+    "base": 3.273
+   },
+   "cold": {
+    "pr": 3.37,
+    "base": 3.261
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 42.42,
+    "base": 44.33
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV3 plain json, detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 10.032,
+    "base": 10.062
+   },
+   "p95": {
+    "pr": 10.049,
+    "base": 10.117
+   },
+   "cold": {
+    "pr": 9.863,
+    "base": 10.17
+   },
+   "status": {
+    "pr": "502",
+    "base": "502"
+   },
+   "vl_cpu_max": {
+    "pr": 202.69,
+    "base": 202.72
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "n/a",
+   "verdict": "same",
+   "speedup": null
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 0.192,
+    "base": 0.192
+   },
+   "p95": {
+    "pr": 0.195,
+    "base": 0.197
+   },
+   "cold": {
+    "pr": 0.248,
+    "base": 0.16
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 87.4,
+    "base": 87.4
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.0
+  },
+  {
+   "shape": "DLV4 explore json volume, level and detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 0.742,
+    "base": 0.786
+   },
+   "p95": {
+    "pr": 0.786,
+    "base": 0.791
+   },
+   "cold": {
+    "pr": 0.818,
+    "base": 0.786
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 179.01,
+    "base": 179.01
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.06
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "6h",
+   "p50": {
+    "pr": 0.031,
+    "base": 0.03
+   },
+   "p95": {
+    "pr": 0.031,
+    "base": 0.031
+   },
+   "cold": {
+    "pr": 0.029,
+    "base": 0.033
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 147.1,
+    "base": 67.6
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.97
+  },
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "24h",
+   "p50": {
+    "pr": 0.192,
+    "base": 0.189
+   },
+   "p95": {
+    "pr": 0.196,
+    "base": 0.191
+   },
+   "cold": {
+    "pr": 0.172,
+    "base": 0.183
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 65.08,
+    "base": 97.66
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 0.98
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "6h",
+   "p50": {
+    "pr": 0.03,
+    "base": 0.031
+   },
+   "p95": {
+    "pr": 0.031,
+    "base": 0.033
+   },
+   "cold": {
+    "pr": 0.033,
+    "base": 0.034
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 97.66,
+    "base": 97.66
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.03
+  },
+  {
+   "shape": "DLV6 drilldown detected_level breakdown, json",
+   "range": "24h",
+   "p50": {
+    "pr": 0.189,
+    "base": 0.19
+   },
+   "p95": {
+    "pr": 0.192,
+    "base": 0.194
+   },
+   "cold": {
+    "pr": 0.159,
+    "base": 0.189
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 101.25,
+    "base": 101.25
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "same",
+   "verdict": "same",
+   "speedup": 1.01
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-d-1h.json
new file mode 100644
index 000000000..d27cc4d91
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-d-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-vs-before760-bodyonly-vlonly-d-1h",
+ "date": "2026-10-17",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "base": 0.088,
+    "pr": 0.104
+   },
+   "p95": {
+    "base": 0.112,
+    "pr": 0.141
+   },
+   "cold": {
+    "base": 0.052,
+    "pr": 0.29
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 126.78,
+    "pr": 126.78
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "differs",
+   "verdict": "same",
+   "speedup": 0.85
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-dlv5-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-dlv5-1h.json
new file mode 100644
index 000000000..fbcfaf90b
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-dlv5-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-vs-before760-bodyonly-vlonly-dlv5-1h",
+ "date": "2026-10-17",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "base": 0.089,
+    "pr": 0.096
+   },
+   "p95": {
+    "base": 0.108,
+    "pr": 0.11
+   },
+   "cold": {
+    "base": 0.064,
+    "pr": 0.1
+   },
+   "status": {
+    "base": "200",
+    "pr": "200"
+   },
+   "vl_cpu_max": {
+    "base": 95.24,
+    "pr": 95.24
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "differs",
+   "verdict": "same",
+   "speedup": 0.93
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-d-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-d-1h.json
new file mode 100644
index 000000000..a161f8ed0
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-d-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-vs-before760-bodyonly-vlonly-swapped-d-1h",
+ "date": "2026-10-17",
+ "set": "json-filter-pushdown",
+ "description": "| json / | logfmt range metrics with label filters on parsed fields (PR #611). Grafana Explore log volume and Logs Drilldown field breakdowns over a JSON stream.",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "D volume, no filters",
+   "range": "1h",
+   "p50": {
+    "pr": 0.1,
+    "base": 0.083
+   },
+   "p95": {
+    "pr": 0.105,
+    "base": 0.092
+   },
+   "cold": {
+    "pr": 0.327,
+    "base": 0.085
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 99.82,
+    "base": 99.82
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "differs",
+   "verdict": "same",
+   "speedup": 0.83
+  }
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-dlv5-1h.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-dlv5-1h.json
new file mode 100644
index 000000000..c002e13a7
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-vs-before760-bodyonly-vlonly-swapped-dlv5-1h.json
@@ -0,0 +1,56 @@
+{
+ "label": "dlfirstview-vs-before760-bodyonly-vlonly-swapped-dlv5-1h",
+ "date": "2026-10-17",
+ "set": "json-detected-level",
+ "description": "sum by (detected_level) over a JSON pipeline (row evaluator, and the stats pushdown with the level computed in VictoriaLogs and its guard probes).",
+ "baseline": "base",
+ "candidate": "pr",
+ "reference": "loki",
+ "runs": 15,
+ "valid": true,
+ "restart_before": "0",
+ "restart_after": "0",
+ "noise": 0.3,
+ "timing": "warm",
+ "verdicts": {
+  "same": 1
+ },
+ "result_differs_from_reference": 0,
+ "result_differs_preexisting": 0,
+ "stale_answers": {
+  "base": 0,
+  "pr": 0,
+  "loki": 0
+ },
+ "rows": [
+  {
+   "shape": "DLV5 json error dropped, detected_level",
+   "range": "1h",
+   "p50": {
+    "pr": 0.097,
+    "base": 0.087
+   },
+   "p95": {
+    "pr": 0.11,
+    "base": 0.1
+   },
+   "cold": {
+    "pr": 0.11,
+    "base": 0.089
+   },
+   "status": {
+    "pr": "200",
+    "base": "200"
+   },
+   "vl_cpu_max": {
+    "pr": 85.28,
+    "base": 85.28
+   },
+   "parity_vs_reference": "n/a",
+   "baseline_parity_vs_reference": "n/a",
+   "parity_vs_baseline": "differs",
+   "verdict": "same",
+   "speedup": 0.9
+  }
+ ]
+}
diff --git a/conformance/registry/generated/perf-evidence.json b/conformance/registry/generated/perf-evidence.json
index a845fc262..7d1ae11d9 100644
--- a/conformance/registry/generated/perf-evidence.json
+++ b/conformance/registry/generated/perf-evidence.json
@@ -843,12 +843,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.025,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.013,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.333,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.337,
+      "loki_warm_p50": 0.02,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -857,7 +857,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.016
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -919,12 +919,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.015,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.019,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.342,
-      "loki_warm_p50": 0.017,
+      "loki_cold": 0.343,
+      "loki_warm_p50": 0.016,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -933,7 +933,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.014
+      "warm_p50": 0.017
     },
     {
       "baseline": "base",
@@ -1073,12 +1073,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.096,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-1h",
+      "cold": 0.1,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.909,
-      "loki_warm_p50": 0.029,
+      "loki_cold": 0.891,
+      "loki_warm_p50": 0.067,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-filter-pushdown",
@@ -1087,14 +1087,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.098
+      "warm_p50": 0.088
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 2.41,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-long",
+      "cold": 2.677,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -1106,7 +1106,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 2.402
+      "warm_p50": 2.508
     },
     {
       "baseline": "main",
@@ -1130,9 +1130,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.611,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-long",
+      "cold": 0.679,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -1144,7 +1144,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.608
+      "warm_p50": 0.697
     },
     {
       "baseline": "main",
@@ -1225,12 +1225,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.093,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.1,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.451,
-      "loki_warm_p50": 0.021,
+      "loki_cold": 0.421,
+      "loki_warm_p50": 0.026,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -1239,7 +1239,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.105
+      "warm_p50": 0.093
     },
     {
       "baseline": "base",
@@ -1301,12 +1301,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.208,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.215,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.049,
-      "loki_warm_p50": 0.049,
+      "loki_cold": 0.046,
+      "loki_warm_p50": 0.05,
       "parity_vs_loki": "same",
       "range": "instant",
       "set": "control",
@@ -1315,33 +1315,33 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.189
+      "warm_p50": 0.215
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.617,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-1h",
+      "cold": 0.595,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.331,
-      "loki_warm_p50": 0.017,
-      "parity_vs_loki": "same series, sum \u00b10.27%",
+      "loki_cold": 0.658,
+      "loki_warm_p50": 0.022,
+      "parity_vs_loki": "same series, sum \u00b10.25%",
       "range": "1h",
       "set": "metric-latency-gap",
       "shape": "DL6 explore volume, level filter before json",
-      "slower_than_loki_cold": true,
+      "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.279
+      "warm_p50": 0.3
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 12.493,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 12.604,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -1353,7 +1353,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 6.904
+      "warm_p50": 6.536
     },
     {
       "baseline": "main",
@@ -1377,9 +1377,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.805,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 3.496,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -1391,7 +1391,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 1.598
+      "warm_p50": 1.693
     },
     {
       "baseline": "base",
@@ -5769,12 +5769,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.004,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.007,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.034,
-      "loki_warm_p50": 0.037,
+      "loki_cold": 0.044,
+      "loki_warm_p50": 0.031,
       "parity_vs_loki": "same",
       "range": "instant",
       "set": "control",
@@ -5783,17 +5783,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.006
+      "warm_p50": 0.007
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.208,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.215,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.049,
-      "loki_warm_p50": 0.049,
+      "loki_cold": 0.046,
+      "loki_warm_p50": 0.05,
       "parity_vs_loki": "same",
       "range": "instant",
       "set": "control",
@@ -5802,17 +5802,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.189
+      "warm_p50": 0.215
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.163,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.179,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.042,
-      "loki_warm_p50": 0.054,
+      "loki_cold": 0.03,
+      "loki_warm_p50": 0.032,
       "parity_vs_loki": "same",
       "range": "instant",
       "set": "control",
@@ -5821,7 +5821,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.161
+      "warm_p50": 0.175
     },
     {
       "baseline": "main",
@@ -6208,12 +6208,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.096,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-1h",
+      "cold": 0.1,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.909,
-      "loki_warm_p50": 0.029,
+      "loki_cold": 0.891,
+      "loki_warm_p50": 0.067,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-filter-pushdown",
@@ -6222,14 +6222,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.098
+      "warm_p50": 0.088
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 2.41,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-long",
+      "cold": 2.677,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -6241,7 +6241,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 2.402
+      "warm_p50": 2.508
     },
     {
       "baseline": "main",
@@ -6265,9 +6265,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.611,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-long",
+      "cold": 0.679,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -6279,7 +6279,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.608
+      "warm_p50": 0.697
     },
     {
       "baseline": "main",
@@ -6664,12 +6664,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.018,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.039,
-      "loki_warm_p50": 0.028,
+      "loki_cold": 0.026,
+      "loki_warm_p50": 0.025,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -6678,7 +6678,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.019
+      "warm_p50": 0.021
     },
     {
       "baseline": "base",
@@ -6740,12 +6740,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.022,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.042,
-      "loki_warm_p50": 0.041,
+      "loki_cold": 0.054,
+      "loki_warm_p50": 0.043,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -6754,7 +6754,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.03
+      "warm_p50": 0.036
     },
     {
       "baseline": "base",
@@ -6816,12 +6816,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.052,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.036,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.033,
-      "loki_warm_p50": 0.044,
+      "loki_cold": 0.036,
+      "loki_warm_p50": 0.032,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -6830,7 +6830,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.042
+      "warm_p50": 0.099
     },
     {
       "baseline": "base",
@@ -6892,12 +6892,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.093,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.1,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.451,
-      "loki_warm_p50": 0.021,
+      "loki_cold": 0.421,
+      "loki_warm_p50": 0.026,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -6906,7 +6906,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.105
+      "warm_p50": 0.093
     },
     {
       "baseline": "base",
@@ -6968,12 +6968,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.101,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.066,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.603,
-      "loki_warm_p50": 0.035,
+      "loki_cold": 0.605,
+      "loki_warm_p50": 0.043,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -6982,7 +6982,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.111
+      "warm_p50": 0.122
     },
     {
       "baseline": "base",
@@ -7044,12 +7044,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.008,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.346,
-      "loki_warm_p50": 0.02,
+      "loki_cold": 0.341,
+      "loki_warm_p50": 0.024,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7058,7 +7058,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.008
+      "warm_p50": 0.009
     },
     {
       "baseline": "base",
@@ -7120,12 +7120,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.011,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.012,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.325,
-      "loki_warm_p50": 0.023,
+      "loki_cold": 0.319,
+      "loki_warm_p50": 0.019,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7134,7 +7134,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.012
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -7196,12 +7196,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.006,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.005,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.335,
-      "loki_warm_p50": 0.04,
+      "loki_cold": 0.338,
+      "loki_warm_p50": 0.046,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7210,7 +7210,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.007
+      "warm_p50": 0.008
     },
     {
       "baseline": "base",
@@ -7272,12 +7272,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.025,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.345,
-      "loki_warm_p50": 0.044,
+      "loki_cold": 0.354,
+      "loki_warm_p50": 0.04,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7286,7 +7286,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.025
+      "warm_p50": 0.032
     },
     {
       "baseline": "base",
@@ -7348,12 +7348,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.018,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.02,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.346,
-      "loki_warm_p50": 0.038,
+      "loki_cold": 0.338,
+      "loki_warm_p50": 0.044,
       "parity_vs_loki": "differs",
       "range": "1h",
       "set": "control",
@@ -7362,7 +7362,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.019
+      "warm_p50": 0.02
     },
     {
       "baseline": "base",
@@ -7424,12 +7424,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.029,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.333,
-      "loki_warm_p50": 0.018,
+      "loki_cold": 0.334,
+      "loki_warm_p50": 0.021,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7438,7 +7438,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.02
+      "warm_p50": 0.025
     },
     {
       "baseline": "base",
@@ -7500,12 +7500,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.025,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.013,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.333,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.337,
+      "loki_warm_p50": 0.02,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7514,7 +7514,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.016
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -7576,12 +7576,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.007,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.01,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.32,
-      "loki_warm_p50": 0.013,
+      "loki_cold": 0.345,
+      "loki_warm_p50": 0.015,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7652,12 +7652,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.015,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.019,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.342,
-      "loki_warm_p50": 0.017,
+      "loki_cold": 0.343,
+      "loki_warm_p50": 0.016,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7666,7 +7666,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.014
+      "warm_p50": 0.017
     },
     {
       "baseline": "base",
@@ -7728,12 +7728,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.023,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.019,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.347,
-      "loki_warm_p50": 0.012,
+      "loki_cold": 0.343,
+      "loki_warm_p50": 0.017,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7742,7 +7742,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.018
+      "warm_p50": 0.019
     },
     {
       "baseline": "base",
@@ -7804,12 +7804,12 @@
     {
       "baseline": "base",
       "baseline_status": "400",
-      "cold": 0.004,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.002,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.064,
-      "loki_warm_p50": 0.06,
+      "loki_cold": 0.078,
+      "loki_warm_p50": 0.054,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7880,12 +7880,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.287,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.273,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.57,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.546,
+      "loki_warm_p50": 0.039,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -7894,7 +7894,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.182
+      "warm_p50": 0.245
     },
     {
       "baseline": "base",
@@ -7956,28 +7956,28 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.617,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-1h",
+      "cold": 0.595,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.331,
-      "loki_warm_p50": 0.017,
-      "parity_vs_loki": "same series, sum \u00b10.27%",
+      "loki_cold": 0.658,
+      "loki_warm_p50": 0.022,
+      "parity_vs_loki": "same series, sum \u00b10.25%",
       "range": "1h",
       "set": "metric-latency-gap",
       "shape": "DL6 explore volume, level filter before json",
-      "slower_than_loki_cold": true,
+      "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.279
+      "warm_p50": 0.3
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 12.493,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 12.604,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -7989,7 +7989,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 6.904
+      "warm_p50": 6.536
     },
     {
       "baseline": "main",
@@ -8013,9 +8013,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.805,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 3.496,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -8027,7 +8027,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 1.598
+      "warm_p50": 1.693
     },
     {
       "baseline": "main",
@@ -13314,12 +13314,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.52,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.536,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.184,
-      "loki_warm_p50": 0.012,
+      "loki_cold": 0.202,
+      "loki_warm_p50": 0.015,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -13328,14 +13328,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.5
+      "warm_p50": 0.554
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 9.675,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 9.401,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13347,14 +13347,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 9.633
+      "warm_p50": 9.395
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.266,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 3.118,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13366,17 +13366,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 3.159
+      "warm_p50": 3.039
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 2.312,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 2.246,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.372,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.411,
+      "loki_warm_p50": 0.026,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -13385,14 +13385,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 2.228
+      "warm_p50": 2.209
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 7.927,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 7.594,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13404,14 +13404,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 7.987
+      "warm_p50": 7.687
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 7.811,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 7.517,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13423,17 +13423,17 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 7.965
+      "warm_p50": 7.65
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.526,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.529,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.087,
-      "loki_warm_p50": 0.008,
+      "loki_cold": 0.097,
+      "loki_warm_p50": 0.01,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -13442,14 +13442,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.53
+      "warm_p50": 0.526
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 9.774,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 9.725,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13461,14 +13461,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 9.57
+      "warm_p50": 9.907
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.234,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 3.214,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13480,17 +13480,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 3.212
+      "warm_p50": 3.181
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.024,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.106,
-      "loki_warm_p50": 0.005,
+      "loki_cold": 0.103,
+      "loki_warm_p50": 0.007,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -13499,14 +13499,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.048
+      "warm_p50": 0.037
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.804,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.792,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13518,14 +13518,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.7
+      "warm_p50": 0.792
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.187,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.181,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13537,17 +13537,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.106
+      "warm_p50": 0.174
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.007,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.424,
-      "loki_warm_p50": 0.021,
+      "loki_cold": 0.423,
+      "loki_warm_p50": 0.022,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -13556,14 +13556,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.008
+      "warm_p50": 0.009
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.185,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.188,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13574,15 +13574,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.174
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.23
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.029,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13593,18 +13593,18 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.028
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.04
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.009,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.047,
-      "loki_warm_p50": 0.017,
+      "loki_cold": 0.403,
+      "loki_warm_p50": 0.018,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -13612,15 +13612,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.009
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.011
     },
     {
       "baseline": "base",
-      "baseline_status": "502",
-      "cold": 0.142,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "baseline_status": "200",
+      "cold": 0.166,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13631,15 +13631,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "fixed",
-      "warm_p50": 0.178
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.19
     },
     {
       "baseline": "base",
-      "baseline_status": "502",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "baseline_status": "200",
+      "cold": 0.041,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -13650,20 +13650,20 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "fixed",
-      "warm_p50": 0.025
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.028
     }
   ],
   "metric-series-identity": [
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.011,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.012,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.325,
-      "loki_warm_p50": 0.023,
+      "loki_cold": 0.319,
+      "loki_warm_p50": 0.019,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -13672,7 +13672,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.012
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -14249,12 +14249,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.011,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.012,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.325,
-      "loki_warm_p50": 0.023,
+      "loki_cold": 0.319,
+      "loki_warm_p50": 0.019,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -14263,7 +14263,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.012
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -14325,12 +14325,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.006,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.005,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.335,
-      "loki_warm_p50": 0.04,
+      "loki_cold": 0.338,
+      "loki_warm_p50": 0.046,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -14339,7 +14339,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.007
+      "warm_p50": 0.008
     },
     {
       "baseline": "base",
@@ -14401,12 +14401,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.025,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.345,
-      "loki_warm_p50": 0.044,
+      "loki_cold": 0.354,
+      "loki_warm_p50": 0.04,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -14415,7 +14415,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.025
+      "warm_p50": 0.032
     },
     {
       "baseline": "base",
@@ -14479,12 +14479,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.018,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.02,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.346,
-      "loki_warm_p50": 0.038,
+      "loki_cold": 0.338,
+      "loki_warm_p50": 0.044,
       "parity_vs_loki": "differs",
       "range": "1h",
       "set": "control",
@@ -14493,7 +14493,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.019
+      "warm_p50": 0.02
     },
     {
       "baseline": "base",
@@ -15243,12 +15243,12 @@
     {
       "baseline": "base",
       "baseline_status": "400",
-      "cold": 0.004,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.002,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.064,
-      "loki_warm_p50": 0.06,
+      "loki_cold": 0.078,
+      "loki_warm_p50": 0.054,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -16860,12 +16860,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.022,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.042,
-      "loki_warm_p50": 0.041,
+      "loki_cold": 0.054,
+      "loki_warm_p50": 0.043,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -16874,7 +16874,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.03
+      "warm_p50": 0.036
     },
     {
       "baseline": "base",
@@ -16936,12 +16936,12 @@
     {
       "baseline": "base",
       "baseline_status": "400",
-      "cold": 0.004,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.002,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.064,
-      "loki_warm_p50": 0.06,
+      "loki_cold": 0.078,
+      "loki_warm_p50": 0.054,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -17299,12 +17299,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.052,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.036,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.033,
-      "loki_warm_p50": 0.044,
+      "loki_cold": 0.036,
+      "loki_warm_p50": 0.032,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -17313,7 +17313,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.042
+      "warm_p50": 0.099
     },
     {
       "baseline": "base",
@@ -17375,12 +17375,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.101,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.066,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.603,
-      "loki_warm_p50": 0.035,
+      "loki_cold": 0.605,
+      "loki_warm_p50": 0.043,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -17389,7 +17389,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.111
+      "warm_p50": 0.122
     },
     {
       "baseline": "base",
@@ -17451,12 +17451,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.287,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.273,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.57,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.546,
+      "loki_warm_p50": 0.039,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -17465,7 +17465,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.182
+      "warm_p50": 0.245
     },
     {
       "baseline": "base",
@@ -18850,12 +18850,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.025,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.345,
-      "loki_warm_p50": 0.044,
+      "loki_cold": 0.354,
+      "loki_warm_p50": 0.04,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -18864,7 +18864,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.025
+      "warm_p50": 0.032
     },
     {
       "baseline": "base",
@@ -18928,12 +18928,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.011,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.012,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.325,
-      "loki_warm_p50": 0.023,
+      "loki_cold": 0.319,
+      "loki_warm_p50": 0.019,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -18942,7 +18942,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.012
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -19006,12 +19006,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.006,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.005,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.335,
-      "loki_warm_p50": 0.04,
+      "loki_cold": 0.338,
+      "loki_warm_p50": 0.046,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -19020,7 +19020,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.007
+      "warm_p50": 0.008
     },
     {
       "baseline": "base",
@@ -19082,12 +19082,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.018,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.02,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.346,
-      "loki_warm_p50": 0.038,
+      "loki_cold": 0.338,
+      "loki_warm_p50": 0.044,
       "parity_vs_loki": "differs",
       "range": "1h",
       "set": "control",
@@ -19096,7 +19096,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.019
+      "warm_p50": 0.02
     },
     {
       "baseline": "base",
@@ -19158,12 +19158,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.004,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.007,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.034,
-      "loki_warm_p50": 0.037,
+      "loki_cold": 0.044,
+      "loki_warm_p50": 0.031,
       "parity_vs_loki": "same",
       "range": "instant",
       "set": "control",
@@ -19172,7 +19172,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.006
+      "warm_p50": 0.007
     }
   ],
   "semantics/extracted-suffix-collision": [
@@ -20443,12 +20443,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.163,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.179,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.042,
-      "loki_warm_p50": 0.054,
+      "loki_cold": 0.03,
+      "loki_warm_p50": 0.032,
       "parity_vs_loki": "same",
       "range": "instant",
       "set": "control",
@@ -20457,7 +20457,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.161
+      "warm_p50": 0.175
     }
   ],
   "semantics/json-label-spelling-probe": [
@@ -20618,12 +20618,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.52,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.536,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.184,
-      "loki_warm_p50": 0.012,
+      "loki_cold": 0.202,
+      "loki_warm_p50": 0.015,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -20632,14 +20632,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.5
+      "warm_p50": 0.554
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 9.675,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 9.401,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20651,14 +20651,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 9.633
+      "warm_p50": 9.395
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.266,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 3.118,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20670,17 +20670,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 3.159
+      "warm_p50": 3.039
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 2.312,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 2.246,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.372,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.411,
+      "loki_warm_p50": 0.026,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -20689,14 +20689,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 2.228
+      "warm_p50": 2.209
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 7.927,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 7.594,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20708,14 +20708,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 7.987
+      "warm_p50": 7.687
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 7.811,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 7.517,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20727,17 +20727,17 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 7.965
+      "warm_p50": 7.65
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.526,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.529,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.087,
-      "loki_warm_p50": 0.008,
+      "loki_cold": 0.097,
+      "loki_warm_p50": 0.01,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -20746,14 +20746,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.53
+      "warm_p50": 0.526
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 9.774,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 9.725,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20765,14 +20765,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 9.57
+      "warm_p50": 9.907
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.234,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 3.214,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20784,17 +20784,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 3.212
+      "warm_p50": 3.181
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.024,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.106,
-      "loki_warm_p50": 0.005,
+      "loki_cold": 0.103,
+      "loki_warm_p50": 0.007,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -20803,14 +20803,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.048
+      "warm_p50": 0.037
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.804,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.792,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20822,14 +20822,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.7
+      "warm_p50": 0.792
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.187,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.181,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20841,17 +20841,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.106
+      "warm_p50": 0.174
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.007,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.424,
-      "loki_warm_p50": 0.021,
+      "loki_cold": 0.423,
+      "loki_warm_p50": 0.022,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -20860,14 +20860,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.008
+      "warm_p50": 0.009
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.185,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.188,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20878,15 +20878,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.174
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.23
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.029,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20897,18 +20897,18 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.028
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.04
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.009,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.047,
-      "loki_warm_p50": 0.017,
+      "loki_cold": 0.403,
+      "loki_warm_p50": 0.018,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -20916,15 +20916,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.009
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.011
     },
     {
       "baseline": "base",
-      "baseline_status": "502",
-      "cold": 0.142,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "baseline_status": "200",
+      "cold": 0.166,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20935,15 +20935,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "fixed",
-      "warm_p50": 0.178
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.19
     },
     {
       "baseline": "base",
-      "baseline_status": "502",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "baseline_status": "200",
+      "cold": 0.041,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -20954,8 +20954,8 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "fixed",
-      "warm_p50": 0.025
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.028
     }
   ],
   "semantics/label-browser-latency-cold-and-refresh": [
@@ -21572,28 +21572,28 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.617,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-1h",
+      "cold": 0.595,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.331,
-      "loki_warm_p50": 0.017,
-      "parity_vs_loki": "same series, sum \u00b10.27%",
+      "loki_cold": 0.658,
+      "loki_warm_p50": 0.022,
+      "parity_vs_loki": "same series, sum \u00b10.25%",
       "range": "1h",
       "set": "metric-latency-gap",
       "shape": "DL6 explore volume, level filter before json",
-      "slower_than_loki_cold": true,
+      "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.279
+      "warm_p50": 0.3
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 12.493,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 12.604,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -21605,7 +21605,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 6.904
+      "warm_p50": 6.536
     },
     {
       "baseline": "main",
@@ -21629,9 +21629,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.805,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 3.496,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -21643,7 +21643,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 1.598
+      "warm_p50": 1.693
     },
     {
       "baseline": "main",
@@ -27566,12 +27566,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.025,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.013,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.333,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.337,
+      "loki_warm_p50": 0.02,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -27580,7 +27580,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.016
+      "warm_p50": 0.015
     },
     {
       "baseline": "base",
@@ -27642,12 +27642,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.015,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.019,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.342,
-      "loki_warm_p50": 0.017,
+      "loki_cold": 0.343,
+      "loki_warm_p50": 0.016,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -27656,7 +27656,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.014
+      "warm_p50": 0.017
     },
     {
       "baseline": "base",
@@ -27720,12 +27720,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.096,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-1h",
+      "cold": 0.1,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.909,
-      "loki_warm_p50": 0.029,
+      "loki_cold": 0.891,
+      "loki_warm_p50": 0.067,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-filter-pushdown",
@@ -27734,14 +27734,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.098
+      "warm_p50": 0.088
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 2.41,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-long",
+      "cold": 2.677,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -27753,7 +27753,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 2.402
+      "warm_p50": 2.508
     },
     {
       "baseline": "main",
@@ -27777,9 +27777,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.611,
-      "date": "2026-10-14",
-      "label": "detlevel-d-capped-long",
+      "cold": 0.679,
+      "date": "2026-10-16",
+      "label": "dlfirstview-d-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -27791,17 +27791,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.608
+      "warm_p50": 0.697
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.093,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.1,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.451,
-      "loki_warm_p50": 0.021,
+      "loki_cold": 0.421,
+      "loki_warm_p50": 0.026,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -27810,7 +27810,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.105
+      "warm_p50": 0.093
     },
     {
       "baseline": "base",
@@ -27872,12 +27872,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.101,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.066,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.603,
-      "loki_warm_p50": 0.035,
+      "loki_cold": 0.605,
+      "loki_warm_p50": 0.043,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -27886,7 +27886,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.111
+      "warm_p50": 0.122
     },
     {
       "baseline": "base",
@@ -27948,12 +27948,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.008,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.346,
-      "loki_warm_p50": 0.02,
+      "loki_cold": 0.341,
+      "loki_warm_p50": 0.024,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -27962,7 +27962,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.008
+      "warm_p50": 0.009
     },
     {
       "baseline": "base",
@@ -28024,12 +28024,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.029,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.333,
-      "loki_warm_p50": 0.018,
+      "loki_cold": 0.334,
+      "loki_warm_p50": 0.021,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -28038,7 +28038,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.02
+      "warm_p50": 0.025
     },
     {
       "baseline": "base",
@@ -28100,12 +28100,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.007,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.01,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.32,
-      "loki_warm_p50": 0.013,
+      "loki_cold": 0.345,
+      "loki_warm_p50": 0.015,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -28176,12 +28176,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.023,
-      "date": "2026-10-14",
-      "label": "detlevel-control-1h",
+      "cold": 0.019,
+      "date": "2026-10-16",
+      "label": "dlfirstview-control-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.347,
-      "loki_warm_p50": 0.012,
+      "loki_cold": 0.343,
+      "loki_warm_p50": 0.017,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "control",
@@ -28190,7 +28190,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.018
+      "warm_p50": 0.019
     },
     {
       "baseline": "base",
@@ -28252,28 +28252,28 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.617,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-1h",
+      "cold": 0.595,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.331,
-      "loki_warm_p50": 0.017,
-      "parity_vs_loki": "same series, sum \u00b10.27%",
+      "loki_cold": 0.658,
+      "loki_warm_p50": 0.022,
+      "parity_vs_loki": "same series, sum \u00b10.25%",
       "range": "1h",
       "set": "metric-latency-gap",
       "shape": "DL6 explore volume, level filter before json",
-      "slower_than_loki_cold": true,
+      "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.279
+      "warm_p50": 0.3
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 12.493,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 12.604,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28285,7 +28285,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 6.904
+      "warm_p50": 6.536
     },
     {
       "baseline": "main",
@@ -28309,9 +28309,9 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.805,
-      "date": "2026-10-14",
-      "label": "detlevel-dl6-capped-long",
+      "cold": 3.496,
+      "date": "2026-10-16",
+      "label": "dlfirstview-dl6-capped-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28323,7 +28323,7 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 1.598
+      "warm_p50": 1.693
     },
     {
       "baseline": "main",
@@ -28575,12 +28575,12 @@
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.52,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.536,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.184,
-      "loki_warm_p50": 0.012,
+      "loki_cold": 0.202,
+      "loki_warm_p50": 0.015,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -28589,14 +28589,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.5
+      "warm_p50": 0.554
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 9.675,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 9.401,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28608,14 +28608,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 9.633
+      "warm_p50": 9.395
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.266,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 3.118,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28627,17 +28627,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 3.159
+      "warm_p50": 3.039
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 2.312,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 2.246,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.372,
-      "loki_warm_p50": 0.025,
+      "loki_cold": 0.411,
+      "loki_warm_p50": 0.026,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -28646,14 +28646,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 2.228
+      "warm_p50": 2.209
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 7.927,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 7.594,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28665,14 +28665,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 7.987
+      "warm_p50": 7.687
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 7.811,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 7.517,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28684,17 +28684,17 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 7.965
+      "warm_p50": 7.65
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.526,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.529,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.087,
-      "loki_warm_p50": 0.008,
+      "loki_cold": 0.097,
+      "loki_warm_p50": 0.01,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -28703,14 +28703,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.53
+      "warm_p50": 0.526
     },
     {
       "baseline": "base",
       "baseline_status": "502",
-      "cold": 9.774,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 9.725,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28722,14 +28722,14 @@
       "status": "502",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 9.57
+      "warm_p50": 9.907
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 3.234,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 3.214,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28741,17 +28741,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 3.212
+      "warm_p50": 3.181
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.024,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.023,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.106,
-      "loki_warm_p50": 0.005,
+      "loki_cold": 0.103,
+      "loki_warm_p50": 0.007,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -28760,14 +28760,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.048
+      "warm_p50": 0.037
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.804,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.792,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28779,14 +28779,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.7
+      "warm_p50": 0.792
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.187,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.181,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28798,17 +28798,17 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.106
+      "warm_p50": 0.174
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.007,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.424,
-      "loki_warm_p50": 0.021,
+      "loki_cold": 0.423,
+      "loki_warm_p50": 0.022,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -28817,14 +28817,14 @@
       "status": "200",
       "valid": true,
       "verdict_vs_baseline": "same",
-      "warm_p50": 0.008
+      "warm_p50": 0.009
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.185,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.188,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28835,15 +28835,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.174
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.23
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "cold": 0.029,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28854,18 +28854,18 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.028
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.04
     },
     {
       "baseline": "base",
       "baseline_status": "200",
-      "cold": 0.009,
-      "date": "2026-10-14",
-      "label": "detlevel-1h",
+      "cold": 0.006,
+      "date": "2026-10-16",
+      "label": "dlfirstview-1h",
       "loki_cache_served": false,
-      "loki_cold": 0.047,
-      "loki_warm_p50": 0.017,
+      "loki_cold": 0.403,
+      "loki_warm_p50": 0.018,
       "parity_vs_loki": "same",
       "range": "1h",
       "set": "json-detected-level",
@@ -28873,15 +28873,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "faster",
-      "warm_p50": 0.009
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.011
     },
     {
       "baseline": "base",
-      "baseline_status": "502",
-      "cold": 0.142,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "baseline_status": "200",
+      "cold": 0.166,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28892,15 +28892,15 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "fixed",
-      "warm_p50": 0.178
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.19
     },
     {
       "baseline": "base",
-      "baseline_status": "502",
-      "cold": 0.027,
-      "date": "2026-10-14",
-      "label": "detlevel-long",
+      "baseline_status": "200",
+      "cold": 0.041,
+      "date": "2026-10-16",
+      "label": "dlfirstview-long",
       "loki_cache_served": false,
       "loki_cold": null,
       "loki_warm_p50": null,
@@ -28911,8 +28911,8 @@
       "slower_than_loki_cold": false,
       "status": "200",
       "valid": true,
-      "verdict_vs_baseline": "fixed",
-      "warm_p50": 0.025
+      "verdict_vs_baseline": "same",
+      "warm_p50": 0.028
     }
   ]
 }
diff --git a/conformance/reports/performance.md b/conformance/reports/performance.md
index 47f9c6438..a94daedd9 100644
--- a/conformance/reports/performance.md
+++ b/conformance/reports/performance.md
@@ -7,14 +7,14 @@ Do not edit by hand. Timings are the candidate build's; Loki is compared on cold
 Loki's first run can still hit split-level caches warmed by earlier requests, so a Loki cold
 time near zero understates what a truly cold Loki takes.
 
-Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-metric-latency-gap (2026-09-23), pr624-final-drilldown-breakdown-exact (2026-09-30), pr624-final-loki-profile-otel-metadata (2026-09-30), backfilled-empty-buckets-metadata-freshness (2026-10-01), backfilled-empty-buckets-metadata-inventory (2026-10-01), loki-parity-pages-loki-profile-otel-metadata (2026-10-01), ordered-json-control-long (2026-10-01), ordered-json-drilldown-breakdown-exact-long (2026-10-01), ordered-json-json-filter-pushdown-1h (2026-10-01), ordered-json-json-filter-pushdown-long (2026-10-01), ordered-json-metric-latency-gap-1h (2026-10-01), ordered-json-metric-latency-gap-long (2026-10-01), stage-field-exposure (2026-10-02), extracted-suffix (2026-10-06), paren-or-filters-parenthesized-range-or-filters (2026-10-06), plain-name-after-parser (2026-10-06), plain-name-control (2026-10-06), plain-name-drilldown-breakdown-exact (2026-10-06), unwrap-validity (2026-10-06), unwrap-validity-24h (2026-10-06), extmetric-extracted (2026-10-07), unwraperr-conversion (2026-10-08), unwrapsum-1h (2026-10-11), unwrapsum-long (2026-10-11), dursec-1h (2026-10-12), dursec-24h (2026-10-12), patanchor-1h (2026-10-12), patanchor-24h (2026-10-12), patanchor-24h-multi (2026-10-12), patanchor-control-24h (2026-10-12), patfilter-1h (2026-10-12), detlevel-1h (2026-10-14), detlevel-control-1h (2026-10-14), detlevel-d-capped-1h (2026-10-14), detlevel-d-capped-long (2026-10-14), detlevel-dl6-capped-1h (2026-10-14), detlevel-dl6-capped-long (2026-10-14), detlevel-long (2026-10-14).
+Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-metric-latency-gap (2026-09-23), pr624-final-drilldown-breakdown-exact (2026-09-30), pr624-final-loki-profile-otel-metadata (2026-09-30), backfilled-empty-buckets-metadata-freshness (2026-10-01), backfilled-empty-buckets-metadata-inventory (2026-10-01), loki-parity-pages-loki-profile-otel-metadata (2026-10-01), ordered-json-control-long (2026-10-01), ordered-json-drilldown-breakdown-exact-long (2026-10-01), ordered-json-json-filter-pushdown-1h (2026-10-01), ordered-json-json-filter-pushdown-long (2026-10-01), ordered-json-metric-latency-gap-1h (2026-10-01), ordered-json-metric-latency-gap-long (2026-10-01), stage-field-exposure (2026-10-02), extracted-suffix (2026-10-06), paren-or-filters-parenthesized-range-or-filters (2026-10-06), plain-name-after-parser (2026-10-06), plain-name-control (2026-10-06), plain-name-drilldown-breakdown-exact (2026-10-06), unwrap-validity (2026-10-06), unwrap-validity-24h (2026-10-06), extmetric-extracted (2026-10-07), unwraperr-conversion (2026-10-08), unwrapsum-1h (2026-10-11), unwrapsum-long (2026-10-11), dursec-1h (2026-10-12), dursec-24h (2026-10-12), patanchor-1h (2026-10-12), patanchor-24h (2026-10-12), patanchor-24h-multi (2026-10-12), patanchor-control-24h (2026-10-12), patfilter-1h (2026-10-12), dlfirstview-1h (2026-10-16), dlfirstview-control-1h (2026-10-16), dlfirstview-d-capped-1h (2026-10-16), dlfirstview-d-capped-long (2026-10-16), dlfirstview-dl6-capped-1h (2026-10-16), dlfirstview-dl6-capped-long (2026-10-16), dlfirstview-long (2026-10-16).
 
 ## Slower than Loki on first load
 
 | shape | range | proxy cold | Loki cold | proxy warm | Loki warm | registry items |
 |---|---|---|---|---|---|---|
-| instant json filtered | instant | 0.16s | 0.04s | 0.16s | 0.05s | `semantics/json-filter-pushdown-without-error-drop` |
-| instant json volume | instant | 0.21s | 0.05s | 0.19s | 0.05s | `explore-logs-volume-json` |
+| instant json filtered | instant | 0.18s | 0.03s | 0.17s | 0.03s | `semantics/json-filter-pushdown-without-error-drop` |
+| instant json volume | instant | 0.21s | 0.05s | 0.21s | 0.05s | `explore-logs-volume-json` |
 | X1 json filter level_extracted, by level | 1h | 0.50s | 0.01s | 0.07s | 0.00s | `parser-error-and-label-collision`, `semantics/extracted-suffix-collision`, `semantics/json-extracted-metric-pushdown` |
 | X1 json filter level_extracted, by level | 6h | 2.65s | 0.01s | 0.40s | 0.00s | `parser-error-and-label-collision`, `semantics/extracted-suffix-collision`, `semantics/json-extracted-metric-pushdown` |
 | X2 json group by level_extracted | 1h | 0.07s | 0.00s | 0.07s | 0.00s | `parser-error-and-label-collision`, `semantics/extracted-suffix-collision`, `semantics/json-extracted-metric-pushdown` |
@@ -29,9 +29,9 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | X5 logfmt filter level_extracted, by level | 24h | 0.74s | 0.00s | 0.71s | 0.00s | `parser-error-and-label-collision`, `semantics/extracted-suffix-collision`, `semantics/json-extracted-metric-pushdown` |
 | X5 logfmt filter level_extracted, by level | 6h | 0.68s | 0.01s | 0.74s | 0.01s | `parser-error-and-label-collision`, `semantics/extracted-suffix-collision`, `semantics/json-extracted-metric-pushdown` |
 | E7 json count by level_extracted | 1h | 0.52s | 0.09s | 0.52s | 0.01s | `loki-compatible-profile`, `profiles/structured-metadata-label-collision`, `semantics/extracted-suffix-collision` |
-| DLV1 drilldown logs volume, json | 1h | 0.52s | 0.18s | 0.50s | 0.01s | `semantics/json-metric-detected-level-derivation`, `severity-detected-level-derivation` |
-| DLV2 json error filter, detected_level | 1h | 2.31s | 0.37s | 2.23s | 0.03s | `semantics/json-metric-detected-level-derivation`, `severity-detected-level-derivation` |
-| DLV3 plain json, detected_level | 1h | 0.53s | 0.09s | 0.53s | 0.01s | `semantics/json-metric-detected-level-derivation`, `severity-detected-level-derivation` |
+| DLV1 drilldown logs volume, json | 1h | 0.54s | 0.20s | 0.55s | 0.01s | `semantics/json-metric-detected-level-derivation`, `severity-detected-level-derivation` |
+| DLV2 json error filter, detected_level | 1h | 2.25s | 0.41s | 2.21s | 0.03s | `semantics/json-metric-detected-level-derivation`, `severity-detected-level-derivation` |
+| DLV3 plain json, detected_level | 1h | 0.53s | 0.10s | 0.53s | 0.01s | `semantics/json-metric-detected-level-derivation`, `severity-detected-level-derivation` |
 | A explore volume, 2 filters, drop | 3h | 0.37s | 0.00s | 0.11s | 0.01s | `explore-logs-volume-json`, `parser-error-and-label-collision`, `semantics/json-filter-pushdown-translated-label`, `semantics/json-filter-pushdown-underscore-label` |
 | B grouped sum, filter, no drop | 3h | 0.30s | 0.03s | 0.10s | 0.01s | `parser-error-and-label-collision`, `semantics/json-filter-pushdown-without-error-drop` |
 | C ungrouped sum, filter, no drop | 3h | 0.11s | 0.00s | 0.07s | 0.00s | `parser-error-and-label-collision`, `semantics/json-filter-pushdown-ungrouped-sum` |
@@ -46,7 +46,6 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | DL1 drilldown field breakdown json-expr, level filter | 3h | 0.06s | 0.01s | 0.00s | 0.01s | `parsed-label-series-identity`, `parser-json`, `severity-detected-level-derivation` |
 | DL2 drilldown field breakdown, level + stream-label filter before json | 3h | 0.06s | 0.00s | 0.04s | 0.00s | `parsed-label-series-identity`, `semantics/label-filter-before-parser-pushdown`, `severity-detected-level-derivation` |
 | DL3 drilldown logfmt field breakdown, level filter | 3h | 0.34s | 0.12s | 0.33s | 0.13s | `parser-logfmt`, `severity-detected-level-derivation` |
-| DL6 explore volume, level filter before json | 1h | 0.62s | 0.33s | 0.28s | 0.02s | `explore-logs-volume-json`, `semantics/label-filter-before-parser-pushdown`, `severity-detected-level-derivation` |
 | DL6 explore volume, level filter before json | 3h | 0.57s | 0.01s | 0.14s | 0.00s | `explore-logs-volume-json`, `semantics/label-filter-before-parser-pushdown`, `severity-detected-level-derivation` |
 | P8 json count by a name that is no stream label | 3h | 0.06s | 0.00s | 0.03s | 0.00s | `loki-compatible-profile`, `semantics/plain-name-after-parser-reads-stream-label` |
 | E1 json duration_ms sum by service | 24h | 0.61s | 0.01s | 0.65s | 0.01s | `parser-error-and-label-collision`, `semantics/unwrap-conversion-error` |
@@ -66,7 +65,7 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | E9 logfmt latency_ms sum by service, namespace prod | 7d | 9.86s | 0.03s | 11.61s | 0.01s | `parser-error-and-label-collision`, `semantics/unwrap-conversion-error` |
 | U13 logfmt latency_ms over every service | 1h | 0.10s | 0.00s | 0.09s | 0.00s | `parser-error-and-label-collision`, `semantics/unwrap-sample-validity` |
 
-52 shape×range slower than Loki beyond noise (25% and 50 ms).
+51 shape×range slower than Loki beyond noise (25% and 50 ms).
 
 ## By registry item
 
@@ -75,7 +74,7 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | `backend-admission-and-heavy-query-queueing` | 7 × 4 ranges | 28 same | worst 0.45s / 0.00s (7d) | 0.02s / 0.01s | differs; 2 slower than Loki cold |
 | `data-probing-and-freshness` | 4 × 4 ranges | 16 same | worst 0.02s / 0.00s (1h) | 0.00s / 0.00s | differs |
 | `drilldown-service-landing` | 2 × 4 ranges | 8 same | worst 0.13s / 0.17s (24h) | — / — | same |
-| `explore-logs-volume-json` | 7 × 5 ranges | 4 faster, 20 same, 1 slower | worst 12.49s / 6.90s (24h) | — / — | differs; 7 slower than Loki cold |
+| `explore-logs-volume-json` | 7 × 5 ranges | 4 faster, 20 same, 1 slower | worst 12.60s / 6.54s (24h) | — / — | differs; 6 slower than Loki cold |
 | `limits/concurrent-full-retention-scans-exhaust-backend` | 8 × 4 ranges | 32 same | worst 0.45s / 0.00s (7d) | 0.02s / 0.01s | same |
 | `limits/drilldown-breakdown-exact` | 4 × 5 ranges | 20 same | worst **502** / **502** (7d) | 180.00s / 41.84s | differs |
 | `limits/metadata-scan-adaptive-limit` | 4 × 4 ranges | 16 same | worst 0.00s / 0.01s (7d) | 0.02s / 0.02s | same |
@@ -87,7 +86,7 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | `loki_api_v1_label_name_values` | 6 × 4 ranges | 24 same | worst 0.45s / 0.00s (7d) | 0.02s / 0.01s | differs |
 | `loki_api_v1_labels` | 6 × 4 ranges | 24 same | worst 0.26s / 0.00s (7d) | 0.04s / 0.02s | differs |
 | `loki_api_v1_query` | 11 × 1 ranges | 2 fixed, 9 same | worst 0.25s / 0.13s (instant) | — / — | same; 2 slower than Loki cold |
-| `loki_api_v1_query_range` | 131 × 6 ranges | 35 faster, 64 fixed, 303 same, 2 slower | worst 13.13s / 13.44s (7d) | 0.01s / 0.00s | differs; 48 slower than Loki cold |
+| `loki_api_v1_query_range` | 131 × 6 ranges | 32 faster, 62 fixed, 308 same, 2 slower | worst 13.13s / 13.44s (7d) | 0.01s / 0.00s | differs; 47 slower than Loki cold |
 | `metric-series-identity` | 10 × 6 ranges | 8 faster, 6 fixed, 17 same | worst 1.18s / 1.06s (7d) | — / — | differs |
 | `operator-sum` | 3 × 4 ranges | 12 same | worst 0.27s / 0.29s (24h) | — / — | same |
 | `operator-topk` | 1 × 4 ranges | 4 same | worst 0.18s / 0.16s (24h) | — / — | differs |
@@ -110,9 +109,9 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | `semantics/json-filter-pushdown-ungrouped-sum` | 1 × 4 ranges | 2 faster, 2 same | worst 0.31s / 0.20s (24h) | — / — | same; 1 slower than Loki cold |
 | `semantics/json-filter-pushdown-without-error-drop` | 3 × 5 ranges | 3 faster, 5 same, 1 slower | worst 0.44s / 0.24s (24h) | — / — | same; 3 slower than Loki cold |
 | `semantics/json-label-spelling-probe` | 2 × 4 ranges | 3 faster, 5 same | worst 4.52s / 0.15s (24h) | — / — | same; 2 slower than Loki cold |
-| `semantics/json-metric-detected-level-derivation` | 6 × 3 ranges | 3 faster, 2 fixed, 13 same | worst **502** / **502** (24h) | — / — | same; 3 slower than Loki cold |
+| `semantics/json-metric-detected-level-derivation` | 6 × 3 ranges | 18 same | worst **502** / **502** (24h) | — / — | same; 3 slower than Loki cold |
 | `semantics/label-browser-latency-cold-and-refresh` | 8 × 4 ranges | 32 same | worst 0.45s / 0.00s (7d) | 0.02s / 0.01s | same |
-| `semantics/label-filter-before-parser-pushdown` | 2 × 4 ranges | 2 faster, 6 same | worst 12.49s / 6.90s (24h) | — / — | differs; 3 slower than Loki cold |
+| `semantics/label-filter-before-parser-pushdown` | 2 × 4 ranges | 2 faster, 6 same | worst 12.60s / 6.54s (24h) | — / — | differs; 2 slower than Loki cold |
 | `semantics/label-inventory-exact-and-incremental` | 12 × 4 ranges | 48 same | worst 0.45s / 0.00s (7d) | 0.02s / 0.01s | differs |
 | `semantics/labels-end-inclusive-like-loki` | 12 × 4 ranges | 48 same | worst 0.45s / 0.00s (7d) | 0.02s / 0.01s | differs |
 | `semantics/line-filter-or-alternatives` | 6 × 5 ranges | 21 fixed | worst 0.06s / 0.04s (3h) | 0.01s / 0.02s | same |
@@ -127,4 +126,4 @@ Runs: pr611-latency-gap-json-filter-pushdown (2026-09-23), pr611-latency-gap-met
 | `semantics/unwrap-sample-validity` | 14 × 3 ranges | 1 faster, 24 same | worst 2.09s / 2.17s (24h) | — / — | differs; 1 slower than Loki cold |
 | `series-limits-and-partial-results` | 4 × 5 ranges | 20 same | worst **502** / **502** (7d) | 180.00s / 41.84s | differs |
 | `service-name-derivation` | 2 × 4 ranges | 8 same | worst 0.13s / 0.17s (24h) | — / — | same |
-| `severity-detected-level-derivation` | 18 × 5 ranges | 6 faster, 2 fixed, 54 same, 1 slower | worst 12.49s / 6.90s (24h) | — / — | differs; 9 slower than Loki cold |
+| `severity-detected-level-derivation` | 18 × 5 ranges | 3 faster, 59 same, 1 slower | worst 12.60s / 6.54s (24h) | — / — | differs; 8 slower than Loki cold |

From 1e027766fa78b0964b4e374d0452a083e5e43c71 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 00:08:06 +0200
Subject: [PATCH 06/14] docs: changelog entry and registry row for the
 first-view cuts

---
 CHANGELOG.md                                  | 25 +++++++++++++++++++
 ...json-metric-detected-level-derivation.yaml | 20 ++++++++++-----
 conformance/registry/generated/wiring.json    | 18 ++++++++++++-
 conformance/reports/gaps.md                   | 10 ++++----
 conformance/reports/roadmap.md                |  2 +-
 5 files changed, 62 insertions(+), 13 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 06052e1e1..b61a66bb5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Performance
+
+- **The first view of a window of `sum by (detected_level)` / `sum by (level,
+  detected_level)` over `| json`, on rows with no stored level, costs less
+  (follow-up to #760).** A window nothing remembers (probed again every five
+  minutes) asks the stored-level query, the level probes and the presence
+  probe before the chain. Three cuts, none of which changes an answer: the two
+  "two level keys" patterns of the level keys probe (a key twice in a JSON or
+  logfmt line), which scanned the rest of every line holding a level key and
+  were the heaviest probe, 320 to 380 CPU-ms of an hour of rows, run behind a
+  filter of phrases (one key name twice, or two of the names; answered from
+  VictoriaLogs' token index, a superset of the patterns, never a second
+  decision), 45 to 55 CPU-ms; a selector of 11.8 KB or more, for which the
+  longer probe would pass VictoriaLogs' 16 KiB query length, gets the probe
+  without the gate; and the label probes (main's partial-parse probe among
+  them) are remembered apart from the level probes, so the chain takes their
+  verdict from the stored-level query instead of asking the same question
+  again (51 CPU-ms of an hour). Explore's JSON volume on the harness's backfill
+  without the level stream label, a proxy restarted before each request,
+  VictoriaLogs capped at 2 CPUs (median of 7 at 1h, 5 at 24h): 311 ms against
+  494 ms at 1h and 7.6 s against 11.2 s at 24h (main before #760: 56 ms and
+  2.9 s), 761 CPU-ms against 1085 and 15.2 CPU-s against 22.6; the
+  `sum by (detected_level)` breakdown 213 ms against 373 ms and 4.8 s against
+  8.1 s. Warm times are unchanged.
+
 ## [2.16.0] - 2026-10-16
 
 ### Fixed
diff --git a/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml b/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml
index 34bbdb765..00ecc0ad5 100644
--- a/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml
+++ b/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml
@@ -169,12 +169,20 @@ why: |
   7.5 s to 0.67 s (6h) and 2.6 s (24h), and on the data with a level stream
   label from 2.3 s to 7 ms at 1h. The first view of a window (nothing
   remembered: the stored-level attempt, the level probes, the presence probe,
-  then the chain) takes about 0.5 s at 1h for Explore's volume where main takes
-  0.08 s (0.55-0.68 s in the previous revision, both builds restarted on one
-  stack): the probes scan the window and share the 2 CPUs with the chain, the
-  heaviest of them (detectedLevelKeysRisk, 260-300 ms: two level keys in a line,
-  an escape in a level value, a brace without its closing brace) one this change
-  adds. A window with a row that has no stored level asks
+  then the chain) takes 0.31 s at 1h for Explore's volume where main before #760 takes
+  0.06 s (0.49 s before the first-view cuts) and 7.6 s at 24h against 2.9 s
+  (11.2 s), medians of cold requests with each build restarted before them: the
+  probes scan the window and share the 2 CPUs with the chain. The heaviest of
+  them was detectedLevelKeysRisk (320-380 CPU-ms of an hour of rows: two level
+  keys in a line, an escape in a level value, a brace without its closing
+  brace), whose two-keys patterns now run behind a filter of phrases
+  (logsqlTwiceFilter over detectedLevelKeyNames: one key name twice, or two of
+  the names, answered from VictoriaLogs' token index and a superset of the
+  patterns; 45-55 CPU-ms; a selector of 11.8 KB or more, which would push the
+  longer text past -search.maxQueryLen, gets the probe without the gate), and
+  the probes of the labels are remembered apart from the level probes
+  (cachedStatsPushdownRisk), so the chain does not ask again what the
+  stored-level query asked. A window with a row that has no stored level asks
   twice, the stored-level attempt first (it costs what main's query costs; its
   verdict is remembered for the base for five minutes so the next ask goes to
   the chain at once), and pays the chain with the three guard probes and the
diff --git a/conformance/registry/generated/wiring.json b/conformance/registry/generated/wiring.json
index 37ca347cb..d4ce99a17 100644
--- a/conformance/registry/generated/wiring.json
+++ b/conformance/registry/generated/wiring.json
@@ -426,11 +426,14 @@
       "test/e2e-compat/json_filter_pushdown_test.go"
     ],
     "semantics/json-metric-detected-level-derivation": [
+      "internal/proxy/detected_level_label_probes_test.go",
+      "internal/proxy/detected_level_long_selector_test.go",
       "internal/proxy/detected_level_presence_sweep_test.go",
       "internal/proxy/detected_level_presence_test.go",
       "internal/proxy/detected_level_shared_unpack_test.go",
       "internal/proxy/ordered_json_detected_level_test.go",
       "internal/proxy/stored_level_series_limit_test.go",
+      "test/e2e-compat/detected_level_keys_gate_test.go",
       "test/e2e-compat/detected_level_variants_test.go",
       "test/e2e-compat/json_detected_level_series_limit_test.go",
       "test/e2e-compat/json_detected_level_test.go"
@@ -559,6 +562,7 @@
       "test/e2e-compat/series_count_aggregation_test.go"
     ],
     "severity-detected-level-derivation": [
+      "internal/proxy/detected_level_keys_gate_test.go",
       "internal/proxy/detected_level_test.go",
       "internal/translator/detected_level_keyword_test.go",
       "internal/translator/detected_level_logsql_test.go",
@@ -654,6 +658,15 @@
     "internal/proxy/compat_cache_freshness_test.go": [
       "semantics/metadata-answers-include-last-24h-like-loki"
     ],
+    "internal/proxy/detected_level_keys_gate_test.go": [
+      "severity-detected-level-derivation"
+    ],
+    "internal/proxy/detected_level_label_probes_test.go": [
+      "semantics/json-metric-detected-level-derivation"
+    ],
+    "internal/proxy/detected_level_long_selector_test.go": [
+      "semantics/json-metric-detected-level-derivation"
+    ],
     "internal/proxy/detected_level_presence_sweep_test.go": [
       "semantics/json-metric-detected-level-derivation"
     ],
@@ -1016,6 +1029,9 @@
       "severity-detected-level-derivation",
       "severity/normalisation-table"
     ],
+    "test/e2e-compat/detected_level_keys_gate_test.go": [
+      "semantics/json-metric-detected-level-derivation"
+    ],
     "test/e2e-compat/detected_level_test.go": [
       "severity-detected-level-derivation",
       "severity-exposure-surfaces"
@@ -1200,7 +1216,7 @@
       "profiles/structured-metadata-keys-per-profile"
     ]
   },
-  "tests_with_markers": 116,
+  "tests_with_markers": 120,
   "unknown_ids": {},
   "unwired_items": [
     "api_prom_label",
diff --git a/conformance/reports/gaps.md b/conformance/reports/gaps.md
index 0dcb70e01..509d7ba8f 100644
--- a/conformance/reports/gaps.md
+++ b/conformance/reports/gaps.md
@@ -73,7 +73,7 @@ Semantics, severity, identity and data-quality behaviour the proxy must reproduc
 | semantics | `parser-error-and-label-collision` — Parser errors, __error__ and _extracted collisions | 21 | 10 | partial |
 | limits | `series-limits-and-partial-results` — Series limits: error, or partial result with a warning | 9 | 9 | partial |
 | identity | `service-name-derivation` — service_name follows Loki's discovery order | 9 | 0 | partial |
-| severity | `severity-detected-level-derivation` — detected_level is derived on the read path | 10 | 5 | partial |
+| severity | `severity-detected-level-derivation` — detected_level is derived on the read path | 10 | 6 | partial |
 | severity | `severity-exposure-surfaces` — Where detected_level and level must appear | 7 | 3 | partial |
 | limits | `tenant-query-limits` — Loki's per-tenant query limits, enforced as published | 13 | 3 | proven |
 | semantics | `window-bounds-and-step-alignment` — Range windows, bucket edges and step alignment | 8 | 5 | partial |
@@ -125,10 +125,10 @@ cold request (bench/ab runs; details in [performance.md](performance.md)).
 | `semantics/unwrap-conversion-error` | 15 | 13.13s (E3 logfmt latency_ms rate, production, 7d) | 0.01s |
 | `semantics/extracted-suffix-collision` | 14 | 2.65s (X1 json filter level_extracted, by level, 6h) | 0.01s |
 | `semantics/json-extracted-metric-pushdown` | 13 | 2.65s (X1 json filter level_extracted, by level, 6h) | 0.01s |
-| `semantics/json-metric-detected-level-derivation` | 3 | 2.31s (DLV2 json error filter, detected_level, 1h) | 0.37s |
-| `severity-detected-level-derivation` | 9 | 2.31s (DLV2 json error filter, detected_level, 1h) | 0.37s |
-| `explore-logs-volume-json` | 7 | 0.57s (DL6 explore volume, level filter before json, 3h) | 0.01s |
-| `semantics/label-filter-before-parser-pushdown` | 3 | 0.57s (DL6 explore volume, level filter before json, 3h) | 0.01s |
+| `semantics/json-metric-detected-level-derivation` | 3 | 2.25s (DLV2 json error filter, detected_level, 1h) | 0.41s |
+| `severity-detected-level-derivation` | 8 | 2.25s (DLV2 json error filter, detected_level, 1h) | 0.41s |
+| `explore-logs-volume-json` | 6 | 0.57s (DL6 explore volume, level filter before json, 3h) | 0.01s |
+| `semantics/label-filter-before-parser-pushdown` | 2 | 0.57s (DL6 explore volume, level filter before json, 3h) | 0.01s |
 | `parsed-label-series-identity` | 5 | 0.49s (E field breakdown pipeline (explore), 3h) | 0.03s |
 | `parser-json` | 2 | 0.49s (E field breakdown pipeline (explore), 3h) | 0.03s |
 | `loki-compatible-profile` | 3 | 0.52s (E7 json count by level_extracted, 1h) | 0.09s |
diff --git a/conformance/reports/roadmap.md b/conformance/reports/roadmap.md
index 0954aa322..9250dd903 100644
--- a/conformance/reports/roadmap.md
+++ b/conformance/reports/roadmap.md
@@ -33,7 +33,7 @@ Proven in part; the rest is named in the item's cases.
 | `parser-error-and-label-collision` — Parser errors, __error__ and _extracted collisions | — | 10 | The filtered-volume pushdown cases (underscore labels, filters without `drop __error__`, ungrouped sums, translated labe |
 | `series-limits-and-partial-results` — Series limits: error, or partial result with a warning | — | 9 | limits/series-limit-error and limits/drilldown-partial-with-warning are written and wired: a metric query above -max-sta |
 | `service-name-derivation` — service_name follows Loki's discovery order | — | 0 | The derivation matches Loki's 13-entry discover_service_name order and is used by selectors, label filters, grouping, la |
-| `severity-detected-level-derivation` — detected_level is derived on the read path | — | 5 | detected_level is derived per returned row from what VictoriaLogs stored: a stored detected_level field, then the first  |
+| `severity-detected-level-derivation` — detected_level is derived on the read path | — | 6 | detected_level is derived per returned row from what VictoriaLogs stored: a stored detected_level field, then the first  |
 | `severity-exposure-surfaces` — Where detected_level and level must appear | — | 3 | Log responses, /tail, /patterns and /detected_fields carry the derived detected_level; categorize-labels puts it and a s |
 | `window-bounds-and-step-alignment` — Range windows, bucket edges and step alignment | — | 5 | semantics/offset-sample-timestamps is written and wired: an offset modifier moves the window and leaves the sample times |
 

From cde363a75e7850cb8be89dbce4fe17af024b3606 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 01:22:41 +0200
Subject: [PATCH 07/14] test: visual proof pages for the detected_level
 volumes, and a 5m range

---
 bench/visual/spec.json | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/bench/visual/spec.json b/bench/visual/spec.json
index 872b00c31..473271f7c 100644
--- a/bench/visual/spec.json
+++ b/bench/visual/spec.json
@@ -16,6 +16,7 @@
   }
  ],
  "ranges": {
+  "5m": 300,
   "15m": 900,
   "1h": 3600,
   "6h": 21600,
@@ -24,6 +25,7 @@
   "live": 300
  },
  "default_ranges": [
+  "5m",
   "15m",
   "1h",
   "6h",
@@ -68,6 +70,26 @@
     "loki_api_v1_query_range"
    ]
   },
+  {
+   "id": "explore-D",
+   "kind": "explore",
+   "query": "sum by (level, detected_level) (count_over_time({env=\"production\"} | json | drop __error__ [$__auto]))",
+   "covers": [
+    "semantics/json-metric-detected-level-derivation",
+    "severity-detected-level-derivation",
+    "loki_api_v1_query_range"
+   ]
+  },
+  {
+   "id": "explore-DLV5",
+   "kind": "explore",
+   "query": "sum by (detected_level) (count_over_time({env=\"production\"} | json | drop __error__ [$__auto]))",
+   "covers": [
+    "semantics/json-metric-detected-level-derivation",
+    "severity-detected-level-derivation",
+    "loki_api_v1_query_range"
+   ]
+  },
   {
    "id": "explore-B",
    "kind": "explore",

From 02787158154ad3b69b6816729349ab566af59267 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:01:40 +0200
Subject: [PATCH 08/14] perf: the gate leaves out the pair of a dotted key name
 and its last word

The one occurrence of log.level holds the word level, so the pair of level and
log.level admitted every line with that single key and the two-keys regexps ran
over it. A line with both keys holds the word twice and passes the sequence of
level after level; the gate stays a superset of the patterns.
---
 .../proxy/detected_level_keys_gate_test.go    | 21 +++++++++++++++++++
 internal/proxy/ordered_json_metric.go         |  8 +++++++
 2 files changed, 29 insertions(+)

diff --git a/internal/proxy/detected_level_keys_gate_test.go b/internal/proxy/detected_level_keys_gate_test.go
index c69e80fc0..4190366b8 100644
--- a/internal/proxy/detected_level_keys_gate_test.go
+++ b/internal/proxy/detected_level_keys_gate_test.go
@@ -220,6 +220,11 @@ func TestTwiceGateRejectsSingleKeys(t *testing.T) {
 		`{"SEVERITY_TEXT":"info","severity_text":"warn"}`:    true,
 		`{"msg":"xlevel and level2 and severity_texts"}`:     false,
 		`{"level":"info"} {"level":"warn"} \u006cevel=error`: true,
+		`{"log.level":"info"}`:                               false, // one occurrence holds the word level once
+		`{"log.level":"a","log.level":"b"}`:                  true,
+		`{"log.level":"a","level":"b"}`:                      true,
+		`{"level":"a","log.level":"b"}`:                      true,
+		`{"log.level":"a","severity":"b"}`:                   true,
 	} {
 		if got := twiceGateMatches(t, gate, line); got != want {
 			t.Errorf("gate over %q = %v, want %v", line, got, want)
@@ -340,3 +345,19 @@ func TestKeysRiskProbeGatesTheTwoKeyPatterns(t *testing.T) {
 		t.Fatalf("a long selector should send the probe without the gate within %d bytes: %d queries, %d bytes", vlDefaultMaxQueryLen, len(queries), len(queries[0]))
 	}
 }
+
+// The gate leaves out the pair of a dotted name and its last word (the one
+// occurrence of log.level holds the word level), and the lines with both still
+// pass through seq("level","level").
+// conformance: severity-detected-level-derivation
+func TestTwiceGateOmitsTheDottedPair(t *testing.T) {
+	gate := detectedLevelTwiceGate()
+	if strings.Contains(gate, `(_msg:"level" (_msg:"LEVEL" or _msg:"Level" or _msg:"log.level"`) {
+		t.Fatalf("the pair of level and log.level is in the gate: %s", gate)
+	}
+	for _, name := range detectedLevelKeyNames {
+		if name != "log.level" && !strings.Contains(gate, `_msg:"`+name+`"`) && name != detectedLevelKeyNames[0] {
+			t.Errorf("%s is missing from the gate", name)
+		}
+	}
+}
diff --git a/internal/proxy/ordered_json_metric.go b/internal/proxy/ordered_json_metric.go
index 77d11c39e..fca5c58d7 100644
--- a/internal/proxy/ordered_json_metric.go
+++ b/internal/proxy/ordered_json_metric.go
@@ -583,6 +583,11 @@ func logsqlWordPrefilter(words []string) string {
 // "key ... key" matches are such, so the filter is a superset of it, answered
 // from VictoriaLogs' token index and a substring search where the regexp
 // would run over every line that holds one key.
+//
+// A dotted phrase ends in a word that is a phrase of its own (log.level, level):
+// the pair of the two is left out, because the one occurrence of log.level
+// already holds the word level and the pair would admit every line with that
+// single key, while a line with both keys holds the word twice and passes seq.
 func logsqlTwiceFilter(phrases []string) string {
 	var alts []string
 	for i, a := range phrases {
@@ -590,6 +595,9 @@ func logsqlTwiceFilter(phrases []string) string {
 		alts = append(alts, "_msg:seq("+quoted+","+quoted+")")
 		var rest []string
 		for _, b := range phrases[i+1:] {
+			if strings.HasSuffix(a, "."+b) || strings.HasSuffix(b, "."+a) {
+				continue
+			}
 			rest = append(rest, "_msg:"+strconv.Quote(b))
 		}
 		if len(rest) > 0 {

From 88831c1fa72420f872e15cd5df6bba78d0f05bb8 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:01:57 +0200
Subject: [PATCH 09/14] fix: the keys probe is asked again without its gate
 when VictoriaLogs refuses the longer text

An operator may have lowered -search.maxQueryLen below the gated probe, which is
2.5 KB longer than the probe was. VictoriaLogs' 400 for a query that is too long
is told apart from other refusals, and the probe goes out once more without the
gate, the same verdict. The edge of the 16 KiB default is pinned with bases of
exactly the longest that fits and one byte more.
---
 .../proxy/detected_level_keys_gate_test.go    | 84 +++++++++++++++++++
 internal/proxy/ordered_json_metric.go         | 28 +++++--
 2 files changed, 105 insertions(+), 7 deletions(-)

diff --git a/internal/proxy/detected_level_keys_gate_test.go b/internal/proxy/detected_level_keys_gate_test.go
index 4190366b8..0f93f31ba 100644
--- a/internal/proxy/detected_level_keys_gate_test.go
+++ b/internal/proxy/detected_level_keys_gate_test.go
@@ -2,6 +2,7 @@ package proxy
 
 import (
 	"context"
+	"fmt"
 	"math/rand"
 	"net/http"
 	"net/http/httptest"
@@ -361,3 +362,86 @@ func TestTwiceGateOmitsTheDottedPair(t *testing.T) {
 		}
 	}
 }
+
+// The longest base the gated probe fits is exactly vlDefaultMaxQueryLen minus the
+// probe without a base; one byte more gets the probe without the gate.
+// conformance: severity-detected-level-derivation
+func TestKeysRiskProbeGateEdgeOfTheQueryLength(t *testing.T) {
+	overhead := len(detectedLevelKeysQuery("", true))
+	for _, tc := range []struct {
+		extra int
+		gated bool
+	}{{0, true}, {1, false}, {-1, true}} {
+		var got []string
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			_ = r.ParseForm()
+			got = append(got, r.Form.Get("query"))
+		}))
+		p := newSlidingTestProxy(t, srv.URL)
+		base := strings.Repeat("a", vlDefaultMaxQueryLen-overhead+tc.extra)
+		if _, err := p.detectedLevelKeysRisk(context.Background(), base, time.Unix(1700000000, 0), time.Unix(1700003600, 0)); err != nil {
+			t.Fatal(err)
+		}
+		srv.Close()
+		if len(got) != 1 || strings.Contains(got[0], "seq(") == !tc.gated || len(got[0]) > vlDefaultMaxQueryLen {
+			t.Errorf("base of %d bytes (limit %d, gated probe %d without a base): %d queries, gated=%v, lengths %v", len(base), vlDefaultMaxQueryLen, overhead, len(got), tc.gated, queryLengths(got))
+		}
+		if tc.gated && len(got) == 1 && len(got[0]) != vlDefaultMaxQueryLen+tc.extra {
+			t.Errorf("the gated probe is %d bytes, want %d", len(got[0]), vlDefaultMaxQueryLen+tc.extra)
+		}
+	}
+}
+
+func queryLengths(qs []string) []int {
+	out := make([]int, len(qs))
+	for i, q := range qs {
+		out[i] = len(q)
+	}
+	return out
+}
+
+// An operator may have lowered VictoriaLogs' -search.maxQueryLen below the gated
+// probe: it answers 400 for the longer text, and the probe is asked again
+// without the gate, which main's probe is. Any other refusal is returned.
+// conformance: severity-detected-level-derivation
+func TestKeysRiskProbeRetriesWithoutTheGateWhenRefusedAsTooLong(t *testing.T) {
+	for _, tc := range []struct {
+		name    string
+		limit   int
+		refusal string
+		queries int
+		wantErr bool
+	}{
+		{"limit below the gated text", 3000, "the `query` arg length cannot exceed -search.maxQueryLen=%d bytes; the current query length is %d bytes", 2, false},
+		{"limit below both", 1000, "the `query` arg length cannot exceed -search.maxQueryLen=%d bytes; the current query length is %d bytes", 2, true},
+		{"another 400 is not retried", 0, "cannot parse `query` arg: unexpected token", 1, true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			var got []string
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				_ = r.ParseForm()
+				q := r.Form.Get("query")
+				got = append(got, q)
+				if len(q) > tc.limit {
+					http.Error(w, fmtRefusal(tc.refusal, tc.limit, len(q)), http.StatusBadRequest)
+				}
+			}))
+			defer srv.Close()
+			p := newSlidingTestProxy(t, srv.URL)
+			risky, err := p.detectedLevelKeysRisk(context.Background(), `app:="a"`, time.Unix(1700000000, 0), time.Unix(1700003600, 0))
+			if (err != nil) != tc.wantErr || risky || len(got) != tc.queries {
+				t.Fatalf("risky=%v err=%v, %d queries %v", risky, err, len(got), queryLengths(got))
+			}
+			if tc.queries == 2 && (!strings.Contains(got[0], "seq(") || strings.Contains(got[1], "seq(")) {
+				t.Errorf("the first ask should be gated and the retry not")
+			}
+		})
+	}
+}
+
+func fmtRefusal(format string, args ...any) string {
+	if !strings.Contains(format, "%d") {
+		return format
+	}
+	return fmt.Sprintf(format, args...)
+}
diff --git a/internal/proxy/ordered_json_metric.go b/internal/proxy/ordered_json_metric.go
index fca5c58d7..ee438fafc 100644
--- a/internal/proxy/ordered_json_metric.go
+++ b/internal/proxy/ordered_json_metric.go
@@ -2,6 +2,7 @@ package proxy
 
 import (
 	"bufio"
+	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -1648,15 +1649,24 @@ func detectedLevelStoredFilter() string {
 // of every line that holds a level key, which is every line of a body-only
 // window, and only a line with two of them can match.
 func (p *Proxy) detectedLevelKeysRisk(ctx context.Context, base string, start, end time.Time) (bool, error) {
-	query := detectedLevelKeysQuery(base, true)
-	if len(query) > vlDefaultMaxQueryLen {
-		// The gate only narrows what the patterns run on, so a selector too long
-		// for the gated text gets the probe without it: the same verdict.
-		query = detectedLevelKeysQuery(base, false)
+	// The gate only narrows what the patterns run on, so a base too long for the
+	// gated text, or one VictoriaLogs refuses as too long (an operator may have
+	// lowered -search.maxQueryLen), gets the probe without it: the same verdict.
+	if query := detectedLevelKeysQuery(base, true); len(query) <= vlDefaultMaxQueryLen {
+		risky, err := p.statsPushdownRiskExists(ctx, query, start, end)
+		var tooLong *queryTooLongError
+		if !errors.As(err, &tooLong) {
+			return risky, err
+		}
 	}
-	return p.statsPushdownRiskExists(ctx, query, start, end)
+	return p.statsPushdownRiskExists(ctx, detectedLevelKeysQuery(base, false), start, end)
 }
 
+// queryTooLongError is VictoriaLogs' refusal of a query longer than -search.maxQueryLen.
+type queryTooLongError struct{ error }
+
+func (e *queryTooLongError) Unwrap() error { return e.error }
+
 // detectedLevelKeysQuery is the probe of detectedLevelKeysRisk, with the two-keys
 // patterns behind detectedLevelTwiceGate or not.
 func detectedLevelKeysQuery(base string, gated bool) string {
@@ -1829,7 +1839,11 @@ func (p *Proxy) statsPushdownRiskExists(ctx context.Context, query string, start
 	defer resp.Body.Close()
 	if resp.StatusCode >= 400 {
 		body, _ := readBodyLimited(resp.Body, maxUpstreamErrorBodyBytes)
-		return false, p.redactedBackendStatusError("backend returned", resp.StatusCode, body)
+		err := p.redactedBackendStatusError("backend returned", resp.StatusCode, body)
+		if resp.StatusCode == http.StatusBadRequest && bytes.Contains(body, []byte("-search.maxQueryLen")) {
+			err = &queryTooLongError{err}
+		}
+		return false, err
 	}
 	head, err := io.ReadAll(io.LimitReader(resp.Body, 64))
 	if err != nil {

From ff1cded2da829db18d2ca02e7e37ea84f3aa9433 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:01:57 +0200
Subject: [PATCH 10/14] test: the remembered risk verdicts are scoped to the
 base and to the filters

A window found clean for one base, or for one set of filters that reject
unparsed lines, must not clear another base or set in the same tenant and window
that holds a risky line: it goes to the raw-row evaluator with the answer it gets
asked alone. Both scopes were unpinned: a key without the base, or without the
filters, passed every test.
---
 .../proxy/detected_level_cache_scope_test.go  | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 internal/proxy/detected_level_cache_scope_test.go

diff --git a/internal/proxy/detected_level_cache_scope_test.go b/internal/proxy/detected_level_cache_scope_test.go
new file mode 100644
index 000000000..c93b8c1fd
--- /dev/null
+++ b/internal/proxy/detected_level_cache_scope_test.go
@@ -0,0 +1,85 @@
+package proxy
+
+import (
+	"net/http"
+	"reflect"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// scopedRows are lines of one app in one window: clean ones, and the extra rows
+// given (a line, or a line with a stored field).
+func scopedRows(s0 time.Time, app string, extra ...pushdownRow) []pushdownRow {
+	var rows []pushdownRow
+	for i := 0; i < 20; i++ {
+		rows = append(rows, pushdownRow{ts: s0.Add(time.Duration(i+1) * 10 * time.Second), stream: map[string]string{"app": app, "env": "prod"},
+			msg: `{"pipeline":"logs/loki","n":` + strconv.Itoa(i) + `}`})
+	}
+	for i := range extra {
+		extra[i].ts = s0.Add(time.Duration(100+i) * time.Second)
+		extra[i].stream = map[string]string{"app": app, "env": "prod"}
+	}
+	return append(rows, extra...)
+}
+
+// askScoped runs a query on a fresh proxy over rows, after the queries of
+// before (same proxy, same window, same tenant), and returns the answer of the
+// last and whether the raw-row evaluator served it.
+func askScoped(t *testing.T, rows []pushdownRow, end time.Time, before []string, query string) (map[string]map[int64]string, bool) {
+	t.Helper()
+	srv, fake := newPushdownFakeVL(t, rows, nil)
+	fake.presence = true
+	p := newFilterPushdownProxy(t, srv.URL)
+	fake.stored = p.labelTranslator.ToVL
+	for _, q := range append(append([]string(nil), before...), query) {
+		fake.mu.Lock()
+		fake.raw = 0
+		fake.mu.Unlock()
+		if code, got, body := detectedLevelQuery(t, p, q, end, end, time.Minute); code != http.StatusOK {
+			t.Fatalf("status %d %.200s", code, body)
+		} else if q == query {
+			fake.mu.Lock()
+			defer fake.mu.Unlock()
+			return got, fake.raw > 0
+		}
+	}
+	return nil, false
+}
+
+// A verdict that a window holds no risky line is remembered per tenant, query and
+// base. Two bases in one window: the first is clean, the second holds a line the
+// pipes read differently from Loki (two level keys; the grouping has no level
+// label, so only the level probes see it). Asking the clean one first
+// must not clear the second: it goes to the raw-row evaluator, with the answer it
+// gets when it is asked alone.
+// conformance: semantics/json-metric-detected-level-derivation
+func TestRiskVerdictOfOneBaseDoesNotClearAnother(t *testing.T) {
+	s0 := time.Unix(1700000400, 0).UTC()
+	end := s0.Add(6 * time.Minute)
+	rows := append(scopedRows(s0, "api"), scopedRows(s0, "web", pushdownRow{msg: `{"level":"info","level":"warn"}`})...)
+	const clean = `sum by (detected_level) (count_over_time({app="api"} | json | drop __error__ [5m]))`
+	const risky = `sum by (detected_level) (count_over_time({app="web"} | json | drop __error__ [5m]))`
+	alone, aloneRaw := askScoped(t, rows, end, nil, risky)
+	after, afterRaw := askScoped(t, rows, end, []string{clean}, risky)
+	if !aloneRaw || !afterRaw || !reflect.DeepEqual(alone, after) {
+		t.Fatalf("risky base asked alone: raw=%v %v; after the clean base: raw=%v %v", aloneRaw, alone, afterRaw, after)
+	}
+}
+
+// The same for the filters that reject unparsed lines: a window is clean for a
+// filter on pipeline and risky for one on service_version (a row stores
+// service.version while its body has no such key), over the same fields.
+// conformance: semantics/json-metric-detected-level-derivation
+func TestRiskVerdictOfOneFilterDoesNotClearAnother(t *testing.T) {
+	s0 := time.Unix(1700000400, 0).UTC()
+	end := s0.Add(6 * time.Minute)
+	rows := scopedRows(s0, "api", pushdownRow{msg: `{"pipeline":"logs/loki"}`, vl: map[string]string{"service.version": "0.95.0"}, loki: map[string]string{"service_version": "0.95.0"}})
+	const clean = `sum by (pipeline, service_version) (count_over_time({app="api"} | json | pipeline!="" [5m]))`
+	const risky = `sum by (pipeline, service_version) (count_over_time({app="api"} | json | service_version!="" [5m]))`
+	alone, aloneRaw := askScoped(t, rows, end, nil, risky)
+	after, afterRaw := askScoped(t, rows, end, []string{clean}, risky)
+	if !aloneRaw || !afterRaw || !reflect.DeepEqual(alone, after) {
+		t.Fatalf("risky filter asked alone: raw=%v %v; after the clean one: raw=%v %v", aloneRaw, alone, afterRaw, after)
+	}
+}

From dce2cb127281b0b74400e22740426fd33bfb9d14 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:02:12 +0200
Subject: [PATCH 11/14] test: a script that measures the first view of a
 window, the builds started fresh before each request

---
 bench/ab/README.md          |  16 ++
 bench/ab/cold_first_view.py | 360 ++++++++++++++++++++++++++++++++++++
 2 files changed, 376 insertions(+)
 create mode 100644 bench/ab/cold_first_view.py

diff --git a/bench/ab/README.md b/bench/ab/README.md
index 464498b08..d52fb296c 100644
--- a/bench/ab/README.md
+++ b/bench/ab/README.md
@@ -98,6 +98,22 @@ python3 bench/ab/pr_smoke.py --base origin/main --no-level-label --out /tmp/ab-b
 (`stack.py seed --no-level-label` does the same for a hand-run stack; the
 generator option is `LOG_NO_LEVEL_LABEL=1`.)
 
+### The first view of a window
+
+A proxy remembers what it learned about a window (which level fields and keys it
+holds, that no line needs the slower path), so a warm run does not measure the
+first request after a restart, which is what a dashboard opened after a deploy or
+a new time range costs. `cold_first_view.py` measures it: a stack seeded with rows
+that have no stored level (the data the detected_level pipes read), VictoriaLogs
+capped at 2 CPUs, and every build started fresh before each request.
+`cold_first_view.py cold --build before=054d1706 --build main=d12a062c --build
+head=HEAD --runs 1h=7,24h=5 --out <dir>` writes `coldrestart.json`: wall time and
+VictoriaLogs' cgroup CPU (Docker's container stats) of every sample, the builds
+interleaved round by round, and the medians; `probes` mode writes `probes.json`:
+the requests one first view sends to VictoriaLogs and what each costs when replayed.
+The results of a run are committed as `results/oneoff/<date>-<name>-coldrestart.json`
+and `-probes.json`.
+
 ## Reading the results
 
 - Timings are warm p50 over the runs after the first; the first run is kept as
diff --git a/bench/ab/cold_first_view.py b/bench/ab/cold_first_view.py
new file mode 100644
index 000000000..98e61f971
--- /dev/null
+++ b/bench/ab/cold_first_view.py
@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""The first view of a window, builds side by side: wall time and VictoriaLogs CPU of the very first
+query of a shape on a freshly started proxy, and what each VictoriaLogs request of that view costs.
+
+A proxy remembers what it learned about a window (which level fields and keys it holds, that no line
+needs the slower path), so the first view is not what a warm run measures. This starts every build
+fresh before each request, on a stack seeded with rows that have no stored level (the level only in
+the line, the data the detected_level pipes read) and VictoriaLogs capped at 2 CPUs, and records
+every sample:
+
+  python3 bench/ab/cold_first_view.py cold --out /tmp/cold \\
+      --build before=054d1706 --build main=d12a062c --build head=HEAD --runs 1h=7,24h=5
+
+writes /tmp/cold/coldrestart.json: per build, shape and range the wall time of the query and the
+CPU time VictoriaLogs' cgroup spent during it (Docker's container stats), one entry per sample, and
+the medians. Builds are interleaved round by round.
+
+  python3 bench/ab/cold_first_view.py probes --out /tmp/cold --build main=d12a062c --build head=HEAD
+
+writes /tmp/cold/probes.json: the requests each build sent to VictoriaLogs for one first view of the
+1h window (a recording forwarder sits between proxy and VictoriaLogs), each replayed --replays times
+on windows shifted by a minute each, with wall time and CPU per replay. Both commands start their own
+compose project (--project, --vl-port) and remove it; they need Docker, git and go.
+"""
+import argparse
+import concurrent.futures
+import datetime
+import http.client
+import http.server
+import json
+import os
+import socket
+import statistics
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import stack  # noqa: E402
+
+SERVICE = "loki-vl-proxy-underscore"
+SELECTOR = '{env="production"}'
+SHAPES = {
+    "D": f"sum by (level, detected_level) (count_over_time({SELECTOR} | json | drop __error__ [1m]))",
+    "DLV5": f"sum by (detected_level) (count_over_time({SELECTOR} | json | drop __error__ [1m]))",
+}
+RANGES = {"1h": 3600, "24h": 86400}
+STEP = 15
+WARM = f"{SELECTOR}"  # a trivial query: warms the label caches only
+
+
+class UnixConnection(http.client.HTTPConnection):
+    def __init__(self, path):
+        super().__init__("localhost")
+        self.path = path
+
+    def connect(self):
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.sock.connect(self.path)
+
+
+def docker_socket():
+    host = os.environ.get("DOCKER_HOST") or subprocess.check_output(
+        ["docker", "context", "inspect", "--format", "{{.Endpoints.docker.Host}}"], text=True).strip()
+    if not host.startswith("unix://"):
+        raise SystemExit(f"cpu sampling reads Docker's stats over a unix socket; the endpoint is {host}")
+    return host[len("unix://"):]
+
+
+class CPU:
+    """Cumulative CPU time of a container (cgroup usage, as Docker reports it), in milliseconds."""
+
+    def __init__(self, container):
+        self.sock = docker_socket()
+        self.id = subprocess.check_output(["docker", "inspect", container, "--format", "{{.Id}}"], text=True).strip()
+
+    def ms(self):
+        c = UnixConnection(self.sock)
+        c.request("GET", f"/containers/{self.id}/stats?stream=false&one-shot=true")
+        data = json.loads(c.getresponse().read())
+        c.close()
+        return data["cpu_stats"]["cpu_usage"]["total_usage"] / 1e6
+
+
+class Tap(http.server.ThreadingHTTPServer):
+    """Forwards to VictoriaLogs and records every request (path, form fields, start, duration)."""
+
+    daemon_threads = True
+
+    def __init__(self, vl):
+        tap = self
+        self.vl, self.log, self.lock = vl, [], threading.Lock()
+
+        class H(http.server.BaseHTTPRequestHandler):
+            protocol_version = "HTTP/1.0"
+
+            def do_POST(self):
+                body = self.rfile.read(int(self.headers.get("Content-Length") or 0))
+                t0 = time.time()
+                req = urllib.request.Request(tap.vl + self.path, data=body, method="POST",
+                                             headers={k: v for k, v in self.headers.items() if k.lower() not in ("host", "accept-encoding")})
+                try:
+                    r = urllib.request.urlopen(req, timeout=300)
+                    status, data, ctype = r.status, r.read(), r.headers.get("Content-Type")
+                except urllib.error.HTTPError as e:
+                    status, data, ctype = e.code, e.read(), e.headers.get("Content-Type")
+                form = {k: v[0] for k, v in urllib.parse.parse_qs(body.decode()).items()}
+                with tap.lock:
+                    tap.log.append({"path": self.path.split("?")[0], "form": form, "t": t0, "ms": (time.time() - t0) * 1000})
+                self.send_response(status)
+                if ctype:
+                    self.send_header("Content-Type", ctype)
+                self.send_header("Content-Length", str(len(data)))
+                self.end_headers()
+                self.wfile.write(data)
+
+            do_GET = do_POST
+
+            def log_message(self, *a):
+                pass
+
+        super().__init__(("127.0.0.1", 0), H)
+        threading.Thread(target=self.serve_forever, daemon=True).start()
+
+    @property
+    def url(self):
+        return f"http://127.0.0.1:{self.server_address[1]}"
+
+
+class Sink(http.server.BaseHTTPRequestHandler):
+    """Stands in for Loki while the generator seeds VictoriaLogs only."""
+
+    def do_GET(self):
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"ready")
+
+    def do_POST(self):
+        self.rfile.read(int(self.headers.get("Content-Length") or 0))
+        self.send_response(204)
+        self.end_headers()
+
+    def log_message(self, *a):
+        pass
+
+
+def seed_vl_only(st, seconds, end):
+    sink = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Sink)
+    threading.Thread(target=sink.serve_forever, daemon=True).start()
+    env = dict(os.environ, LOKI_URL=f"http://127.0.0.1:{sink.server_address[1]}", VL_URL=st.vl, LOG_BATCH=str(stack.BACKFILL_BATCH),
+               LOG_BACKFILL_SECONDS=str(seconds), LOG_BACKFILL_INTERVAL=str(stack.BACKFILL_INTERVAL),
+               LOG_BACKFILL_END=str(end), LOG_BACKFILL_ONLY="1", LOG_BACKFILL_SEED=str(end), LOG_NO_LEVEL_LABEL="1")
+    subprocess.run([sys.executable, stack.GENERATOR], cwd=stack.ROOT, env=env, check=True, stdout=sys.stderr)
+    time.sleep(5)
+    sink.shutdown()
+
+
+def parse_builds(specs):
+    out = []
+    for s in specs:
+        name, _, ref = s.partition("=")
+        if not name or not ref:
+            raise SystemExit(f"--build wants name=ref, got {s!r}")
+        out.append((name, ref))
+    return out
+
+
+def query(proxy_url, q, end, rng):
+    params = {"query": q, "start": end - rng, "end": end, "step": STEP}
+    req = urllib.request.Request(proxy_url + "/loki/api/v1/query_range?" + urllib.parse.urlencode(params), headers={"X-Scope-OrgID": "0"})
+    t0 = time.time()
+    try:
+        with urllib.request.urlopen(req, timeout=600) as r:
+            status = r.status
+            r.read()
+    except urllib.error.HTTPError as e:
+        status = e.code
+    return status, (time.time() - t0) * 1000
+
+
+class Run:
+    def __init__(self, args):
+        self.args = args
+        self.out = os.path.abspath(args.out)
+        os.makedirs(self.out, exist_ok=True)
+        self.st = stack.Stack(args.project, args.loki_port, args.vl_port, args.loki_mem or None, args.vl_mem or None, no_level_label=True)
+        self.builds = parse_builds(args.build)
+        self.trees, self.proxies, self.tap = [], {}, None
+
+    def setup(self):
+        a = self.args
+        self.st.up()
+        subprocess.run(["docker", "update", "--cpus", str(a.vl_cpus), self.st.vl_container], check=True, stdout=subprocess.DEVNULL)
+        # data ends well in the past: the part of a window younger than five minutes is probed again
+        # by every request and would blur a first view
+        self.end = int(time.time()) // 60 * 60 - 600
+        seconds = int(a.hours * 3600)
+        jobs = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=len(self.builds) + 1) as pool:
+            seeding = pool.submit(seed_vl_only, self.st, seconds, self.end)
+            for name, ref in self.builds:
+                binary = os.path.join(self.out, f"proxy-{name}")
+                jobs.append((name, pool.submit(stack.build, ref if ref != "WORKTREE" else None, binary), binary))
+            for name, fut, binary in jobs:
+                self.trees.append((name, fut.result(), binary))
+            seeding.result()
+        stack.log(f"seeded {seconds}s ending {self.end}")
+        self.sha = {name: subprocess.check_output(["git", "rev-parse", ref], cwd=stack.ROOT, text=True).strip() for name, ref in self.builds}
+
+    def start(self, name, backend):
+        tree, binary = next((t, b) for n, t, b in self.trees if n == name)
+        self.stop(name)
+        work = os.path.join(self.out, f"work-{name}")
+        os.makedirs(work, exist_ok=True)
+        cmd, env = stack.proxy_command(tree, SERVICE, self.args.proxy_port, backend, work)
+        p = stack.Proxy(name, binary, cmd, env, self.args.proxy_port, self.out)
+        p.start()
+        self.proxies[name] = p
+        return p
+
+    def stop(self, name):
+        p = self.proxies.pop(name, None)
+        if p:
+            p.stop()
+
+    def teardown(self):
+        for name in list(self.proxies):
+            self.stop(name)
+        for _, tree, _ in self.trees:
+            stack.remove_tree(tree)
+        try:
+            self.st.down()
+        except Exception as e:  # noqa: BLE001
+            stack.log(f"down failed: {e}")
+
+    def cold(self):
+        a = self.args
+        runs = {k: int(v) for k, v in (x.split("=") for x in a.runs.split(","))}
+        cpu = CPU(self.st.vl_container)
+        samples = []
+        restarts0 = self.st.restart_count()
+        for rng_name, n in runs.items():
+            for shape, q in SHAPES.items():
+                for rnd in range(n):
+                    for name, _ in self.builds:
+                        p = self.start(name, self.st.vl)
+                        query(p.url, WARM, self.end, 60)
+                        c0 = cpu.ms()
+                        status, wall = query(p.url, q, self.end, RANGES[rng_name])
+                        c1 = cpu.ms()
+                        samples.append({"build": name, "shape": shape, "range": rng_name, "round": rnd, "status": status,
+                                        "wall_ms": round(wall, 1), "cpu_ms": round(c1 - c0, 1)})
+                        stack.log(f"{name} {shape} {rng_name} #{rnd}: {wall:.0f} ms, {c1 - c0:.0f} CPU-ms")
+                        self.stop(name)
+        summary = []
+        for rng_name in runs:
+            for shape in SHAPES:
+                for name, _ in self.builds:
+                    s = [x for x in samples if (x["build"], x["shape"], x["range"]) == (name, shape, rng_name)]
+                    w, c = [x["wall_ms"] for x in s], [x["cpu_ms"] for x in s]
+                    summary.append({"build": name, "shape": shape, "range": rng_name, "n": len(s),
+                                    "wall_ms": {"median": round(statistics.median(w), 1), "min": min(w), "max": max(w)},
+                                    "cpu_ms": {"median": round(statistics.median(c), 1), "min": min(c), "max": max(c)}})
+        self.write("coldrestart.json", {"samples": samples, "summary": summary, "vl_restarts": [restarts0, self.st.restart_count()]})
+
+    def classify(self, form):
+        q = form.get("query", "")
+        if " as p0, " in q:
+            return "presence"
+        if q.endswith('filter _stream:{detected_level=~".+"} | limit 1'):
+            return "stream guard"
+        if q.endswith("limit 1"):
+            if "__lr_" in q:
+                return "unpack probe"
+            return "partial-parse probe" if "unpack_json fields" in q else "keys probe"
+        if "copy detected_level as __dl_d" in q:
+            return "stored-level query"
+        return "chain" if "__dl" in q else "other"
+
+    def shifted(self, form, minutes):
+        out = dict(form)
+        for k in ("start", "end"):
+            if k in out:
+                t = datetime.datetime.fromisoformat(out[k].replace("Z", "+00:00")) - datetime.timedelta(minutes=minutes)
+                out[k] = t.astimezone(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f").rstrip("0").rstrip(".") + "Z"
+        return out
+
+    def probes(self):
+        a = self.args
+        cpu = CPU(self.st.vl_container)
+        self.tap = Tap(self.st.vl)
+        result = {}
+        for name, _ in self.builds:
+            self.tap.log.clear()
+            p = self.start(name, self.tap.url)
+            query(p.url, WARM, self.end, 60)
+            self.tap.log.clear()
+            query(p.url, SHAPES["D"], self.end, RANGES["1h"])
+            seen = {}
+            for rec in sorted(self.tap.log, key=lambda r: r["t"]):
+                if rec["path"].endswith(("stream_field_names", "stream_field_values", "field_names")):
+                    continue
+                kind = self.classify(rec["form"])
+                seen.setdefault(kind, {"requests": 0, "first": rec})["requests"] += 1
+            self.stop(name)
+            kinds = {}
+            for kind, info in seen.items():
+                rec = info["first"]
+                reps = []
+                for phase in ("warm", "measured"):
+                    for i in range(a.replays):
+                        form = self.shifted(rec["form"], i)
+                        data = urllib.parse.urlencode(form).encode()
+                        c0, t0 = cpu.ms(), time.time()
+                        urllib.request.urlopen(urllib.request.Request(self.st.vl + rec["path"], data=data), timeout=300).read()
+                        if phase == "measured":
+                            reps.append({"wall_ms": round((time.time() - t0) * 1000, 1), "cpu_ms": round(cpu.ms() - c0, 1)})
+                kinds[kind] = {"requests_in_a_first_view": info["requests"], "query_bytes": len(rec["form"]["query"]),
+                               "wall_ms_median": round(statistics.median(r["wall_ms"] for r in reps), 1),
+                               "cpu_ms_median": round(statistics.median(r["cpu_ms"] for r in reps), 1), "replays": reps}
+            result[name] = kinds
+        self.write("probes.json", {"shape": "D", "range": "1h", "builds": result})
+
+    def write(self, name, body):
+        doc = {"command": [os.path.basename(sys.argv[0])] + sys.argv[1:], "date": time.strftime("%Y-%m-%d"),
+               "vl_cpus": self.args.vl_cpus, "data": {"hours": self.args.hours, "end": self.end, "rows_without_stored_level": True},
+               "builds": self.sha, **body}
+        with open(os.path.join(self.out, name), "w") as f:
+            json.dump(doc, f, indent=1)
+            f.write("\n")
+        stack.log(f"wrote {os.path.join(self.out, name)}")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("cmd", choices=["cold", "probes"])
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--build", action="append", required=True, help="name=git ref (HEAD for the checked-out commit); repeatable")
+    ap.add_argument("--runs", default="1h=7,24h=5", help="cold: samples per range")
+    ap.add_argument("--replays", type=int, default=10, help="probes: replays per request")
+    ap.add_argument("--hours", type=float, default=25, help="hours of data to seed")
+    ap.add_argument("--vl-cpus", type=float, default=2)
+    ap.add_argument("--proxy-port", type=int, default=27190)
+    stack.stack_args(ap)
+    args = ap.parse_args()
+    run = Run(args)
+    try:
+        run.setup()
+        run.cold() if args.cmd == "cold" else run.probes()
+    finally:
+        run.teardown()
+
+
+if __name__ == "__main__":
+    main()

From 1887016f5d18b19446f1979f1016484af1525e6e Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:04:29 +0200
Subject: [PATCH 12/14] test: the first-view script records its command without
 the output directory

---
 bench/ab/cold_first_view.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/bench/ab/cold_first_view.py b/bench/ab/cold_first_view.py
index 98e61f971..8ecb8a0b5 100644
--- a/bench/ab/cold_first_view.py
+++ b/bench/ab/cold_first_view.py
@@ -327,7 +327,9 @@ def probes(self):
         self.write("probes.json", {"shape": "D", "range": "1h", "builds": result})
 
     def write(self, name, body):
-        doc = {"command": [os.path.basename(sys.argv[0])] + sys.argv[1:], "date": time.strftime("%Y-%m-%d"),
+        argv = sys.argv[1:]
+        argv = [("<dir>" if argv[i - 1] == "--out" else a) for i, a in enumerate(argv)]
+        doc = {"command": ["bench/ab/" + os.path.basename(sys.argv[0])] + argv, "date": time.strftime("%Y-%m-%d"),
                "vl_cpus": self.args.vl_cpus, "data": {"hours": self.args.hours, "end": self.end, "rows_without_stored_level": True},
                "builds": self.sha, **body}
         with open(os.path.join(self.out, name), "w") as f:

From 28f86e65f034871efc883fd256c22418ef7e2a76 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:15:11 +0200
Subject: [PATCH 13/14] test: the first view of a window, every sample: main
 before #760, main and this branch started fresh before each request

---
 .../2026-10-16-dlfirstview-coldrestart.json   | 886 ++++++++++++++++++
 .../oneoff/2026-10-16-dlfirstview-probes.json | 709 ++++++++++++++
 2 files changed, 1595 insertions(+)
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-coldrestart.json
 create mode 100644 bench/ab/results/oneoff/2026-10-16-dlfirstview-probes.json

diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-coldrestart.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-coldrestart.json
new file mode 100644
index 000000000..e4af76f2d
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-coldrestart.json
@@ -0,0 +1,886 @@
+{
+ "command": [
+  "bench/ab/cold_first_view.py",
+  "cold",
+  "--out",
+  "<dir>",
+  "--project",
+  "dlcold",
+  "--loki-port",
+  "27601",
+  "--vl-port",
+  "27628",
+  "--loki-mem",
+  "3g",
+  "--vl-mem",
+  "4g",
+  "--build",
+  "before=054d1706",
+  "--build",
+  "main=d12a062c",
+  "--build",
+  "head=HEAD",
+  "--runs",
+  "1h=7,24h=5"
+ ],
+ "date": "2026-10-17",
+ "vl_cpus": 2,
+ "data": {
+  "hours": 25,
+  "end": 1792194900,
+  "rows_without_stored_level": true
+ },
+ "builds": {
+  "before": "054d17067ea5b2460cc11e2ca024d06599060aa9",
+  "main": "d12a062c75322fdc6faa3be3107e8ed37d77971a",
+  "head": "1887016f5d18b19446f1979f1016484af1525e6e"
+ },
+ "samples": [
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 174.6,
+   "cpu_ms": 394.6
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 520.8,
+   "cpu_ms": 1122.1
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 318.8,
+   "cpu_ms": 775.7
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 106.8,
+   "cpu_ms": 303.9
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 501.5,
+   "cpu_ms": 1095.9
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 317.0,
+   "cpu_ms": 744.1
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 106.0,
+   "cpu_ms": 303.8
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 525.8,
+   "cpu_ms": 1142.3
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 398.4,
+   "cpu_ms": 820.2
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 118.6,
+   "cpu_ms": 350.8
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 439.3,
+   "cpu_ms": 1082.2
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 319.3,
+   "cpu_ms": 736.9
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 124.4,
+   "cpu_ms": 324.2
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 498.8,
+   "cpu_ms": 1096.1
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 322.0,
+   "cpu_ms": 728.6
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 5,
+   "status": 200,
+   "wall_ms": 115.4,
+   "cpu_ms": 377.1
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 5,
+   "status": 200,
+   "wall_ms": 498.0,
+   "cpu_ms": 1087.4
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 5,
+   "status": 200,
+   "wall_ms": 314.2,
+   "cpu_ms": 725.5
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "round": 6,
+   "status": 200,
+   "wall_ms": 118.9,
+   "cpu_ms": 344.6
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "round": 6,
+   "status": 200,
+   "wall_ms": 503.8,
+   "cpu_ms": 1085.1
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "round": 6,
+   "status": 200,
+   "wall_ms": 413.5,
+   "cpu_ms": 941.8
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 108.5,
+   "cpu_ms": 313.3
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 418.5,
+   "cpu_ms": 952.6
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 218.3,
+   "cpu_ms": 512.4
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 213.8,
+   "cpu_ms": 566.1
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 318.5,
+   "cpu_ms": 769.4
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 285.2,
+   "cpu_ms": 510.6
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 124.6,
+   "cpu_ms": 329.0
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 306.7,
+   "cpu_ms": 782.5
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 193.7,
+   "cpu_ms": 491.7
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 118.8,
+   "cpu_ms": 347.8
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 402.8,
+   "cpu_ms": 869.6
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 204.5,
+   "cpu_ms": 495.1
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 114.6,
+   "cpu_ms": 314.3
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 328.4,
+   "cpu_ms": 794.9
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 291.2,
+   "cpu_ms": 583.5
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 5,
+   "status": 200,
+   "wall_ms": 192.3,
+   "cpu_ms": 348.8
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 5,
+   "status": 200,
+   "wall_ms": 425.3,
+   "cpu_ms": 955.7
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 5,
+   "status": 200,
+   "wall_ms": 190.1,
+   "cpu_ms": 535.1
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 6,
+   "status": 200,
+   "wall_ms": 181.7,
+   "cpu_ms": 398.5
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 6,
+   "status": 200,
+   "wall_ms": 501.2,
+   "cpu_ms": 1079.7
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "round": 6,
+   "status": 200,
+   "wall_ms": 227.6,
+   "cpu_ms": 568.5
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "24h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 2916.5,
+   "cpu_ms": 5892.6
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "24h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 11726.3,
+   "cpu_ms": 23574.4
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "24h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 7760.8,
+   "cpu_ms": 15677.3
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "24h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 2956.5,
+   "cpu_ms": 6010.0
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "24h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 11601.8,
+   "cpu_ms": 23222.7
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "24h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 7727.8,
+   "cpu_ms": 15392.0
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "24h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 3040.4,
+   "cpu_ms": 6235.5
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "24h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 11693.9,
+   "cpu_ms": 23474.7
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "24h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 8007.6,
+   "cpu_ms": 16166.1
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "24h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 2989.8,
+   "cpu_ms": 6133.8
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "24h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 11742.6,
+   "cpu_ms": 23616.8
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "24h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 7812.4,
+   "cpu_ms": 15676.7
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "24h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 2988.5,
+   "cpu_ms": 6023.0
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "24h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 11599.1,
+   "cpu_ms": 23398.8
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "24h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 7797.1,
+   "cpu_ms": 15769.0
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 3080.6,
+   "cpu_ms": 6270.8
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 8284.8,
+   "cpu_ms": 16749.6
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 0,
+   "status": 200,
+   "wall_ms": 5148.9,
+   "cpu_ms": 10397.6
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 2908.3,
+   "cpu_ms": 5888.5
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 8299.8,
+   "cpu_ms": 16683.7
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 1,
+   "status": 200,
+   "wall_ms": 5092.0,
+   "cpu_ms": 10155.8
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 2803.0,
+   "cpu_ms": 5689.1
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 8529.9,
+   "cpu_ms": 17008.0
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 2,
+   "status": 200,
+   "wall_ms": 4822.0,
+   "cpu_ms": 9748.1
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 3109.4,
+   "cpu_ms": 6269.3
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 8195.8,
+   "cpu_ms": 16464.5
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 3,
+   "status": 200,
+   "wall_ms": 4677.0,
+   "cpu_ms": 9575.3
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 2988.4,
+   "cpu_ms": 6098.5
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 8302.4,
+   "cpu_ms": 16691.5
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "24h",
+   "round": 4,
+   "status": 200,
+   "wall_ms": 4902.5,
+   "cpu_ms": 9952.8
+  }
+ ],
+ "summary": [
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "1h",
+   "n": 7,
+   "wall_ms": {
+    "median": 118.6,
+    "min": 106.0,
+    "max": 174.6
+   },
+   "cpu_ms": {
+    "median": 344.6,
+    "min": 303.8,
+    "max": 394.6
+   }
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "1h",
+   "n": 7,
+   "wall_ms": {
+    "median": 501.5,
+    "min": 439.3,
+    "max": 525.8
+   },
+   "cpu_ms": {
+    "median": 1095.9,
+    "min": 1082.2,
+    "max": 1142.3
+   }
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "1h",
+   "n": 7,
+   "wall_ms": {
+    "median": 319.3,
+    "min": 314.2,
+    "max": 413.5
+   },
+   "cpu_ms": {
+    "median": 744.1,
+    "min": 725.5,
+    "max": 941.8
+   }
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "1h",
+   "n": 7,
+   "wall_ms": {
+    "median": 124.6,
+    "min": 108.5,
+    "max": 213.8
+   },
+   "cpu_ms": {
+    "median": 347.8,
+    "min": 313.3,
+    "max": 566.1
+   }
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "1h",
+   "n": 7,
+   "wall_ms": {
+    "median": 402.8,
+    "min": 306.7,
+    "max": 501.2
+   },
+   "cpu_ms": {
+    "median": 869.6,
+    "min": 769.4,
+    "max": 1079.7
+   }
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "1h",
+   "n": 7,
+   "wall_ms": {
+    "median": 218.3,
+    "min": 190.1,
+    "max": 291.2
+   },
+   "cpu_ms": {
+    "median": 512.4,
+    "min": 491.7,
+    "max": 583.5
+   }
+  },
+  {
+   "build": "before",
+   "shape": "D",
+   "range": "24h",
+   "n": 5,
+   "wall_ms": {
+    "median": 2988.5,
+    "min": 2916.5,
+    "max": 3040.4
+   },
+   "cpu_ms": {
+    "median": 6023.0,
+    "min": 5892.6,
+    "max": 6235.5
+   }
+  },
+  {
+   "build": "main",
+   "shape": "D",
+   "range": "24h",
+   "n": 5,
+   "wall_ms": {
+    "median": 11693.9,
+    "min": 11599.1,
+    "max": 11742.6
+   },
+   "cpu_ms": {
+    "median": 23474.7,
+    "min": 23222.7,
+    "max": 23616.8
+   }
+  },
+  {
+   "build": "head",
+   "shape": "D",
+   "range": "24h",
+   "n": 5,
+   "wall_ms": {
+    "median": 7797.1,
+    "min": 7727.8,
+    "max": 8007.6
+   },
+   "cpu_ms": {
+    "median": 15677.3,
+    "min": 15392.0,
+    "max": 16166.1
+   }
+  },
+  {
+   "build": "before",
+   "shape": "DLV5",
+   "range": "24h",
+   "n": 5,
+   "wall_ms": {
+    "median": 2988.4,
+    "min": 2803.0,
+    "max": 3109.4
+   },
+   "cpu_ms": {
+    "median": 6098.5,
+    "min": 5689.1,
+    "max": 6270.8
+   }
+  },
+  {
+   "build": "main",
+   "shape": "DLV5",
+   "range": "24h",
+   "n": 5,
+   "wall_ms": {
+    "median": 8299.8,
+    "min": 8195.8,
+    "max": 8529.9
+   },
+   "cpu_ms": {
+    "median": 16691.5,
+    "min": 16464.5,
+    "max": 17008.0
+   }
+  },
+  {
+   "build": "head",
+   "shape": "DLV5",
+   "range": "24h",
+   "n": 5,
+   "wall_ms": {
+    "median": 4902.5,
+    "min": 4677.0,
+    "max": 5148.9
+   },
+   "cpu_ms": {
+    "median": 9952.8,
+    "min": 9575.3,
+    "max": 10397.6
+   }
+  }
+ ],
+ "vl_restarts": [
+  0,
+  0
+ ]
+}
diff --git a/bench/ab/results/oneoff/2026-10-16-dlfirstview-probes.json b/bench/ab/results/oneoff/2026-10-16-dlfirstview-probes.json
new file mode 100644
index 000000000..88c708d1b
--- /dev/null
+++ b/bench/ab/results/oneoff/2026-10-16-dlfirstview-probes.json
@@ -0,0 +1,709 @@
+{
+ "command": [
+  "bench/ab/cold_first_view.py",
+  "probes",
+  "--out",
+  "<dir>",
+  "--project",
+  "dlcold",
+  "--loki-port",
+  "27601",
+  "--vl-port",
+  "27628",
+  "--loki-mem",
+  "3g",
+  "--vl-mem",
+  "4g",
+  "--build",
+  "main=d12a062c",
+  "--build",
+  "head=HEAD"
+ ],
+ "date": "2026-10-17",
+ "vl_cpus": 2,
+ "data": {
+  "hours": 25,
+  "end": 1792195320,
+  "rows_without_stored_level": true
+ },
+ "builds": {
+  "main": {
+   "stored-level query": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 164,
+    "wall_ms_median": 98.8,
+    "cpu_ms_median": 220.6,
+    "replays": [
+     {
+      "wall_ms": 184.7,
+      "cpu_ms": 219.4
+     },
+     {
+      "wall_ms": 91.9,
+      "cpu_ms": 232.8
+     },
+     {
+      "wall_ms": 101.0,
+      "cpu_ms": 206.7
+     },
+     {
+      "wall_ms": 97.5,
+      "cpu_ms": 218.9
+     },
+     {
+      "wall_ms": 98.5,
+      "cpu_ms": 222.2
+     },
+     {
+      "wall_ms": 99.1,
+      "cpu_ms": 221.8
+     },
+     {
+      "wall_ms": 104.5,
+      "cpu_ms": 239.2
+     },
+     {
+      "wall_ms": 97.9,
+      "cpu_ms": 226.3
+     },
+     {
+      "wall_ms": 104.1,
+      "cpu_ms": 205.1
+     },
+     {
+      "wall_ms": 97.8,
+      "cpu_ms": 203.5
+     }
+    ]
+   },
+   "partial-parse probe": {
+    "requests_in_a_first_view": 2,
+    "query_bytes": 753,
+    "wall_ms_median": 23.1,
+    "cpu_ms_median": 55.9,
+    "replays": [
+     {
+      "wall_ms": 47.9,
+      "cpu_ms": 54.6
+     },
+     {
+      "wall_ms": 22.8,
+      "cpu_ms": 56.9
+     },
+     {
+      "wall_ms": 23.5,
+      "cpu_ms": 59.8
+     },
+     {
+      "wall_ms": 22.7,
+      "cpu_ms": 56.1
+     },
+     {
+      "wall_ms": 24.4,
+      "cpu_ms": 53.6
+     },
+     {
+      "wall_ms": 22.1,
+      "cpu_ms": 55.7
+     },
+     {
+      "wall_ms": 23.0,
+      "cpu_ms": 56.3
+     },
+     {
+      "wall_ms": 22.4,
+      "cpu_ms": 55.5
+     },
+     {
+      "wall_ms": 36.2,
+      "cpu_ms": 55.6
+     },
+     {
+      "wall_ms": 23.2,
+      "cpu_ms": 56.4
+     }
+    ]
+   },
+   "unpack probe": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 1566,
+    "wall_ms_median": 6.0,
+    "cpu_ms_median": 33.9,
+    "replays": [
+     {
+      "wall_ms": 6.1,
+      "cpu_ms": 35.7
+     },
+     {
+      "wall_ms": 5.9,
+      "cpu_ms": 33.5
+     },
+     {
+      "wall_ms": 5.9,
+      "cpu_ms": 34.2
+     },
+     {
+      "wall_ms": 5.9,
+      "cpu_ms": 32.3
+     },
+     {
+      "wall_ms": 60.5,
+      "cpu_ms": 31.3
+     },
+     {
+      "wall_ms": 6.6,
+      "cpu_ms": 38.0
+     },
+     {
+      "wall_ms": 6.1,
+      "cpu_ms": 36.5
+     },
+     {
+      "wall_ms": 6.1,
+      "cpu_ms": 34.5
+     },
+     {
+      "wall_ms": 5.8,
+      "cpu_ms": 32.1
+     },
+     {
+      "wall_ms": 5.9,
+      "cpu_ms": 32.0
+     }
+    ]
+   },
+   "stream guard": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 67,
+    "wall_ms_median": 0.6,
+    "cpu_ms_median": 0.2,
+    "replays": [
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     }
+    ]
+   },
+   "keys probe": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 2040,
+    "wall_ms_median": 184.8,
+    "cpu_ms_median": 325.2,
+    "replays": [
+     {
+      "wall_ms": 179.6,
+      "cpu_ms": 304.9
+     },
+     {
+      "wall_ms": 111.0,
+      "cpu_ms": 320.4
+     },
+     {
+      "wall_ms": 189.5,
+      "cpu_ms": 350.6
+     },
+     {
+      "wall_ms": 190.3,
+      "cpu_ms": 355.3
+     },
+     {
+      "wall_ms": 187.4,
+      "cpu_ms": 337.1
+     },
+     {
+      "wall_ms": 116.5,
+      "cpu_ms": 325.4
+     },
+     {
+      "wall_ms": 187.7,
+      "cpu_ms": 330.3
+     },
+     {
+      "wall_ms": 107.5,
+      "cpu_ms": 321.4
+     },
+     {
+      "wall_ms": 191.9,
+      "cpu_ms": 324.3
+     },
+     {
+      "wall_ms": 182.1,
+      "cpu_ms": 325.1
+     }
+    ]
+   },
+   "presence": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 1432,
+    "wall_ms_median": 13.1,
+    "cpu_ms_median": 83.9,
+    "replays": [
+     {
+      "wall_ms": 73.2,
+      "cpu_ms": 84.3
+     },
+     {
+      "wall_ms": 11.9,
+      "cpu_ms": 81.9
+     },
+     {
+      "wall_ms": 12.0,
+      "cpu_ms": 78.6
+     },
+     {
+      "wall_ms": 80.1,
+      "cpu_ms": 89.8
+     },
+     {
+      "wall_ms": 12.5,
+      "cpu_ms": 85.4
+     },
+     {
+      "wall_ms": 74.8,
+      "cpu_ms": 89.1
+     },
+     {
+      "wall_ms": 13.3,
+      "cpu_ms": 91.3
+     },
+     {
+      "wall_ms": 78.9,
+      "cpu_ms": 83.5
+     },
+     {
+      "wall_ms": 11.7,
+      "cpu_ms": 81.7
+     },
+     {
+      "wall_ms": 12.8,
+      "cpu_ms": 78.1
+     }
+    ]
+   },
+   "chain": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 2837,
+    "wall_ms_median": 107.5,
+    "cpu_ms_median": 264.5,
+    "replays": [
+     {
+      "wall_ms": 104.6,
+      "cpu_ms": 239.5
+     },
+     {
+      "wall_ms": 99.2,
+      "cpu_ms": 241.1
+     },
+     {
+      "wall_ms": 104.8,
+      "cpu_ms": 246.0
+     },
+     {
+      "wall_ms": 98.7,
+      "cpu_ms": 235.4
+     },
+     {
+      "wall_ms": 177.2,
+      "cpu_ms": 260.4
+     },
+     {
+      "wall_ms": 105.5,
+      "cpu_ms": 269.9
+     },
+     {
+      "wall_ms": 109.6,
+      "cpu_ms": 268.7
+     },
+     {
+      "wall_ms": 174.7,
+      "cpu_ms": 282.0
+     },
+     {
+      "wall_ms": 111.4,
+      "cpu_ms": 283.0
+     },
+     {
+      "wall_ms": 178.9,
+      "cpu_ms": 278.1
+     }
+    ]
+   }
+  },
+  "head": {
+   "stored-level query": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 164,
+    "wall_ms_median": 101.3,
+    "cpu_ms_median": 221.4,
+    "replays": [
+     {
+      "wall_ms": 94.9,
+      "cpu_ms": 207.0
+     },
+     {
+      "wall_ms": 96.0,
+      "cpu_ms": 203.4
+     },
+     {
+      "wall_ms": 211.1,
+      "cpu_ms": 488.8
+     },
+     {
+      "wall_ms": 112.7,
+      "cpu_ms": 217.8
+     },
+     {
+      "wall_ms": 156.9,
+      "cpu_ms": 219.2
+     },
+     {
+      "wall_ms": 110.4,
+      "cpu_ms": 242.5
+     },
+     {
+      "wall_ms": 89.9,
+      "cpu_ms": 239.6
+     },
+     {
+      "wall_ms": 102.3,
+      "cpu_ms": 232.4
+     },
+     {
+      "wall_ms": 100.3,
+      "cpu_ms": 223.7
+     },
+     {
+      "wall_ms": 96.2,
+      "cpu_ms": 209.9
+     }
+    ]
+   },
+   "partial-parse probe": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 753,
+    "wall_ms_median": 22.9,
+    "cpu_ms_median": 54.9,
+    "replays": [
+     {
+      "wall_ms": 22.7,
+      "cpu_ms": 55.7
+     },
+     {
+      "wall_ms": 28.3,
+      "cpu_ms": 53.3
+     },
+     {
+      "wall_ms": 22.8,
+      "cpu_ms": 55.7
+     },
+     {
+      "wall_ms": 22.2,
+      "cpu_ms": 54.4
+     },
+     {
+      "wall_ms": 23.3,
+      "cpu_ms": 55.0
+     },
+     {
+      "wall_ms": 35.0,
+      "cpu_ms": 54.0
+     },
+     {
+      "wall_ms": 22.5,
+      "cpu_ms": 54.8
+     },
+     {
+      "wall_ms": 22.9,
+      "cpu_ms": 55.7
+     },
+     {
+      "wall_ms": 32.6,
+      "cpu_ms": 53.5
+     },
+     {
+      "wall_ms": 22.7,
+      "cpu_ms": 55.2
+     }
+    ]
+   },
+   "stream guard": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 67,
+    "wall_ms_median": 0.6,
+    "cpu_ms_median": 0.2,
+    "replays": [
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.7,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     },
+     {
+      "wall_ms": 0.6,
+      "cpu_ms": 0.2
+     }
+    ]
+   },
+   "unpack probe": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 1566,
+    "wall_ms_median": 6.2,
+    "cpu_ms_median": 34.6,
+    "replays": [
+     {
+      "wall_ms": 6.2,
+      "cpu_ms": 35.5
+     },
+     {
+      "wall_ms": 6.1,
+      "cpu_ms": 35.8
+     },
+     {
+      "wall_ms": 5.8,
+      "cpu_ms": 34.4
+     },
+     {
+      "wall_ms": 6.3,
+      "cpu_ms": 28.9
+     },
+     {
+      "wall_ms": 5.6,
+      "cpu_ms": 33.6
+     },
+     {
+      "wall_ms": 58.7,
+      "cpu_ms": 28.1
+     },
+     {
+      "wall_ms": 6.4,
+      "cpu_ms": 37.0
+     },
+     {
+      "wall_ms": 6.2,
+      "cpu_ms": 36.7
+     },
+     {
+      "wall_ms": 5.8,
+      "cpu_ms": 34.8
+     },
+     {
+      "wall_ms": 5.9,
+      "cpu_ms": 32.6
+     }
+    ]
+   },
+   "presence": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 1432,
+    "wall_ms_median": 13.9,
+    "cpu_ms_median": 86.0,
+    "replays": [
+     {
+      "wall_ms": 14.0,
+      "cpu_ms": 87.9
+     },
+     {
+      "wall_ms": 12.9,
+      "cpu_ms": 82.3
+     },
+     {
+      "wall_ms": 81.0,
+      "cpu_ms": 81.0
+     },
+     {
+      "wall_ms": 11.8,
+      "cpu_ms": 82.5
+     },
+     {
+      "wall_ms": 80.4,
+      "cpu_ms": 86.5
+     },
+     {
+      "wall_ms": 13.2,
+      "cpu_ms": 89.8
+     },
+     {
+      "wall_ms": 72.9,
+      "cpu_ms": 84.4
+     },
+     {
+      "wall_ms": 13.9,
+      "cpu_ms": 94.4
+     },
+     {
+      "wall_ms": 81.6,
+      "cpu_ms": 85.6
+     },
+     {
+      "wall_ms": 13.7,
+      "cpu_ms": 94.6
+     }
+    ]
+   },
+   "keys probe": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 4552,
+    "wall_ms_median": 13.9,
+    "cpu_ms_median": 45.5,
+    "replays": [
+     {
+      "wall_ms": 14.5,
+      "cpu_ms": 47.5
+     },
+     {
+      "wall_ms": 13.6,
+      "cpu_ms": 46.3
+     },
+     {
+      "wall_ms": 20.0,
+      "cpu_ms": 40.7
+     },
+     {
+      "wall_ms": 30.2,
+      "cpu_ms": 45.6
+     },
+     {
+      "wall_ms": 14.0,
+      "cpu_ms": 45.4
+     },
+     {
+      "wall_ms": 13.6,
+      "cpu_ms": 45.5
+     },
+     {
+      "wall_ms": 13.6,
+      "cpu_ms": 44.8
+     },
+     {
+      "wall_ms": 13.9,
+      "cpu_ms": 46.1
+     },
+     {
+      "wall_ms": 37.2,
+      "cpu_ms": 44.9
+     },
+     {
+      "wall_ms": 13.8,
+      "cpu_ms": 45.7
+     }
+    ]
+   },
+   "chain": {
+    "requests_in_a_first_view": 1,
+    "query_bytes": 2837,
+    "wall_ms_median": 113.2,
+    "cpu_ms_median": 279.4,
+    "replays": [
+     {
+      "wall_ms": 116.7,
+      "cpu_ms": 284.4
+     },
+     {
+      "wall_ms": 96.1,
+      "cpu_ms": 241.3
+     },
+     {
+      "wall_ms": 173.2,
+      "cpu_ms": 229.6
+     },
+     {
+      "wall_ms": 109.8,
+      "cpu_ms": 239.2
+     },
+     {
+      "wall_ms": 94.4,
+      "cpu_ms": 258.6
+     },
+     {
+      "wall_ms": 205.4,
+      "cpu_ms": 468.4
+     },
+     {
+      "wall_ms": 192.6,
+      "cpu_ms": 291.5
+     },
+     {
+      "wall_ms": 100.5,
+      "cpu_ms": 283.4
+     },
+     {
+      "wall_ms": 179.0,
+      "cpu_ms": 282.2
+     },
+     {
+      "wall_ms": 106.4,
+      "cpu_ms": 276.6
+     }
+    ]
+   }
+  }
+ },
+ "shape": "D",
+ "range": "1h"
+}

From df7609b61a788deb68ffe87dc89182f82812e059 Mon Sep 17 00:00:00 2001
From: szibis <szibis@users.noreply.github.com>
Date: Sat, 17 Oct 2026 02:15:11 +0200
Subject: [PATCH 14/14] docs: the changelog entry and the registry row cite the
 first-view samples and say what the probes do on a refusal

---
 CHANGELOG.md                                  | 35 +++++++++++--------
 ...json-metric-detected-level-derivation.yaml | 30 ++++++++--------
 conformance/registry/generated/wiring.json    |  6 +++-
 3 files changed, 41 insertions(+), 30 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b61a66bb5..8caa6d877 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,26 +11,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **The first view of a window of `sum by (detected_level)` / `sum by (level,
   detected_level)` over `| json`, on rows with no stored level, costs less
-  (follow-up to #760).** A window nothing remembers (probed again every five
-  minutes) asks the stored-level query, the level probes and the presence
+  (#764, follow-up to #760).** A window nothing remembers (probed again every
+  five minutes) asks the stored-level query, the level probes and the presence
   probe before the chain. Three cuts, none of which changes an answer: the two
   "two level keys" patterns of the level keys probe (a key twice in a JSON or
   logfmt line), which scanned the rest of every line holding a level key and
-  were the heaviest probe, 320 to 380 CPU-ms of an hour of rows, run behind a
+  were the heaviest probe, 325 CPU-ms of an hour of rows, run behind a
   filter of phrases (one key name twice, or two of the names; answered from
   VictoriaLogs' token index, a superset of the patterns, never a second
-  decision), 45 to 55 CPU-ms; a selector of 11.8 KB or more, for which the
-  longer probe would pass VictoriaLogs' 16 KiB query length, gets the probe
-  without the gate; and the label probes (main's partial-parse probe among
-  them) are remembered apart from the level probes, so the chain takes their
-  verdict from the stored-level query instead of asking the same question
-  again (51 CPU-ms of an hour). Explore's JSON volume on the harness's backfill
-  without the level stream label, a proxy restarted before each request,
-  VictoriaLogs capped at 2 CPUs (median of 7 at 1h, 5 at 24h): 311 ms against
-  494 ms at 1h and 7.6 s against 11.2 s at 24h (main before #760: 56 ms and
-  2.9 s), 761 CPU-ms against 1085 and 15.2 CPU-s against 22.6; the
-  `sum by (detected_level)` breakdown 213 ms against 373 ms and 4.8 s against
-  8.1 s. Warm times are unchanged.
+  decision), 45 CPU-ms; a base (the translated LogsQL before the pipes) of
+  11.8 KB or more, for which the longer probe would exceed VictoriaLogs' 16 KiB
+  query length, and a VictoriaLogs whose `-search.maxQueryLen` is lower than the
+  longer probe, get the probe without the gate; and the label probes (main's
+  partial-parse probe among them) are remembered apart from the level probes,
+  so the chain takes their verdict from the stored-level query instead of asking
+  the same question again (56 CPU-ms of an hour). Explore's JSON volume on the
+  harness's backfill without the level stream label, a proxy started fresh
+  before each request, VictoriaLogs capped at 2 CPUs (median of 7 at 1h, 5 at
+  24h): 319 ms against 502 ms at 1h and 7.8 s against 11.7 s at 24h (main before
+  #760: 119 ms and 3.0 s), 744 CPU-ms against 1096 and 15.7 CPU-s against 23.5;
+  the `sum by (detected_level)` breakdown 218 ms against 403 ms and 4.9 s
+  against 8.3 s. Warm times are unchanged. Samples and per-request costs:
+  `bench/ab/results/oneoff/2026-10-16-dlfirstview-coldrestart.json` and
+  `-probes.json`, from `python3 bench/ab/cold_first_view.py cold --build
+  before=054d1706 --build main=d12a062c --build head=HEAD --runs 1h=7,24h=5
+  --out <dir>` (`probes` for the second).
 
 ## [2.16.0] - 2026-10-16
 
diff --git a/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml b/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml
index 00ecc0ad5..a0bd09252 100644
--- a/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml
+++ b/conformance/registry/cases/semantics/json-metric-detected-level-derivation.yaml
@@ -169,20 +169,22 @@ why: |
   7.5 s to 0.67 s (6h) and 2.6 s (24h), and on the data with a level stream
   label from 2.3 s to 7 ms at 1h. The first view of a window (nothing
   remembered: the stored-level attempt, the level probes, the presence probe,
-  then the chain) takes 0.31 s at 1h for Explore's volume where main before #760 takes
-  0.06 s (0.49 s before the first-view cuts) and 7.6 s at 24h against 2.9 s
-  (11.2 s), medians of cold requests with each build restarted before them: the
-  probes scan the window and share the 2 CPUs with the chain. The heaviest of
-  them was detectedLevelKeysRisk (320-380 CPU-ms of an hour of rows: two level
-  keys in a line, an escape in a level value, a brace without its closing
-  brace), whose two-keys patterns now run behind a filter of phrases
-  (logsqlTwiceFilter over detectedLevelKeyNames: one key name twice, or two of
-  the names, answered from VictoriaLogs' token index and a superset of the
-  patterns; 45-55 CPU-ms; a selector of 11.8 KB or more, which would push the
-  longer text past -search.maxQueryLen, gets the probe without the gate), and
-  the probes of the labels are remembered apart from the level probes
-  (cachedStatsPushdownRisk), so the chain does not ask again what the
-  stored-level query asked. A window with a row that has no stored level asks
+  then the chain) takes 0.32 s at 1h for Explore's volume where main before #760 takes
+  0.12 s (0.50 s before the first-view cuts) and 7.8 s at 24h against 3.0 s
+  (11.7 s), medians of cold requests with each build started fresh before them
+  (bench/ab/cold_first_view.py; samples in
+  bench/ab/results/oneoff/2026-10-16-dlfirstview-coldrestart.json, per-request
+  costs in -probes.json): the probes scan the window and share the 2 CPUs with
+  the chain. The heaviest of them was detectedLevelKeysRisk (311-325 CPU-ms of an
+  hour of rows: two level keys in a line, an escape in a level value, a brace
+  without its closing brace), whose two-keys patterns now run behind a filter of
+  phrases (logsqlTwiceFilter over detectedLevelKeyNames: one key name twice, or
+  two of the names, answered from VictoriaLogs' token index and a superset of
+  the patterns; 45 CPU-ms; a base of 11.8 KB or more, which would push the
+  longer text past -search.maxQueryLen, or a VictoriaLogs that refuses it as too
+  long, gets the probe without the gate), and the probes of the labels are
+  remembered apart from the level probes (cachedStatsPushdownRisk), so the chain
+  does not ask again what the stored-level query asked. A window with a row that has no stored level asks
   twice, the stored-level attempt first (it costs what main's query costs; its
   verdict is remembered for the base for five minutes so the next ask goes to
   the chain at once), and pays the chain with the three guard probes and the
diff --git a/conformance/registry/generated/wiring.json b/conformance/registry/generated/wiring.json
index d4ce99a17..e079e78e6 100644
--- a/conformance/registry/generated/wiring.json
+++ b/conformance/registry/generated/wiring.json
@@ -426,6 +426,7 @@
       "test/e2e-compat/json_filter_pushdown_test.go"
     ],
     "semantics/json-metric-detected-level-derivation": [
+      "internal/proxy/detected_level_cache_scope_test.go",
       "internal/proxy/detected_level_label_probes_test.go",
       "internal/proxy/detected_level_long_selector_test.go",
       "internal/proxy/detected_level_presence_sweep_test.go",
@@ -658,6 +659,9 @@
     "internal/proxy/compat_cache_freshness_test.go": [
       "semantics/metadata-answers-include-last-24h-like-loki"
     ],
+    "internal/proxy/detected_level_cache_scope_test.go": [
+      "semantics/json-metric-detected-level-derivation"
+    ],
     "internal/proxy/detected_level_keys_gate_test.go": [
       "severity-detected-level-derivation"
     ],
@@ -1216,7 +1220,7 @@
       "profiles/structured-metadata-keys-per-profile"
     ]
   },
-  "tests_with_markers": 120,
+  "tests_with_markers": 121,
   "unknown_ids": {},
   "unwired_items": [
     "api_prom_label",