Query oracle and API freeze

Label matchers (equal, not-equal, regexp, not-regexp) in labels/,
postings intersection/union/difference in internal/postings/,
LabelValues and AllPostings on index, block, and head readers.

ingot.go wired to real DB backed by head + block readers. Querier
snapshots overlapping blocks, Select resolves matchers to postings,
merged iterator chains blocks then head with block-wins dedup.

Oracle tests compare every query against a naive []sample reference
across head-only, block-only, head+block merge seam, multiple blocks,
all four matcher types, and time range filtering.

internal/head/head.go

@@ -5,6 +5,7 @@ package head
 import (
 	"fmt"
 	"path/filepath"
+	"sort"
 	"sync/atomic"
 
 	"git.dvdt.dev/david/ingot/internal/block"
@@ -214,6 +215,59 @@ func (h *Head) FlushOlderThan(maxT int64) (string, error) {
 	return ulid, nil
 }
 
+// Postings returns sorted series refs where the series has label name=value.
+func (h *Head) Postings(name, value string) []uint64 {
+	var refs []uint64
+	h.series.forEach(func(s *memSeries) {
+		for _, l := range s.labels {
+			if l.Name == name && l.Value == value {
+				refs = append(refs, s.ref)
+				break
+			}
+		}
+	})
+	sort.Slice(refs, func(i, j int) bool { return refs[i] < refs[j] })
+	return refs
+}
+
+// LabelValues returns sorted unique values for the given label name.
+func (h *Head) LabelValues(name string) []string {
+	seen := make(map[string]struct{})
+	h.series.forEach(func(s *memSeries) {
+		for _, l := range s.labels {
+			if l.Name == name {
+				seen[l.Value] = struct{}{}
+				break
+			}
+		}
+	})
+	vals := make([]string, 0, len(seen))
+	for v := range seen {
+		vals = append(vals, v)
+	}
+	sort.Strings(vals)
+	return vals
+}
+
+// Labels returns the labels for a series by ref.
+func (h *Head) Labels(ref uint64) ([]labels.Label, bool) {
+	s := h.series.getByRef(ref)
+	if s == nil {
+		return nil, false
+	}
+	return s.labels, true
+}
+
+// AllPostings returns sorted refs for all series in the head.
+func (h *Head) AllPostings() []uint64 {
+	var refs []uint64
+	h.series.forEach(func(s *memSeries) {
+		refs = append(refs, s.ref)
+	})
+	sort.Slice(refs, func(i, j int) bool { return refs[i] < refs[j] })
+	return refs
+}
+
 // DataDir returns the data directory (parent of WAL dir).
 func (h *Head) DataDir() string {
 	return h.dataDir

internal/head/head_test.go

@@ -609,6 +609,79 @@ func TestFlushWALTruncation(t *testing.T) {
 	require.NoError(t, app.Commit())
 }
 
+func TestHeadPostings(t *testing.T) {
+	h := openHead(t)
+
+	// Add three series.
+	app := h.Appender()
+	_, err := app.Append(0, []labels.Label{{Name: "__name__", Value: "temp"}, {Name: "room", Value: "office"}}, 1000, 1.0)
+	require.NoError(t, err)
+	_, err = app.Append(0, []labels.Label{{Name: "__name__", Value: "humidity"}, {Name: "room", Value: "office"}}, 1000, 2.0)
+	require.NoError(t, err)
+	_, err = app.Append(0, []labels.Label{{Name: "__name__", Value: "temp"}, {Name: "room", Value: "kitchen"}}, 1000, 3.0)
+	require.NoError(t, err)
+	require.NoError(t, app.Commit())
+
+	tests := []struct {
+		name     string
+		label    string
+		value    string
+		wantRefs []uint64
+	}{
+		{name: "match_name_temp", label: "__name__", value: "temp", wantRefs: []uint64{1, 3}},
+		{name: "match_room_office", label: "room", value: "office", wantRefs: []uint64{1, 2}},
+		{name: "match_name_humidity", label: "__name__", value: "humidity", wantRefs: []uint64{2}},
+		{name: "no_match", label: "__name__", value: "pressure", wantRefs: nil},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := h.Postings(tc.label, tc.value)
+			assert.Equal(t, tc.wantRefs, got)
+		})
+	}
+}
+
+func TestHeadLabelValues(t *testing.T) {
+	h := openHead(t)
+
+	app := h.Appender()
+	_, err := app.Append(0, []labels.Label{{Name: "__name__", Value: "temp"}, {Name: "room", Value: "office"}}, 1000, 1.0)
+	require.NoError(t, err)
+	_, err = app.Append(0, []labels.Label{{Name: "__name__", Value: "humidity"}, {Name: "room", Value: "office"}}, 1000, 2.0)
+	require.NoError(t, err)
+	_, err = app.Append(0, []labels.Label{{Name: "__name__", Value: "temp"}, {Name: "room", Value: "kitchen"}}, 1000, 3.0)
+	require.NoError(t, err)
+	require.NoError(t, app.Commit())
+
+	assert.Equal(t, []string{"humidity", "temp"}, h.LabelValues("__name__"))
+	assert.Equal(t, []string{"kitchen", "office"}, h.LabelValues("room"))
+	assert.Equal(t, []string{}, h.LabelValues("nonexistent"))
+}
+
+func TestHeadLabelsAndAllPostings(t *testing.T) {
+	h := openHead(t)
+
+	app := h.Appender()
+	_, err := app.Append(0, []labels.Label{{Name: "__name__", Value: "temp"}}, 1000, 1.0)
+	require.NoError(t, err)
+	_, err = app.Append(0, []labels.Label{{Name: "__name__", Value: "humidity"}}, 1000, 2.0)
+	require.NoError(t, err)
+	require.NoError(t, app.Commit())
+
+	// Labels
+	ls, ok := h.Labels(1)
+	assert.True(t, ok)
+	assert.Equal(t, []labels.Label{{Name: "__name__", Value: "temp"}}, ls)
+
+	_, ok = h.Labels(999)
+	assert.False(t, ok)
+
+	// AllPostings
+	refs := h.AllPostings()
+	assert.Equal(t, []uint64{1, 2}, refs)
+}
+
 func TestConcurrentAppend(t *testing.T) {
 	tests := []struct {
 		name                string