diff --git a/adapter/admin_grpc.go b/adapter/admin_grpc.go
index 0eb0dd028..a8cb10a8a 100644
--- a/adapter/admin_grpc.go
+++ b/adapter/admin_grpc.go
@@ -699,6 +699,7 @@ func newKeyVizRowFrom(mr keyviz.MatrixRow, numCols int) *pb.KeyVizRow {
 	}
 	row := &pb.KeyVizRow{
 		BucketId:          bucketIDFor(mr),
+		Label:             string(mr.Label),
 		Start:             append([]byte(nil), mr.Start...),
 		End:               append([]byte(nil), mr.End...),
 		Aggregate:         mr.Aggregate,
@@ -722,6 +723,9 @@ func bucketIDFor(mr keyviz.MatrixRow) string {
 		return "virtual:" + strconv.FormatUint(mr.RouteID, 10)
 	}
 	id := "route:" + strconv.FormatUint(mr.RouteID, 10)
+	if mr.Label != keyviz.LabelLegacy {
+		id += ":" + string(mr.Label)
+	}
 	// Sub-bucket suffix only for genuinely sub-divided routes, so K=1 /
 	// aggregate / degenerate slots keep the exact legacy id. See §5.1.
 	if mr.SubBucketCount > 1 {
diff --git a/adapter/admin_grpc_subrange_test.go b/adapter/admin_grpc_subrange_test.go
index 2c7c4edc1..8847ac1bf 100644
--- a/adapter/admin_grpc_subrange_test.go
+++ b/adapter/admin_grpc_subrange_test.go
@@ -37,6 +37,33 @@ func TestMatrixToProtoSubRowsDoNotCollide(t *testing.T) {
 	require.Equal(t, []uint64{9}, byID["route:1#1"])
 }
 
+func TestMatrixToProtoLabelsDoNotCollide(t *testing.T) {
+	t.Parallel()
+	pick := func(r keyviz.MatrixRow) uint64 { return r.Writes }
+	cols := []keyviz.MatrixColumn{
+		{
+			At: time.Unix(1_700_000_000, 0),
+			Rows: []keyviz.MatrixRow{
+				{RouteID: 1, Label: keyviz.LabelDynamo, Start: []byte("a"), End: []byte("z"), SubBucketCount: 1, Writes: 5},
+				{RouteID: 1, Label: keyviz.LabelRedis, Start: []byte("a"), End: []byte("z"), SubBucketCount: 1, Writes: 9},
+			},
+		},
+	}
+
+	resp := matrixToProto(cols, pick, 0)
+	require.Len(t, resp.Rows, 2)
+	byID := map[string]uint64{}
+	labels := map[string]string{}
+	for _, row := range resp.Rows {
+		byID[row.BucketId] = row.Values[0]
+		labels[row.BucketId] = row.Label
+	}
+	require.Equal(t, uint64(5), byID["route:1:dynamo"])
+	require.Equal(t, "dynamo", labels["route:1:dynamo"])
+	require.Equal(t, uint64(9), byID["route:1:redis"])
+	require.Equal(t, "redis", labels["route:1:redis"])
+}
+
 // TestNewKeyVizRowFromAggregateZeroTotalFallback pins the adapter/handler
 // harmonization (Claude round-2 follow-up): an aggregate row whose
 // MemberRoutesTotal is still 0 (a just-coalesced bucket serialized before
diff --git a/adapter/dynamodb.go b/adapter/dynamodb.go
index f53ed238b..742e89d23 100644
--- a/adapter/dynamodb.go
+++ b/adapter/dynamodb.go
@@ -12,6 +12,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	"github.com/bootjp/elastickv/monitoring"
 	"github.com/bootjp/elastickv/store"
@@ -259,7 +260,7 @@ func NewDynamoDBServer(listen net.Listener, st store.MVCCStore, coordinate kv.Co
 	d := &DynamoDBServer{
 		listen:           listen,
 		store:            st,
-		coordinator:      coordinate,
+		coordinator:      kv.WithKeyVizLabel(coordinate, keyviz.LabelDynamo),
 		onePhaseTxnDedup: os.Getenv("ELASTICKV_DYNAMODB_ONEPHASE_DEDUP") != "0",
 	}
 	d.targetHandlers = map[string]func(http.ResponseWriter, *http.Request){
diff --git a/adapter/grpc.go b/adapter/grpc.go
index cd966afad..49aaa58cc 100644
--- a/adapter/grpc.go
+++ b/adapter/grpc.go
@@ -7,6 +7,7 @@ import (
 	"sync"
 
 	"github.com/bootjp/elastickv/internal"
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	pb "github.com/bootjp/elastickv/proto"
 	"github.com/bootjp/elastickv/store"
@@ -47,7 +48,7 @@ func NewGRPCServer(store store.MVCCStore, coordinate kv.Coordinator, opts ...GRP
 			Level: slog.LevelWarn,
 		})),
 		grpcTranscoder: newGrpcGrpcTranscoder(),
-		coordinator:    coordinate,
+		coordinator:    kv.WithKeyVizLabel(coordinate, keyviz.LabelRawKV),
 		store:          store,
 	}
 	for _, opt := range opts {
diff --git a/adapter/redis.go b/adapter/redis.go
index 73eb0e5d1..bb243ca80 100644
--- a/adapter/redis.go
+++ b/adapter/redis.go
@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/bootjp/elastickv/internal/raftengine"
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	"github.com/bootjp/elastickv/monitoring"
 	pb "github.com/bootjp/elastickv/proto"
@@ -476,7 +477,7 @@ func NewRedisServer(listen net.Listener, redisAddr string, store store.MVCCStore
 	r := &RedisServer{
 		listen:          listen,
 		store:           store,
-		coordinator:     coordinate,
+		coordinator:     kv.WithKeyVizLabel(coordinate, keyviz.LabelRedis),
 		redisTranscoder: newRedisTranscoder(),
 		redisAddr:       redisAddr,
 		relay:           relay,
diff --git a/adapter/redis_delta_compactor.go b/adapter/redis_delta_compactor.go
index 50159edfb..0f64a197d 100644
--- a/adapter/redis_delta_compactor.go
+++ b/adapter/redis_delta_compactor.go
@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	"github.com/bootjp/elastickv/store"
 	"github.com/cockroachdb/errors"
@@ -113,7 +114,7 @@ func WithDeltaCompactorLogger(l *slog.Logger) DeltaCompactorOption {
 func NewDeltaCompactor(st store.MVCCStore, coord kv.Coordinator, opts ...DeltaCompactorOption) *DeltaCompactor {
 	c := &DeltaCompactor{
 		st:       st,
-		coord:    coord,
+		coord:    kv.WithKeyVizLabel(coord, keyviz.LabelRedis),
 		logger:   slog.Default(),
 		maxCount: defaultDeltaCompactorMaxDeltaCount,
 		interval: defaultDeltaCompactorScanInterval,
diff --git a/adapter/redis_delta_compactor_test.go b/adapter/redis_delta_compactor_test.go
index bf357630b..326bfff71 100644
--- a/adapter/redis_delta_compactor_test.go
+++ b/adapter/redis_delta_compactor_test.go
@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	"github.com/bootjp/elastickv/store"
 	"github.com/stretchr/testify/require"
@@ -20,6 +21,27 @@ func newDeltaCompactorTestFixture(t *testing.T) (store.MVCCStore, *DeltaCompacto
 	return st, c
 }
 
+type recordingCompactorCoordinator struct {
+	stubAdapterCoordinator
+	labels []keyviz.Label
+}
+
+func (c *recordingCompactorCoordinator) Dispatch(_ context.Context, reqs *kv.OperationGroup[kv.OP]) (*kv.CoordinateResponse, error) {
+	if reqs != nil {
+		c.labels = append(c.labels, reqs.KeyVizLabel)
+	}
+	return &kv.CoordinateResponse{}, nil
+}
+
+func TestDeltaCompactorStampsRedisKeyVizLabel(t *testing.T) {
+	t.Parallel()
+	rec := &recordingCompactorCoordinator{}
+	c := NewDeltaCompactor(store.NewMVCCStore(), rec)
+	_, err := c.coord.Dispatch(context.Background(), &kv.OperationGroup[kv.OP]{})
+	require.NoError(t, err)
+	require.Equal(t, []keyviz.Label{keyviz.LabelRedis}, rec.labels)
+}
+
 func TestDeltaCompactor_ListDeltaFoldedIntoBaseMeta(t *testing.T) {
 	t.Parallel()
 
diff --git a/adapter/s3.go b/adapter/s3.go
index db200417b..2fc5dec2d 100644
--- a/adapter/s3.go
+++ b/adapter/s3.go
@@ -24,6 +24,7 @@ import (
 	"time"
 
 	"github.com/bootjp/elastickv/internal/s3keys"
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	"github.com/bootjp/elastickv/store"
 	"github.com/cockroachdb/errors"
@@ -318,7 +319,7 @@ func NewS3Server(listen net.Listener, s3Addr string, st store.MVCCStore, coordin
 		s3Addr:      s3Addr,
 		region:      s3DefaultRegion,
 		store:       st,
-		coordinator: coordinate,
+		coordinator: kv.WithKeyVizLabel(coordinate, keyviz.LabelS3),
 		leaderS3:    cloneLeaderAddrMap(leaderS3),
 		cleanupSem:  make(chan struct{}, s3ManifestCleanupWorkers),
 	}
diff --git a/adapter/sqs.go b/adapter/sqs.go
index b7da6ddfe..4a8bdd93c 100644
--- a/adapter/sqs.go
+++ b/adapter/sqs.go
@@ -10,6 +10,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/bootjp/elastickv/keyviz"
 	"github.com/bootjp/elastickv/kv"
 	"github.com/bootjp/elastickv/store"
 	"github.com/cockroachdb/errors"
@@ -285,7 +286,7 @@ func NewSQSServer(listen net.Listener, st store.MVCCStore, coordinate kv.Coordin
 	s := &SQSServer{
 		listen:       listen,
 		store:        st,
-		coordinator:  coordinate,
+		coordinator:  kv.WithKeyVizLabel(coordinate, keyviz.LabelSQS),
 		reaperCtx:    reaperCtx,
 		reaperCancel: reaperCancel,
 		throttle:     newBucketStoreDefault(),
diff --git a/docs/admin_ui_key_visualizer_design.md b/docs/admin_ui_key_visualizer_design.md
index 2f296a6a1..1c0794fa3 100644
--- a/docs/admin_ui_key_visualizer_design.md
+++ b/docs/admin_ui_key_visualizer_design.md
@@ -135,7 +135,7 @@ Response matrix format: `matrix[i][j]` is the value for bucket `i` at time colum
 A single call site is added at the dispatch entry of `kv.ShardedCoordinator` (see `kv/sharded_coordinator.go`), immediately after the request is resolved to a `RouteID`:
 
 ```go
-sampler.Observe(routeID, op, keyLen, valueLen)
+sampler.Observe(routeID, key, op, valueLen, label)
 ```
 
 `sampler` is an interface; the default implementation is nil-safe (a nil sampler compiles to one branch and no allocation). The hook runs *before* Raft proposal so it measures offered load, not applied load.
diff --git a/docs/design/2026_04_28_proposed_keyviz_adapter_labels.md b/docs/design/2026_04_28_implemented_keyviz_adapter_labels.md
similarity index 91%
rename from docs/design/2026_04_28_proposed_keyviz_adapter_labels.md
rename to docs/design/2026_04_28_implemented_keyviz_adapter_labels.md
index 88ad5e4ef..831f8cd18 100644
--- a/docs/design/2026_04_28_proposed_keyviz_adapter_labels.md
+++ b/docs/design/2026_04_28_implemented_keyviz_adapter_labels.md
@@ -1,13 +1,21 @@
 ---
-status: proposed
+status: implemented
 phase: 2-C+
 parent_design: docs/admin_ui_key_visualizer_design.md
 author: bootjp
-date: 2026-04-28
+date: 2026-07-08
 ---
 
 # KeyViz adapter / namespace labels
 
+Implementation note: the shipped surface uses typed labels in
+`keyviz/labels.go`, a `--keyvizLabelsEnabled` startup flag, adapter
+coordinator wrappers for RawKV / Redis / DynamoDB / S3 / SQS, composite
+`route:<id>:<label>` bucket IDs, and explicit label copies across the
+single-node JSON, fan-out JSON, and gRPC matrix paths. The default flag
+value remains false, so existing rolling deploys keep legacy
+`route:<id>` rows until operators opt in after every node is upgraded.
+
 ## 1. Background
 
 Phase 2-A through 2-C ship a fully functional KeyViz heatmap, but
@@ -103,7 +111,7 @@ Extend the sampler signature with a typed `Label` (defined as
 `type Label string` in `keyviz/labels.go`, see §9 Q2):
 
 ```go
-Observe(routeID uint64, op Op, keyLen, valueLen int, label Label)
+Observe(routeID uint64, key []byte, op Op, valueLen int, label Label)
 ```
 
 Empty `label` (`LabelLegacy`) → existing behaviour, single row
@@ -629,7 +637,7 @@ Virtual-bucket rows in the heatmap render as
 | PR | Scope |
 |---|---|
 | **PR-A** | Land this design doc. |
-| **PR-B** | Sampler API extension: extend the `Sampler` interface declaration (`keyviz/sampler.go:74`) AND the `MemSampler.Observe` implementation to `Observe(routeID uint64, op Op, keyLen, valueLen int, label Label)` (Claude bot round-8 minor: surfaces immediately as a compile error if any mock implementer is missed, but naming it keeps the scope complete). `routeSlot.Label`, slot-key type widens to `slotKey{uint64, Label}`. **PR-B introduces the `--keyvizLabelsEnabled` startup flag** (default `false`) on the server binary — CLI parsing and the `KeyVizLabelsEnabled bool` option on `ShardedCoordinatorOpts` / `MemSamplerOpts` ship in PR-B, so the flag exists from PR-B onward and PR-B's behavior-neutrality claim does not depend on PR-C+D+E (Codex round-25 P2). **`RegisterRoute` in PR-B always pre-creates only the legacy empty-label slot, regardless of the flag** (Codex round-26 P2 — earlier round-25 wording said pre-creation is "gated on the flag" in PR-B, which would have allowed an operator to enable the flag in PR-B and start allocating `len(AllLabels)+1` slots before any of the PR-C+D+E adapter-wiring or wire-format machinery existed). The `RegisterRoute` flag-honoring code lands in **PR-C+D+E**, not PR-B; in PR-B the flag is **dormant** for slot pre-creation (it exists for option plumbing only). Per-route slot count in PR-B is therefore unconditionally 1, regardless of the flag, and PR-B is fully behavior-neutral. **PR-B creates `keyviz/labels.go`** with the `slotKey` struct, the `type Label string` definition, the `LabelLegacy`/`LabelDynamo`/`LabelRedis`/etc. **typed constants**, and `AllLabels` as a **fixed-size array** `[5]Label{LabelDynamo, ..., LabelRawKV}` (round-23 — array form prevents importing-package mutation; see §9 Q2). The constants must exist at compile time so `RemoveRoute`'s `allLabelsWithLegacy()` teardown loop compiles in PR-B; `RegisterRoute`'s flag-honoring pre-creation loop is **not yet present in PR-B** (it lands in PR-C+D+E per the previous paragraph), so PR-B's `RegisterRoute` body is a single legacy-slot create call regardless of the flag. With PR-B unconditionally pre-creating only the legacy slot, per-route slot count stays at 1 (Claude bot round-6 + round-23 array correction + Codex round-26 P2 unconditionality). `MatrixRow.Label` field present. **L0 label copy** (Claude bot round-8 moderate): update `appendDrainedRow` (`keyviz/sampler.go:828`) to include `Label: slot.Label` in the `MatrixRow` struct literal — `slot.Label` is set once at `RegisterRoute` time and immutable, so read it directly rather than threading through `snapshotMeta`. This is the first link in the propagation chain: `slot.Label` → `MatrixRow.Label` (L0, here) → `KeyVizRow.Label` via `newKeyVizRowFrom` (L1, PR-D+E) → merged `KeyVizRow.Label` via `mergeRowInto` (L2, PR-D+E). Missing L0 silently truncates the chain and leaves `MatrixRow.Label = ""` even after PR-C+D+E wires the adapters to pass labels; L1 and L2 then faithfully copy the empty string and the feature collapses. With PR-B unconditionally pre-creating only the legacy slot (regardless of flag, per round-26 P2), `slot.Label` is `""` so the emitted row is `""`-labeled (identical to today's behavior), but the type-widening + L0 wiring is in place for PR-C+D+E to land the flag-honoring `RegisterRoute` loop and start emitting labels. `reclaimRetiredSlot` dedupes on `(RouteID, Label)` (forward-prep; only `Label=""` exists). The `MaxTrackedRoutes` coarsening check (`keyviz/sampler.go:416`) in PR-B uses `slotsPerRoute` as the **literal `1`** — same unconditionality reason as the `RegisterRoute` body above (Codex round-26 + round-27 P1: the flag-gated `slotsPerRoute := 1; if KeyVizLabelsEnabled { slotsPerRoute = len(AllLabels)+1 }` lands in PR-C+D+E, not PR-B). PR-B with `slotsPerRoute = 1` keeps the cap counting routes (1 slot per route × N routes ≤ MaxTrackedRoutes), behavior identical to today regardless of any flag value. Update existing tests **and the coordinator call sites in `kv/sharded_coordinator.go`** (the only non-test caller of `Sampler.Observe`) to pass `label = ""`. |
+| **PR-B** | Sampler API extension: extend the `Sampler` interface declaration (`keyviz/sampler.go:74`) AND the `MemSampler.Observe` implementation to `Observe(routeID uint64, key []byte, op Op, valueLen int, label Label)` (Claude bot round-8 minor: surfaces immediately as a compile error if any mock implementer is missed, but naming it keeps the scope complete). `routeSlot.Label`, slot-key type widens to `slotKey{uint64, Label}`. **PR-B introduces the `--keyvizLabelsEnabled` startup flag** (default `false`) on the server binary — CLI parsing and the `KeyVizLabelsEnabled bool` option on `ShardedCoordinatorOpts` / `MemSamplerOpts` ship in PR-B, so the flag exists from PR-B onward and PR-B's behavior-neutrality claim does not depend on PR-C+D+E (Codex round-25 P2). **`RegisterRoute` in PR-B always pre-creates only the legacy empty-label slot, regardless of the flag** (Codex round-26 P2 — earlier round-25 wording said pre-creation is "gated on the flag" in PR-B, which would have allowed an operator to enable the flag in PR-B and start allocating `len(AllLabels)+1` slots before any of the PR-C+D+E adapter-wiring or wire-format machinery existed). The `RegisterRoute` flag-honoring code lands in **PR-C+D+E**, not PR-B; in PR-B the flag is **dormant** for slot pre-creation (it exists for option plumbing only). Per-route slot count in PR-B is therefore unconditionally 1, regardless of the flag, and PR-B is fully behavior-neutral. **PR-B creates `keyviz/labels.go`** with the `slotKey` struct, the `type Label string` definition, the `LabelLegacy`/`LabelDynamo`/`LabelRedis`/etc. **typed constants**, and `AllLabels` as a **fixed-size array** `[5]Label{LabelDynamo, ..., LabelRawKV}` (round-23 — array form prevents importing-package mutation; see §9 Q2). The constants must exist at compile time so `RemoveRoute`'s `allLabelsWithLegacy()` teardown loop compiles in PR-B; `RegisterRoute`'s flag-honoring pre-creation loop is **not yet present in PR-B** (it lands in PR-C+D+E per the previous paragraph), so PR-B's `RegisterRoute` body is a single legacy-slot create call regardless of the flag. With PR-B unconditionally pre-creating only the legacy slot, per-route slot count stays at 1 (Claude bot round-6 + round-23 array correction + Codex round-26 P2 unconditionality). `MatrixRow.Label` field present. **L0 label copy** (Claude bot round-8 moderate): update `appendDrainedRow` (`keyviz/sampler.go:828`) to include `Label: slot.Label` in the `MatrixRow` struct literal — `slot.Label` is set once at `RegisterRoute` time and immutable, so read it directly rather than threading through `snapshotMeta`. This is the first link in the propagation chain: `slot.Label` → `MatrixRow.Label` (L0, here) → `KeyVizRow.Label` via `newKeyVizRowFrom` (L1, PR-D+E) → merged `KeyVizRow.Label` via `mergeRowInto` (L2, PR-D+E). Missing L0 silently truncates the chain and leaves `MatrixRow.Label = ""` even after PR-C+D+E wires the adapters to pass labels; L1 and L2 then faithfully copy the empty string and the feature collapses. With PR-B unconditionally pre-creating only the legacy slot (regardless of flag, per round-26 P2), `slot.Label` is `""` so the emitted row is `""`-labeled (identical to today's behavior), but the type-widening + L0 wiring is in place for PR-C+D+E to land the flag-honoring `RegisterRoute` loop and start emitting labels. `reclaimRetiredSlot` dedupes on `(RouteID, Label)` (forward-prep; only `Label=""` exists). The `MaxTrackedRoutes` coarsening check (`keyviz/sampler.go:416`) in PR-B uses `slotsPerRoute` as the **literal `1`** — same unconditionality reason as the `RegisterRoute` body above (Codex round-26 + round-27 P1: the flag-gated `slotsPerRoute := 1; if KeyVizLabelsEnabled { slotsPerRoute = len(AllLabels)+1 }` lands in PR-C+D+E, not PR-B). PR-B with `slotsPerRoute = 1` keeps the cap counting routes (1 slot per route × N routes ≤ MaxTrackedRoutes), behavior identical to today regardless of any flag value. Update existing tests **and the coordinator call sites in `kv/sharded_coordinator.go`** (the only non-test caller of `Sampler.Observe`) to pass `label = ""`. |
 | **PR-C+D+E** | **Bundled — must ship together.** PR-C (adapter wiring only — `AllLabels` constants are already declared in PR-B as part of the `[5]Label` array, see §9 Q2) and PR-D+E (wire format + pivot-key widening) are not separately shippable: once an adapter calls `Observe(..., LabelDynamo)`, the sampler emits multiple `MatrixRow` per route in a single column (one per label); without the pivot-key widening from PR-D+E, `pivotKeyVizColumns` and `matrixToProto` collapse those rows back into a single `RouteID`-keyed entry where each labeled row overwrites the previous one — non-deterministic data loss in the intermediate state. Earlier drafts framed PR-C and PR-D+E as separately shippable; that was wrong (Codex round-10 P1). The bundle covers: <br>**Adapter wiring (was PR-C)**: each adapter sets its label at the `ShardedCoordinator.Observe…` dispatch entry. The five canonical constants (`LabelDynamo`, `LabelRedis`, `LabelS3`, `LabelSQS`, `LabelRawKV`) are already declared in `keyviz/labels.go` from PR-B as part of the `[5]Label` array (round-23 — see §9 Q2 and the PR-B row above); PR-C+D+E only wires the adapters to pass them, no `AllLabels` modification needed (Claude round-24 fix to the prior "populate empty slice" framing). Extend `RegisterRoute` to pre-create the labeled siblings (one slot per `AllLabels` member) **only when `--keyvizLabelsEnabled=true`**; with the flag off, `RegisterRoute` continues to pre-create just the legacy empty-label slot, identical to today's behavior (Codex round-15-4th-pass P1). **MaxTrackedRoutes is unchanged in semantics** — the §4.1.1 coarsening check divides slot count by `slotsPerRoute` (`len(AllLabels)+1` when the flag is on, `1` when off), so the existing operator-set cap continues to mean "individually-tracked routes" exactly as before; **operators do not need to raise `--keyvizMaxTrackedRoutes`** (an earlier draft told operators to scale the cap by `× (len(labels)+1)` — that contradicted Option A; Codex round-6). Memory growth: `MaxTrackedRoutes × (len(AllLabels) + 1)` slots when labels are enabled, `MaxTrackedRoutes × 1` when off (today's baseline); documented but not capped. Emit `slog.Warn` from inside `RegisterRoute` when a route coarsens. <br>**Wire-format extension (was PR-D+E)**: proto + JSON `bucket_id` composite + optional `label` field, plus the SPA `route:N / label` rendering AND the **five** code changes across the three response paths: <br>**Single-node JSON path (`internal/admin/keyviz_handler.go`)**: <br>(a) `pivotKeyVizColumns` `rowsByID` map AND `order` slice both widen from `uint64` to the composite `BucketID string` — widening only the map without the `order` slice is a compile error; <br>(b) `newKeyVizRowFrom` (`keyviz_handler.go:368`) copies `mr.Label → row.Label` via an explicit `string(mr.Label)` cast (`MatrixRow.Label` is the typed `keyviz.Label`; `KeyVizRow.Label` is plain `string` for wire-format flexibility — Claude bot round-10 minor) — **first-level** Label copy, affects single-node and cluster deployments alike; <br>(c) `bucketIDFor` (`keyviz_handler.go:383`) returns the composite `"route:<id>:<label>"` when `mr.Label != ""`, falling back to the legacy `"route:<id>"` for empty labels — without this `BucketID` is non-unique and `applyKeyVizRowBudget` / `sortKeyVizRowsByStart` lose their deterministic tiebreak; <br>**Fan-out JSON path (`internal/admin/keyviz_fanout.go`)**: <br>(d) `mergeRowInto` (`keyviz_fanout.go:509`) adds `dst.Label = row.Label` — **second-level** Label copy, only the cluster fan-out path touches this; <br>**gRPC path (`adapter/admin_grpc.go`)**: <br>(e) `matrixToProto` (`admin_grpc.go:599`) and the per-row conversion it drives: (e1) **widen `rowsByID` (line 603) and `order` (line 604) from `uint64` to the composite `BucketID string` key** — same widening as item (a); without it `(routeID=1, label="dynamo")` and `(routeID=1, label="redis")` collapse to the same map entry; (e2) copy `MatrixRow.Label → KeyVizRow.label` (proto field 4) via `string(mr.Label)` cast (same typed→untyped reasoning as item (b)); (e3) emit composite `bucket_id` (`"route:<id>:<label>"`). Without (e1)–(e3), `GetKeyVizMatrix` gRPC clients receive collapsed unlabeled rows even though HTTP/SPA responses now show per-label rows. <br>All five copies are required; missing any one leaves a flavour of deployment with empty labels. Splitting the bundle into separate PR-C and PR-D+E was the original framing but is now rejected (see opening paragraph of this row). <br>**Operator-controlled rollout gate (rolling-upgrade safety)**: a normal rolling upgrade temporarily mixes nodes that emit legacy `route:<id>` rows with nodes that emit labeled `route:<id>:<label>` rows. The fan-out aggregator keys strictly by `BucketID` in `mergeRowInto`, so those rows do **not** merge — operators would see fragmented unlabeled-plus-labeled data per route until every node converges. **`--keyvizLabelsEnabled` is introduced in PR-B** (default `false`) so PR-B's behavior-neutrality claim (`RegisterRoute` skips labeled-sibling pre-creation, slot count stays at 1) holds without any PR-C+D+E dependency. PR-C+D+E adds the **coordinator override path**: when the flag is false, the **`ShardedCoordinator` overrides the adapter-supplied label to `keyviz.LabelLegacy` at the single `sampler.Observe(...)` call site** in `kv/sharded_coordinator.go` (one `if !s.keyvizLabelsEnabled { label = keyviz.LabelLegacy }` guard, not a 5-file flag-read duplication across adapters; Claude bot round-12 moderate). The override path only matters in PR-C+D+E because that is when adapters first start passing non-empty labels; in PR-B all adapters still pass `label = ""` so the override is a no-op. (Codex round-25 P2 caught the prior wording that said "PR-C+D+E adds the flag" — it implied PR-B couldn't enforce its own gating, when in fact PR-B introduces the flag for pre-creation gating and PR-C+D+E only adds the override path on top.) The bundled binary is therefore safe to roll out one node at a time — every node, mixed or fully upgraded, emits the legacy format. <br>**Flag-flip activation**: once the fleet is fully on the new binary, the operator flips `--keyvizLabelsEnabled=true`. The flag is a startup-only `flag.Bool` (no live-toggle / config-reload path; Claude bot round-12 minor); changing it requires a process restart. There are two restart strategies: (a) **simultaneous restart of all nodes** — KeyViz heatmap is briefly unavailable during the restart window but no mixed-format fragmentation occurs; (b) **rolling restart** — for the duration of the restart (typically minutes), the heatmap shows a transient mixed view because the legacy `route:N` rows from not-yet-restarted nodes don't merge with `route:N:label` rows from restarted nodes. Since KeyViz is a monitoring view (not a consistency-sensitive system), the rolling-restart fragmentation is acceptable and clears as the final node restarts; operators who want zero fragmentation should use the simultaneous restart. (Claude bot round-12 moderate.) <br>**Flag also gates pre-allocation**: `--keyvizLabelsEnabled` is **both** the traffic-routing toggle (override label to `LabelLegacy` at the coordinator) **and** the slot-pre-creation toggle. When `false`, `RegisterRoute` pre-creates only the legacy empty-label slot (`len(next.slots) += 1` per route, identical to today's behavior); labeled siblings are not allocated. When `true`, `RegisterRoute` pre-creates the legacy slot **and** one labeled sibling per `AllLabels` member (`len(next.slots) += len(AllLabels)+1` per route). Memory therefore stays at the today's level (`MaxTrackedRoutes × 1`) for clusters that deploy the bundled binary but leave the flag off, and grows to `MaxTrackedRoutes × (len(AllLabels)+1)` only when the operator opts in. The flag-flip activation requires a process restart (see preceding paragraph), and `RegisterRoute` re-runs at startup, so the new pre-creation regime is in effect immediately after the restart — there is no live re-allocation path needed. **An earlier draft separated memory and traffic-routing into two regimes ("memory-vs-flag separation", round-12) where labeled slots were pre-created regardless of the flag; that was wrong (Codex round-15-4th-pass P1) — it imposed a multi-x memory penalty on clusters that never enable labels, contradicting the §2.1 minimal-penalty goal.** (Codex round-11 P2 originated this rollout gate.) |
 
 PR-B is independent of the bundled PR-C+D+E: PR-B widens types
diff --git a/docs/design/2026_05_25_proposed_keyviz_subrange_sampling.md b/docs/design/2026_05_25_proposed_keyviz_subrange_sampling.md
index c4ec828a6..a6733cc9d 100644
--- a/docs/design/2026_05_25_proposed_keyviz_subrange_sampling.md
+++ b/docs/design/2026_05_25_proposed_keyviz_subrange_sampling.md
@@ -17,7 +17,7 @@ sequential prefix, change a schema). The current sampler cannot do
 this at the granularity the name implies.
 
 Today the sampler keys every counter on **RouteID**
-(`keyviz.MemSampler`, `Observe(routeID, op, keyLen, valueLen)` —
+(`keyviz.MemSampler`, `Observe(routeID, key, op, valueLen, label)` —
 `keyviz/sampler.go`). A *route* is the key range a Raft group owns in
 the distribution catalog. The heatmap's Y axis is therefore
 **route-granular**:
@@ -209,11 +209,12 @@ non-`MaxUint64` start does sub-divide.
 // before
 Observe(routeID uint64, op Op, keyLen, valueLen int)
 // after
-Observe(routeID uint64, key []byte, op Op, valueLen int)
+Observe(routeID uint64, key []byte, op Op, valueLen int, label Label)
 ```
 
 `keyLen` is dropped in favour of the key itself (`len(key)` recovers
-it for the `*Bytes` counters). This is a **semantic-touching signature
+it for the `*Bytes` counters), while adapter labels are forwarded
+unchanged by the sub-range bucket selection. This is a **semantic-touching signature
 change**: per CLAUDE.md, every caller of `Sampler.Observe` /
 `MemSampler.Observe` will be grep-audited so each passes the real key
 (not, say, a nil placeholder that would silently bucket all traffic
diff --git a/internal/admin/keyviz_fanout.go b/internal/admin/keyviz_fanout.go
index 3a245f67a..472c2fc3f 100644
--- a/internal/admin/keyviz_fanout.go
+++ b/internal/admin/keyviz_fanout.go
@@ -551,6 +551,7 @@ type rowMergeAcc struct {
 	routeIDs          []uint64
 	routeIDsTruncated bool
 	routeCount        uint64
+	label             string
 	cells             []cellMergeAcc
 }
 
@@ -628,6 +629,7 @@ func mergeRowInto(
 			routeIDs:          append([]uint64(nil), row.RouteIDs...),
 			routeIDsTruncated: row.RouteIDsTruncated,
 			routeCount:        row.RouteCount,
+			label:             row.Label,
 			cells:             make([]cellMergeAcc, mergedWidth),
 		}
 		accByBucket[row.BucketID] = acc
@@ -745,6 +747,7 @@ func resolveRowMergeAcc(acc *rowMergeAcc, useGroupTermDedupe bool) KeyVizRow {
 	width := len(acc.cells)
 	row := KeyVizRow{
 		BucketID:          acc.bucketID,
+		Label:             acc.label,
 		Start:             acc.start,
 		End:               acc.end,
 		Aggregate:         acc.aggregate,
diff --git a/internal/admin/keyviz_fanout_test.go b/internal/admin/keyviz_fanout_test.go
index 803e87cf2..ec36d54a1 100644
--- a/internal/admin/keyviz_fanout_test.go
+++ b/internal/admin/keyviz_fanout_test.go
@@ -43,6 +43,34 @@ func TestMergeKeyVizMatricesReadsSum(t *testing.T) {
 	require.False(t, merged.Rows[0].Conflict, "reads must never raise conflict")
 }
 
+func TestMergeKeyVizMatricesPreservesLabels(t *testing.T) {
+	t.Parallel()
+	col := []int64{1_700_000_000_000}
+	a := KeyVizMatrix{
+		ColumnUnixMs: col,
+		Series:       keyVizSeriesWrites,
+		Rows: []KeyVizRow{
+			{BucketID: "route:1:dynamo", Label: "dynamo", Values: []uint64{5}, RaftGroupIDs: []uint64{1}, LeaderTerms: []uint64{3}},
+		},
+	}
+	b := KeyVizMatrix{
+		ColumnUnixMs: col,
+		Series:       keyVizSeriesWrites,
+		Rows: []KeyVizRow{
+			{BucketID: "route:1:redis", Label: "redis", Values: []uint64{9}, RaftGroupIDs: []uint64{1}, LeaderTerms: []uint64{3}},
+		},
+	}
+
+	merged := mergeKeyVizMatrices([]KeyVizMatrix{a, b}, keyVizSeriesWrites)
+	require.Len(t, merged.Rows, 2)
+	byID := map[string]KeyVizRow{}
+	for _, row := range merged.Rows {
+		byID[row.BucketID] = row
+	}
+	require.Equal(t, "dynamo", byID["route:1:dynamo"].Label)
+	require.Equal(t, "redis", byID["route:1:redis"].Label)
+}
+
 // TestMergeKeyVizMatricesWritesMaxStableLeader pins the §4.2 happy
 // path: under stable leadership exactly one node reports non-zero
 // writes. The merge picks the non-zero value without raising
diff --git a/internal/admin/keyviz_handler.go b/internal/admin/keyviz_handler.go
index 778fe6054..d4192d693 100644
--- a/internal/admin/keyviz_handler.go
+++ b/internal/admin/keyviz_handler.go
@@ -85,6 +85,7 @@ type KeyVizMatrix struct {
 // surfaces that per-cell conflict bit on the wire via Conflicts[].
 type KeyVizRow struct {
 	BucketID          string   `json:"bucket_id"`
+	Label             string   `json:"label,omitempty"`
 	Start             []byte   `json:"start"`
 	End               []byte   `json:"end"`
 	Aggregate         bool     `json:"aggregate"`
@@ -408,6 +409,7 @@ func newKeyVizRowFrom(mr keyviz.MatrixRow, numCols int) *KeyVizRow {
 	}
 	row := &KeyVizRow{
 		BucketID:          bucketIDFor(mr),
+		Label:             string(mr.Label),
 		Start:             append([]byte(nil), mr.Start...),
 		End:               append([]byte(nil), mr.End...),
 		Aggregate:         mr.Aggregate,
@@ -431,6 +433,9 @@ func bucketIDFor(mr keyviz.MatrixRow) string {
 		return "virtual:" + strconv.FormatUint(mr.RouteID, 10)
 	}
 	id := "route:" + strconv.FormatUint(mr.RouteID, 10)
+	if mr.Label != keyviz.LabelLegacy {
+		id += ":" + string(mr.Label)
+	}
 	// Append the sub-bucket index only for genuinely sub-divided routes
 	// (SubBucketCount > 1), so a K=1 / aggregate / degenerate slot keeps
 	// the exact legacy "route:<id>" id and the change stays inert at the
diff --git a/internal/admin/keyviz_hotkeys_fanout.go b/internal/admin/keyviz_hotkeys_fanout.go
index 23522f500..c35bad760 100644
--- a/internal/admin/keyviz_hotkeys_fanout.go
+++ b/internal/admin/keyviz_hotkeys_fanout.go
@@ -258,6 +258,9 @@ func buildKeyVizHotKeysPeerURL(peer string, params hotKeysParams) (string, error
 	base.Path = pathKeyVizHotKeys
 	q := base.Query()
 	q.Set("route_id", strconv.FormatUint(params.routeID, 10))
+	if params.label != keyviz.LabelLegacy {
+		q.Set("label", string(params.label))
+	}
 	if params.subBucketSet {
 		q.Set("sub_bucket", strconv.Itoa(params.subBucket))
 	}
@@ -322,6 +325,7 @@ func mergeHotKeyResponses(responses []hotKeyResponse, params hotKeysParams) hotK
 		// cannot panic the merge step.
 		return hotKeyResponse{
 			RouteID:     params.routeID,
+			Label:       string(params.label),
 			Series:      params.series,
 			Approximate: true,
 			Keys:        []hotKeyResponseEntry{},
@@ -336,6 +340,7 @@ func mergeHotKeyResponses(responses []hotKeyResponse, params hotKeysParams) hotK
 	// the SUM identity and the loop folds responses[0] cleanly.
 	out := hotKeyResponse{
 		RouteID:     base.RouteID,
+		Label:       base.Label,
 		SubBucket:   base.SubBucket,
 		Series:      base.Series,
 		Approximate: true, // SS sketches are always approximate.
diff --git a/internal/admin/keyviz_hotkeys_fanout_test.go b/internal/admin/keyviz_hotkeys_fanout_test.go
index 4d94c67c3..b79e14b60 100644
--- a/internal/admin/keyviz_hotkeys_fanout_test.go
+++ b/internal/admin/keyviz_hotkeys_fanout_test.go
@@ -259,6 +259,12 @@ func TestBuildKeyVizHotKeysPeerURL(t *testing.T) {
 			params: hotKeysParams{routeID: 7, series: "writes", top: 20},
 			want:   "https://node-b.internal:9443/admin/api/v1/keyviz/hotkeys?route_id=7&series=writes&top=256",
 		},
+		{
+			name:   "label forwarded",
+			peer:   "10.0.0.2:8080",
+			params: hotKeysParams{routeID: 7, label: keyviz.LabelRedis, series: "writes", top: 20},
+			want:   "http://10.0.0.2:8080/admin/api/v1/keyviz/hotkeys?label=redis&route_id=7&series=writes&top=256",
+		},
 		{
 			name: "sub_bucket + from/to forwarded",
 			peer: "10.0.0.2:8080",
diff --git a/internal/admin/keyviz_hotkeys_handler.go b/internal/admin/keyviz_hotkeys_handler.go
index c3d4be916..d2140060b 100644
--- a/internal/admin/keyviz_hotkeys_handler.go
+++ b/internal/admin/keyviz_hotkeys_handler.go
@@ -24,8 +24,8 @@ import (
 // aggregate, or the index is out of range; nil hi means unbounded tail.
 type KeyVizHotKeysSource interface {
 	HotKeysOptions() (enabled bool, capacity, sampleRate, maxKeyLen int)
-	HotKeysSnapshot(routeID uint64) *keyviz.KeyvizHotKeysSnapshot
-	SubBucketBoundsFor(routeID uint64, subBucket int) (lo, hi []byte, ok bool)
+	HotKeysSnapshot(routeID uint64, label keyviz.Label) *keyviz.KeyvizHotKeysSnapshot
+	SubBucketBoundsFor(routeID uint64, label keyviz.Label, subBucket int) (lo, hi []byte, ok bool)
 }
 
 // KeyVizHotKeysHandler serves GET /admin/api/v1/keyviz/hotkeys.
@@ -114,6 +114,7 @@ const (
 // scaled units (`sample_rate × sampled_n / m`).
 type hotKeyResponse struct {
 	RouteID         uint64                `json:"route_id"`
+	Label           string                `json:"label,omitempty"`
 	SubBucket       *int                  `json:"sub_bucket,omitempty"`
 	Series          string                `json:"series"`
 	Keys            []hotKeyResponseEntry `json:"keys"`
@@ -152,7 +153,7 @@ func (h *KeyVizHotKeysHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
 	// makes the !enabled+fanout intent visible at the call site.
 	var snap *keyviz.KeyvizHotKeysSnapshot
 	if enabled {
-		snap = h.source.HotKeysSnapshot(params.routeID)
+		snap = h.source.HotKeysSnapshot(params.routeID, params.label)
 	}
 	out, errStatus, errCode, errMsg := h.buildLocalResponse(r, params, snap)
 	if errCode != "" {
@@ -222,7 +223,7 @@ func (h *KeyVizHotKeysHandler) checkSnapshotWindow(p hotKeysParams, snap *keyviz
 func (h *KeyVizHotKeysHandler) collectEntries(p hotKeysParams, snap *keyviz.KeyvizHotKeysSnapshot) ([]keyviz.KeyvizHotKeyEntry, string, string) {
 	entries := snap.Entries
 	if p.subBucketSet {
-		lo, hi, ok := h.source.SubBucketBoundsFor(p.routeID, p.subBucket)
+		lo, hi, ok := h.source.SubBucketBoundsFor(p.routeID, p.label, p.subBucket)
 		if !ok {
 			return nil, "invalid_query", "sub_bucket is out of range for this route"
 		}
@@ -257,6 +258,7 @@ func (h *KeyVizHotKeysHandler) collectEntries(p hotKeysParams, snap *keyviz.Keyv
 func buildHotKeysResponse(p hotKeysParams, snap *keyviz.KeyvizHotKeysSnapshot, entries []keyviz.KeyvizHotKeyEntry) hotKeyResponse {
 	out := hotKeyResponse{
 		RouteID:         p.routeID,
+		Label:           string(p.label),
 		Series:          p.series,
 		Keys:            make([]hotKeyResponseEntry, len(entries)),
 		Approximate:     true,
@@ -393,6 +395,7 @@ func (h *KeyVizHotKeysHandler) buildLocalResponse(r *http.Request, params hotKey
 func emptyHotKeyResponse(params hotKeysParams) hotKeyResponse {
 	out := hotKeyResponse{
 		RouteID:     params.routeID,
+		Label:       string(params.label),
 		Series:      params.series,
 		Approximate: true,
 		Keys:        []hotKeyResponseEntry{},
@@ -448,6 +451,7 @@ func (h *KeyVizHotKeysHandler) audit(r *http.Request, p hotKeysParams, returned
 		slog.String("method", r.Method),
 		slog.String("path", r.URL.Path),
 		slog.Uint64("route_id", p.routeID),
+		slog.String("label", string(p.label)),
 		slog.Int("top", p.top),
 		slog.String("series", p.series),
 		slog.Int("returned", returned),
@@ -464,6 +468,7 @@ func (h *KeyVizHotKeysHandler) audit(r *http.Request, p hotKeysParams, returned
 
 type hotKeysParams struct {
 	routeID      uint64
+	label        keyviz.Label
 	subBucket    int
 	subBucketSet bool
 	series       string
@@ -479,6 +484,9 @@ func parseHotKeysParams(r *http.Request, capacity int) (hotKeysParams, error) {
 		return hotKeysParams{}, err
 	}
 	p := hotKeysParams{routeID: routeID, series: "writes", top: hotKeysDefaultTop}
+	if err := parseHotKeysLabelParam(q.Get("label"), &p); err != nil {
+		return hotKeysParams{}, err
+	}
 	if err := parseSubBucketParam(q.Get("sub_bucket"), &p); err != nil {
 		return hotKeysParams{}, err
 	}
@@ -505,6 +513,21 @@ func parseRouteIDParam(raw string) (uint64, error) {
 	return v, nil
 }
 
+func parseHotKeysLabelParam(raw string, p *hotKeysParams) error {
+	if raw == "" {
+		p.label = keyviz.LabelLegacy
+		return nil
+	}
+	label := keyviz.Label(raw)
+	for _, known := range keyviz.AllLabels {
+		if label == known {
+			p.label = label
+			return nil
+		}
+	}
+	return errors.New("label must be a known KeyViz adapter label")
+}
+
 func parseSubBucketParam(raw string, p *hotKeysParams) error {
 	if raw == "" {
 		return nil
diff --git a/internal/admin/keyviz_hotkeys_handler_test.go b/internal/admin/keyviz_hotkeys_handler_test.go
index 0b2ea2c4d..4d952dc44 100644
--- a/internal/admin/keyviz_hotkeys_handler_test.go
+++ b/internal/admin/keyviz_hotkeys_handler_test.go
@@ -31,6 +31,7 @@ type stubHotKeysSource struct {
 
 type boundsKey struct {
 	routeID   uint64
+	label     keyviz.Label
 	subBucket int
 }
 
@@ -43,12 +44,16 @@ func (s *stubHotKeysSource) HotKeysOptions() (bool, int, int, int) {
 	return s.enabled, s.capacity, s.sampleRate, s.maxKeyLen
 }
 
-func (s *stubHotKeysSource) HotKeysSnapshot(routeID uint64) *keyviz.KeyvizHotKeysSnapshot {
-	return s.snapshots[routeID]
+func (s *stubHotKeysSource) HotKeysSnapshot(routeID uint64, label keyviz.Label) *keyviz.KeyvizHotKeysSnapshot {
+	snap := s.snapshots[routeID]
+	if snap == nil || snap.Label != label {
+		return nil
+	}
+	return snap
 }
 
-func (s *stubHotKeysSource) SubBucketBoundsFor(routeID uint64, subBucket int) ([]byte, []byte, bool) {
-	v, ok := s.bounds[boundsKey{routeID, subBucket}]
+func (s *stubHotKeysSource) SubBucketBoundsFor(routeID uint64, label keyviz.Label, subBucket int) ([]byte, []byte, bool) {
+	v, ok := s.bounds[boundsKey{routeID: routeID, label: label, subBucket: subBucket}]
 	if !ok {
 		return nil, nil, false
 	}
@@ -154,6 +159,31 @@ func TestHotKeysHandler_WholeRouteReturnsScaledTopN(t *testing.T) {
 	require.Equal(t, uint64(5*16), resp.Keys[1].Count)
 }
 
+func TestHotKeysHandler_LabelParamSelectsLabeledSnapshot(t *testing.T) {
+	t.Parallel()
+	src := newStubSource()
+	src.snapshots[1] = &keyviz.KeyvizHotKeysSnapshot{
+		RouteID:    1,
+		Label:      keyviz.LabelRedis,
+		SampledN:   1,
+		SampleRate: 1,
+		Capacity:   8,
+		SnapshotAt: time.Now().UTC(),
+		Entries:    []keyviz.KeyvizHotKeyEntry{{Key: []byte("redis-key"), Count: 1}},
+	}
+	h := newHandler(t, src)
+
+	unlabeled := serve(t, h, "GET", "/admin/api/v1/keyviz/hotkeys?route_id=1", nil)
+	require.Equal(t, http.StatusNotFound, unlabeled.Code)
+
+	labeled := serve(t, h, "GET", "/admin/api/v1/keyviz/hotkeys?route_id=1&label=redis", nil)
+	require.Equal(t, http.StatusOK, labeled.Code)
+	var resp hotKeyResponse
+	require.NoError(t, json.NewDecoder(labeled.Body).Decode(&resp))
+	require.Equal(t, "redis", resp.Label)
+	require.Equal(t, base64.StdEncoding.EncodeToString([]byte("redis-key")), resp.Keys[0].KeyB64)
+}
+
 func TestHotKeysHandler_SubBucketFiltersByBytes(t *testing.T) {
 	t.Parallel()
 	src := newStubSource()
@@ -172,7 +202,7 @@ func TestHotKeysHandler_SubBucketFiltersByBytes(t *testing.T) {
 		},
 	}
 	// Sub-bucket 3 spans [m, t).
-	src.bounds[boundsKey{1, 3}] = boundsValue{lo: []byte("m"), hi: []byte("t"), ok: true}
+	src.bounds[boundsKey{routeID: 1, label: keyviz.LabelLegacy, subBucket: 3}] = boundsValue{lo: []byte("m"), hi: []byte("t"), ok: true}
 	h := newHandler(t, src)
 	rec := serve(t, h, "GET", "/admin/api/v1/keyviz/hotkeys?route_id=1&sub_bucket=3", nil)
 	require.Equal(t, http.StatusOK, rec.Code)
@@ -201,7 +231,7 @@ func TestHotKeysHandler_SubBucketUnboundedTailFilter(t *testing.T) {
 			{Key: []byte("zzz"), Count: 5},
 		},
 	}
-	src.bounds[boundsKey{1, 7}] = boundsValue{lo: []byte("m"), hi: nil, ok: true}
+	src.bounds[boundsKey{routeID: 1, label: keyviz.LabelLegacy, subBucket: 7}] = boundsValue{lo: []byte("m"), hi: nil, ok: true}
 	h := newHandler(t, src)
 	rec := serve(t, h, "GET", "/admin/api/v1/keyviz/hotkeys?route_id=1&sub_bucket=7", nil)
 	require.Equal(t, http.StatusOK, rec.Code)
diff --git a/internal/admin/keyviz_subrange_test.go b/internal/admin/keyviz_subrange_test.go
index 67a940a82..ae9374078 100644
--- a/internal/admin/keyviz_subrange_test.go
+++ b/internal/admin/keyviz_subrange_test.go
@@ -56,6 +56,31 @@ func TestPivotKeyVizColumnsK1KeepsLegacyBucketID(t *testing.T) {
 	require.Equal(t, "route:7", m.Rows[0].BucketID)
 }
 
+func TestPivotKeyVizColumnsLabelsDoNotCollide(t *testing.T) {
+	t.Parallel()
+	at := time.Unix(1_700_000_000, 0)
+	cols := []keyviz.MatrixColumn{
+		{
+			At: at,
+			Rows: []keyviz.MatrixRow{
+				{RouteID: 1, Label: keyviz.LabelDynamo, Start: []byte("a"), End: []byte("z"), SubBucketCount: 1, Writes: 5},
+				{RouteID: 1, Label: keyviz.LabelRedis, Start: []byte("a"), End: []byte("z"), SubBucketCount: 1, Writes: 9},
+			},
+		},
+	}
+
+	m := pivotKeyVizColumns(cols, keyVizSeriesWrites, keyVizRowBudgetCap)
+	require.Len(t, m.Rows, 2)
+	byID := map[string]KeyVizRow{}
+	for _, row := range m.Rows {
+		byID[row.BucketID] = row
+	}
+	require.Equal(t, "dynamo", byID["route:1:dynamo"].Label)
+	require.Equal(t, []uint64{5}, byID["route:1:dynamo"].Values)
+	require.Equal(t, "redis", byID["route:1:redis"].Label)
+	require.Equal(t, []uint64{9}, byID["route:1:redis"].Values)
+}
+
 // TestMergeKeyVizMatricesMixedKCoexist pins the §9 decision 2: in a
 // mixed-K cluster a K=1 peer emits "route:1" while a K=2 peer emits
 // "route:1#0"/"route:1#1". Because the merge dedupes by BucketID these
diff --git a/keyviz/flusher_test.go b/keyviz/flusher_test.go
index 9588e02a2..8ce3ba69c 100644
--- a/keyviz/flusher_test.go
+++ b/keyviz/flusher_test.go
@@ -21,7 +21,7 @@ func TestRunFlusherTicksUntilCancel(t *testing.T) {
 
 	// Drive Observe across ticker firings.
 	for i := 0; i < 10; i++ {
-		s.Observe(1, make([]byte, 0), OpRead, 0)
+		s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
 		time.Sleep(2 * time.Millisecond)
 	}
 	cancel()
diff --git a/keyviz/hot_keys.go b/keyviz/hot_keys.go
index b96fadbf0..cf5b6df77 100644
--- a/keyviz/hot_keys.go
+++ b/keyviz/hot_keys.go
@@ -21,8 +21,8 @@ import (
 // between the hot path and the aggregator (design §4 pool-vs-snapshot
 // ownership) — never aliased by an SS entry or a published snapshot.
 type hotKeyEvent struct {
-	routeID uint64
-	key     *[]byte
+	slot slotKey
+	key  *[]byte
 }
 
 // KeyvizHotKeysSnapshot is the immutable per-route view a drill-down
@@ -34,6 +34,7 @@ type hotKeyEvent struct {
 // keyviz package because the aggregator owns and publishes it.
 type KeyvizHotKeysSnapshot struct {
 	RouteID         uint64
+	Label           Label
 	SampledN        uint64    // events the sketch actually saw this window
 	DroppedSamples  uint64    // node-global: bounded-queue back-pressure drops
 	SkippedLongKeys uint64    // node-global: pre-sample length-cap rejects
@@ -69,12 +70,12 @@ type hotKeysAggregator struct {
 	// read once per publish by the aggregator).
 	dropped atomic.Uint64
 	skipped atomic.Uint64
-	// Per-route sampled-N counters (incremented by the aggregator only,
+	// Per-route/label sampled-N counters (incremented by the aggregator only,
 	// reset on publish). Map mutation is guarded by the fact that the
 	// aggregator is the single writer.
-	perRouteN map[uint64]*uint64
-	// Per-route Space-Saving sketches (single-writer-by-aggregator).
-	sketches map[uint64]*spaceSaving
+	perSlotN map[slotKey]*uint64
+	// Per-route/label Space-Saving sketches (single-writer-by-aggregator).
+	sketches map[slotKey]*spaceSaving
 	// rngState backs the sample gate. We avoid math/rand/v2 entirely
 	// (gosec G404 flags the package as a weak crypto generator — but
 	// it's also the only built-in PRNG, and we'd otherwise need a
@@ -156,8 +157,8 @@ func newHotKeysAggregator(s *MemSampler, opts MemSamplerOptions) *hotKeysAggrega
 		maxKeyLen:  maxKeyLen,
 		step:       opts.Step,
 		clock:      now,
-		perRouteN:  map[uint64]*uint64{},
-		sketches:   map[uint64]*spaceSaving{},
+		perSlotN:   map[slotKey]*uint64{},
+		sketches:   map[slotKey]*spaceSaving{},
 	}
 	a.keyPool = &sync.Pool{
 		New: func() any {
@@ -206,7 +207,7 @@ func (a *hotKeysAggregator) releaseKeyBuffer(bp *[]byte) {
 //
 // Returns true iff the event was enqueued for the aggregator. The
 // boolean is for tests; the production caller in Observe ignores it.
-func (a *hotKeysAggregator) observe(routeID uint64, key []byte) bool {
+func (a *hotKeysAggregator) observe(routeID uint64, label Label, key []byte) bool {
 	if len(key) > a.maxKeyLen {
 		a.skipped.Add(1)
 		return false
@@ -227,7 +228,7 @@ func (a *hotKeysAggregator) observe(routeID uint64, key []byte) bool {
 	bp := a.borrowKeyBuffer()
 	*bp = append(*bp, key...)
 	select {
-	case a.ch <- hotKeyEvent{routeID: routeID, key: bp}:
+	case a.ch <- hotKeyEvent{slot: slotKey{RouteID: routeID, Label: label}, key: bp}:
 		// bp will be released by the aggregator after it copies the key
 		// into the SS entry's own storage.
 		return true
@@ -250,7 +251,7 @@ func (a *hotKeysAggregator) observe(routeID uint64, key []byte) bool {
 //	  }
 //	}
 //
-// Single-writer to every per-route SS sketch and to perRouteN, so no
+// Single-writer to every per-route/label SS sketch and to perSlotN, so no
 // lock is needed on the update path. ctx cancellation drains a final
 // publish so the last window's data isn't lost on shutdown.
 func (a *hotKeysAggregator) run(ctx context.Context) {
@@ -287,17 +288,17 @@ func (a *hotKeysAggregator) run(ctx context.Context) {
 // consume handles one event: drains the sample-N counter for the route,
 // updates the Space-Saving sketch, and releases the pool buffer.
 func (a *hotKeysAggregator) consume(e hotKeyEvent) {
-	n, ok := a.perRouteN[e.routeID]
+	n, ok := a.perSlotN[e.slot]
 	if !ok {
 		n = new(uint64)
-		a.perRouteN[e.routeID] = n
+		a.perSlotN[e.slot] = n
 	}
 	*n++
 
-	sk, ok := a.sketches[e.routeID]
+	sk, ok := a.sketches[e.slot]
 	if !ok {
 		sk = newSpaceSaving(a.capacity)
-		a.sketches[e.routeID] = sk
+		a.sketches[e.slot] = sk
 	}
 	// SS copies the bytes into its own entry storage; the pool buffer
 	// is then safe to return immediately.
@@ -332,24 +333,25 @@ func (a *hotKeysAggregator) publishAndReset() {
 	dropped := a.dropped.Swap(0)
 	skipped := a.skipped.Swap(0)
 	tbl := a.s.table.Load()
-	for rid, sk := range a.sketches {
-		slot := lookupSlotForRoute(tbl, rid)
+	for skey, sk := range a.sketches {
+		slot := lookupSlotForRoute(tbl, skey.RouteID, skey.Label)
 		if slot == nil {
 			// Route was removed mid-window: drop the sketch AND its
 			// per-route counter so we don't accumulate dead entries
 			// under route churn (gemini HIGH on PR #854 — without this,
 			// every removed route's m × key bytes plus a *uint64 stays
 			// in the aggregator forever).
-			delete(a.sketches, rid)
-			delete(a.perRouteN, rid)
+			delete(a.sketches, skey)
+			delete(a.perSlotN, skey)
 			continue
 		}
 		n := uint64(0)
-		if p, ok := a.perRouteN[rid]; ok {
+		if p, ok := a.perSlotN[skey]; ok {
 			n = *p
 		}
 		snap := &KeyvizHotKeysSnapshot{
-			RouteID:         rid,
+			RouteID:         skey.RouteID,
+			Label:           skey.Label,
 			SampledN:        n,
 			DroppedSamples:  dropped,
 			SkippedLongKeys: skipped,
@@ -365,8 +367,8 @@ func (a *hotKeysAggregator) publishAndReset() {
 	// captured-and-reset by the Swap(0) calls at the top of this
 	// function — issuing another Store(0) here would re-clobber any
 	// hot-path Add that arrived during the publish loop.
-	for k := range a.perRouteN {
-		*a.perRouteN[k] = 0
+	for k := range a.perSlotN {
+		*a.perSlotN[k] = 0
 	}
 }
 
@@ -388,11 +390,11 @@ func toSnapshotEntries(es []ssEntrySnap) []KeyvizHotKeyEntry {
 // the route table. Aggregate / virtual buckets are NOT eligible for
 // hot-keys tracking (design §2.2): they coarsen multiple routes and
 // "top-K within an aggregate" is not meaningful.
-func lookupSlotForRoute(tbl *routeTable, routeID uint64) *routeSlot {
+func lookupSlotForRoute(tbl *routeTable, routeID uint64, label Label) *routeSlot {
 	if tbl == nil {
 		return nil
 	}
-	if s, ok := tbl.slots[routeID]; ok && !s.Aggregate {
+	if s, ok := tbl.slots[slotKey{RouteID: routeID, Label: label}]; ok && !s.Aggregate {
 		return s
 	}
 	return nil
diff --git a/keyviz/hot_keys_test.go b/keyviz/hot_keys_test.go
index 869ee0763..9a2b3d002 100644
--- a/keyviz/hot_keys_test.go
+++ b/keyviz/hot_keys_test.go
@@ -50,14 +50,14 @@ func TestHotKeysObservePublishesPerRouteSnapshot(t *testing.T) {
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 
 	for i := 0; i < 5; i++ {
-		s.Observe(1, []byte("hot"), OpWrite, 0)
+		s.Observe(1, []byte("hot"), OpWrite, 0, LabelLegacy)
 	}
-	s.Observe(1, []byte("cold"), OpWrite, 0)
+	s.Observe(1, []byte("cold"), OpWrite, 0, LabelLegacy)
 
-	require.Nil(t, s.HotKeysSnapshot(1), "no snapshot before publish")
+	require.Nil(t, s.HotKeysSnapshot(1, LabelLegacy), "no snapshot before publish")
 	drainAndPublish(s.hotKeys)
 
-	snap := s.HotKeysSnapshot(1)
+	snap := s.HotKeysSnapshot(1, LabelLegacy)
 	require.NotNil(t, snap)
 	require.Equal(t, uint64(1), snap.RouteID)
 	require.Equal(t, uint64(6), snap.SampledN, "every Observe enqueued at R=1")
@@ -75,6 +75,35 @@ func TestHotKeysObservePublishesPerRouteSnapshot(t *testing.T) {
 	require.Equal(t, uint64(1), got["cold"])
 }
 
+func TestHotKeysSnapshotsAreLabelScoped(t *testing.T) {
+	t.Parallel()
+	s := NewMemSampler(MemSamplerOptions{
+		Step:                time.Hour,
+		HistoryColumns:      4,
+		KeyVizLabelsEnabled: true,
+		HotKeysEnabled:      true,
+		HotKeysPerRoute:     hotKeysTestCapacity,
+		HotKeysSampleRate:   1,
+		HotKeysQueueSize:    32,
+		HotKeysMaxKeyLen:    64,
+	})
+	require.True(t, s.RegisterRoute(1, []byte("a"), nil, 1))
+	s.Observe(1, []byte("redis-hot"), OpWrite, 0, LabelRedis)
+	s.Observe(1, []byte("dynamo-hot"), OpWrite, 0, LabelDynamo)
+	drainAndPublish(s.hotKeys)
+
+	redisSnap := s.HotKeysSnapshot(1, LabelRedis)
+	require.NotNil(t, redisSnap)
+	require.Equal(t, LabelRedis, redisSnap.Label)
+	require.Equal(t, []byte("redis-hot"), redisSnap.Entries[0].Key)
+
+	dynamoSnap := s.HotKeysSnapshot(1, LabelDynamo)
+	require.NotNil(t, dynamoSnap)
+	require.Equal(t, LabelDynamo, dynamoSnap.Label)
+	require.Equal(t, []byte("dynamo-hot"), dynamoSnap.Entries[0].Key)
+	require.Nil(t, s.HotKeysSnapshot(1, LabelLegacy))
+}
+
 // snapDegraded mirrors the admin response's `degraded` rule (§5):
 // drops > 0 OR skipped_long_keys > 0.
 func snapDegraded(s *KeyvizHotKeysSnapshot) bool {
@@ -103,7 +132,7 @@ func TestHotKeysLongKeySkippedBeforeSampling(t *testing.T) {
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 	tooLong := bytes.Repeat([]byte("x"), 100)
 	for i := 0; i < 50; i++ {
-		s.Observe(1, tooLong, OpWrite, 0)
+		s.Observe(1, tooLong, OpWrite, 0, LabelLegacy)
 	}
 	// Long-key check runs BEFORE the sample gate, so all 50 observes
 	// bump the node-global counter — independent of R.
@@ -115,7 +144,7 @@ func TestHotKeysLongKeySkippedBeforeSampling(t *testing.T) {
 	// to. publishAndReset must NOT discard the signal in that case —
 	// it should carry the skipped count forward to the next window.
 	drainAndPublish(s.hotKeys)
-	require.Nil(t, s.HotKeysSnapshot(1), "no enqueues -> no per-route snapshot")
+	require.Nil(t, s.HotKeysSnapshot(1, LabelLegacy), "no enqueues -> no per-route snapshot")
 	require.Equal(t, uint64(50), s.hotKeys.skipped.Load(),
 		"node-global skipped must carry forward when no sketch exists to attach it to")
 
@@ -128,9 +157,9 @@ func TestHotKeysLongKeySkippedBeforeSampling(t *testing.T) {
 	s2 := hotKeysTestSampler(t, 32, 4)
 	require.True(t, s2.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 	s2.hotKeys.skipped.Store(50)
-	s2.Observe(1, []byte("ok"), OpWrite, 0)
+	s2.Observe(1, []byte("ok"), OpWrite, 0, LabelLegacy)
 	drainAndPublish(s2.hotKeys)
-	snap := s2.HotKeysSnapshot(1)
+	snap := s2.HotKeysSnapshot(1, LabelLegacy)
 	require.NotNil(t, snap)
 	require.Equal(t, uint64(50), snap.SkippedLongKeys, "skipped surfaced on the first sketch-bearing snapshot")
 	require.True(t, snapDegraded(snap), "non-zero skipped -> degraded")
@@ -147,7 +176,7 @@ func TestHotKeysChannelFullCountsDrops(t *testing.T) {
 	s := hotKeysTestSampler(t, 4, 64)
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 	for i := 0; i < 10; i++ {
-		s.Observe(1, []byte("k"), OpWrite, 0)
+		s.Observe(1, []byte("k"), OpWrite, 0, LabelLegacy)
 	}
 	require.Equal(t, 4, len(s.hotKeys.ch), "queue should be full (cap=4)")
 	require.Equal(t, uint64(6), s.hotKeys.dropped.Load(), "10 observes - 4 enqueued = 6 drops")
@@ -173,10 +202,10 @@ func TestHotKeysAggregateRoutesNotTracked(t *testing.T) {
 	// Observe against route 2: hits the aggregate bucket, which is
 	// filtered out by the Observe-time !slot.Aggregate check.
 	for i := 0; i < 5; i++ {
-		s.Observe(2, []byte("would-be-hot"), OpWrite, 0)
+		s.Observe(2, []byte("would-be-hot"), OpWrite, 0, LabelLegacy)
 	}
 	drainAndPublish(s.hotKeys)
-	require.Nil(t, s.HotKeysSnapshot(2), "aggregate routes are not tracked")
+	require.Nil(t, s.HotKeysSnapshot(2, LabelLegacy), "aggregate routes are not tracked")
 }
 
 // TestHotKeysSnapshotResetClearsLiveSketch pins design §4 / Codex P2
@@ -188,19 +217,19 @@ func TestHotKeysSnapshotResetClearsLiveSketch(t *testing.T) {
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 	// Window 1: "old" key hot.
 	for i := 0; i < 10; i++ {
-		s.Observe(1, []byte("old"), OpWrite, 0)
+		s.Observe(1, []byte("old"), OpWrite, 0, LabelLegacy)
 	}
 	drainAndPublish(s.hotKeys)
-	snap := s.HotKeysSnapshot(1)
+	snap := s.HotKeysSnapshot(1, LabelLegacy)
 	require.NotNil(t, snap)
 	require.Equal(t, uint64(10), snap.SampledN)
 
 	// Window 2: only one observe of a new key. The reset rule means
 	// the new snapshot reflects ONLY window-2 traffic — "old" must
 	// be absent, sampledN == 1.
-	s.Observe(1, []byte("new"), OpWrite, 0)
+	s.Observe(1, []byte("new"), OpWrite, 0, LabelLegacy)
 	drainAndPublish(s.hotKeys)
-	snap2 := s.HotKeysSnapshot(1)
+	snap2 := s.HotKeysSnapshot(1, LabelLegacy)
 	require.NotNil(t, snap2)
 	require.Equal(t, uint64(1), snap2.SampledN, "reset must clear sampledN")
 	require.Len(t, snap2.Entries, 1)
@@ -216,8 +245,8 @@ func TestHotKeysDisabledIsZeroCost(t *testing.T) {
 	s := NewMemSampler(MemSamplerOptions{Step: time.Hour, HistoryColumns: 4, HotKeysEnabled: false})
 	require.Nil(t, s.hotKeys, "disabled => no aggregator constructed")
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
-	s.Observe(1, []byte("any"), OpWrite, 0) // must not panic; no-op for hot-keys
-	require.Nil(t, s.HotKeysSnapshot(1))
+	s.Observe(1, []byte("any"), OpWrite, 0, LabelLegacy) // must not panic; no-op for hot-keys
+	require.Nil(t, s.HotKeysSnapshot(1, LabelLegacy))
 }
 
 // TestHotKeysDropCounterAttachesToSnapshot pins the claude-bot 🔴
@@ -230,11 +259,11 @@ func TestHotKeysDropCounterAttachesToSnapshot(t *testing.T) {
 	s := hotKeysTestSampler(t, 4, 64)
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 	for i := 0; i < 10; i++ {
-		s.Observe(1, []byte("k"), OpWrite, 0)
+		s.Observe(1, []byte("k"), OpWrite, 0, LabelLegacy)
 	}
 	require.Equal(t, uint64(6), s.hotKeys.dropped.Load(), "10 sends - 4 enqueued = 6 drops")
 	drainAndPublish(s.hotKeys)
-	snap := s.HotKeysSnapshot(1)
+	snap := s.HotKeysSnapshot(1, LabelLegacy)
 	require.NotNil(t, snap)
 	require.Equal(t, uint64(6), snap.DroppedSamples, "Swap captures drops into the published snapshot")
 	require.Equal(t, uint64(0), s.hotKeys.dropped.Load(), "Swap reset the live counter")
@@ -250,17 +279,17 @@ func TestHotKeysAggregatorReleasesRemovedRouteState(t *testing.T) {
 	s := hotKeysTestSampler(t, 32, 64)
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
 	for i := 0; i < 4; i++ {
-		s.Observe(1, []byte("hot"), OpWrite, 0)
+		s.Observe(1, []byte("hot"), OpWrite, 0, LabelLegacy)
 	}
 	drainAndPublish(s.hotKeys)
-	require.Contains(t, s.hotKeys.sketches, uint64(1))
-	require.Contains(t, s.hotKeys.perRouteN, uint64(1))
+	require.Contains(t, s.hotKeys.sketches, slotKey{RouteID: 1, Label: LabelLegacy})
+	require.Contains(t, s.hotKeys.perSlotN, slotKey{RouteID: 1, Label: LabelLegacy})
 
 	// Route removed → next publish must drop its sketch + counter.
 	s.RemoveRoute(1)
 	drainAndPublish(s.hotKeys)
-	require.NotContains(t, s.hotKeys.sketches, uint64(1), "removed route's sketch must be released")
-	require.NotContains(t, s.hotKeys.perRouteN, uint64(1), "removed route's counter must be released")
+	require.NotContains(t, s.hotKeys.sketches, slotKey{RouteID: 1, Label: LabelLegacy}, "removed route's sketch must be released")
+	require.NotContains(t, s.hotKeys.perSlotN, slotKey{RouteID: 1, Label: LabelLegacy}, "removed route's counter must be released")
 }
 
 // TestHotKeysAggregatorGracefulShutdownPublishes pins the ctx.Done arm
@@ -293,14 +322,14 @@ func TestHotKeysAggregatorGracefulShutdownPublishes(t *testing.T) {
 	}()
 
 	for i := 0; i < 7; i++ {
-		s.Observe(1, []byte("hot"), OpWrite, 0)
+		s.Observe(1, []byte("hot"), OpWrite, 0, LabelLegacy)
 	}
 	// Cancel triggers the ctx.Done arm, which drains the channel
 	// and publishes one final snapshot before returning.
 	cancel()
 	<-done
 
-	snap := s.HotKeysSnapshot(1)
+	snap := s.HotKeysSnapshot(1, LabelLegacy)
 	require.NotNil(t, snap, "graceful shutdown must publish a final snapshot")
 	require.GreaterOrEqual(t, snap.SampledN, uint64(7), "all observed events present in the final snapshot")
 	require.Len(t, snap.Entries, 1)
@@ -343,7 +372,7 @@ func TestHotKeysAggregatorRaceFree(t *testing.T) {
 				if i%2 == 1 {
 					rid = 2
 				}
-				s.Observe(rid, key, OpWrite, 0)
+				s.Observe(rid, key, OpWrite, 0, LabelLegacy)
 			}
 		}(w)
 	}
@@ -359,7 +388,7 @@ func TestHotKeysAggregatorRaceFree(t *testing.T) {
 	// (atomic.Pointer.Load), which is what this test pins. Observed
 	// failure: Actions run 26765510693.
 	require.Eventually(t, func() bool {
-		return s.HotKeysSnapshot(1) != nil && s.HotKeysSnapshot(2) != nil
+		return s.HotKeysSnapshot(1, LabelLegacy) != nil && s.HotKeysSnapshot(2, LabelLegacy) != nil
 	}, 3*time.Second, 5*time.Millisecond, "aggregator must publish a snapshot for each route within the budget")
 	cancel()
 	wgRun.Wait()
diff --git a/keyviz/labels.go b/keyviz/labels.go
new file mode 100644
index 000000000..9b375472e
--- /dev/null
+++ b/keyviz/labels.go
@@ -0,0 +1,30 @@
+package keyviz
+
+// Label is the canonical adapter-family label carried by KeyViz samples.
+// The empty label is the legacy route-only view.
+type Label string
+
+const (
+	LabelLegacy Label = ""
+	LabelDynamo Label = "dynamo"
+	LabelRedis  Label = "redis"
+	LabelS3     Label = "s3"
+	LabelSQS    Label = "sqs"
+	LabelRawKV  Label = "rawkv"
+)
+
+// AllLabels lists every non-legacy adapter label that RegisterRoute can
+// pre-create when label attribution is enabled. The fixed-size array makes
+// accidental append-based mutation a compile-time error.
+var AllLabels = [5]Label{LabelDynamo, LabelRedis, LabelS3, LabelSQS, LabelRawKV}
+
+func allLabelsWithLegacy() []Label {
+	result := make([]Label, len(AllLabels), len(AllLabels)+1)
+	copy(result, AllLabels[:])
+	return append(result, LabelLegacy)
+}
+
+type slotKey struct {
+	RouteID uint64
+	Label   Label
+}
diff --git a/keyviz/labels_test.go b/keyviz/labels_test.go
new file mode 100644
index 000000000..44de712fd
--- /dev/null
+++ b/keyviz/labels_test.go
@@ -0,0 +1,110 @@
+package keyviz
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestAllLabelsAvoidBucketIDSeparator(t *testing.T) {
+	t.Parallel()
+	for _, label := range AllLabels {
+		require.NotContains(t, string(label), ":", "label %q must not break route:<id>:<label>", label)
+	}
+}
+
+func TestAllLabelConstantsInAllLabels(t *testing.T) {
+	t.Parallel()
+	want := []Label{LabelDynamo, LabelRedis, LabelS3, LabelSQS, LabelRawKV}
+	for _, label := range want {
+		require.True(t, labelInAllLabels(label), "AllLabels must include %q", label)
+	}
+}
+
+func TestAllLabelsWithLegacyFreshSlice(t *testing.T) {
+	t.Parallel()
+	labels := allLabelsWithLegacy()
+	require.Len(t, labels, len(AllLabels)+1)
+	require.Equal(t, LabelLegacy, labels[len(labels)-1])
+	labels[0] = Label("mutated")
+	require.Equal(t, LabelDynamo, AllLabels[0], "helper must not expose AllLabels storage")
+}
+
+func TestLabelSlotPrecreationAndRemoveRoute(t *testing.T) {
+	t.Parallel()
+	s := NewMemSampler(MemSamplerOptions{Step: time.Second, HistoryColumns: 4, KeyVizLabelsEnabled: true})
+	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 7))
+
+	tbl := s.table.Load()
+	require.Len(t, tbl.slots, len(AllLabels)+1)
+	for _, label := range allLabelsWithLegacy() {
+		slot := tbl.slots[slotKey{RouteID: 1, Label: label}]
+		require.NotNil(t, slot, "missing pre-created slot for label %q", label)
+		require.Equal(t, label, slot.Label)
+	}
+
+	s.RemoveRoute(1)
+	require.Empty(t, s.table.Load().slots)
+	s.retiredMu.Lock()
+	retired := len(s.retiredSlots)
+	s.retiredMu.Unlock()
+	require.Equal(t, len(AllLabels)+1, retired)
+}
+
+func TestLabelDisabledKeepsLegacySlotOnly(t *testing.T) {
+	t.Parallel()
+	s := NewMemSampler(MemSamplerOptions{Step: time.Second, HistoryColumns: 4})
+	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
+	require.Len(t, s.table.Load().slots, 1)
+
+	s.Observe(1, []byte("k"), OpWrite, 0, LabelDynamo)
+	s.Flush()
+	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
+	require.Len(t, rows, 1)
+	require.Equal(t, LabelLegacy, rows[0].Label)
+	require.Equal(t, uint64(1), rows[0].Writes)
+}
+
+func TestObserveSplitsRowsByLabelWhenEnabled(t *testing.T) {
+	t.Parallel()
+	s := NewMemSampler(MemSamplerOptions{Step: time.Second, HistoryColumns: 4, KeyVizLabelsEnabled: true})
+	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("z"), 0))
+
+	s.Observe(1, []byte("d"), OpWrite, 0, LabelDynamo)
+	s.Observe(1, []byte("r"), OpWrite, 0, LabelRedis)
+	s.Flush()
+
+	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
+	require.Len(t, rows, 2)
+	byLabel := map[Label]MatrixRow{}
+	for _, row := range rows {
+		byLabel[row.Label] = row
+	}
+	require.Equal(t, uint64(1), byLabel[LabelDynamo].Writes)
+	require.Equal(t, uint64(1), byLabel[LabelRedis].Writes)
+}
+
+func TestCoarsenedRouteEmitsLegacyLabel(t *testing.T) {
+	t.Parallel()
+	s := NewMemSampler(MemSamplerOptions{Step: time.Second, HistoryColumns: 4, MaxTrackedRoutes: 1, KeyVizLabelsEnabled: true})
+	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("m"), 0))
+	require.False(t, s.RegisterRoute(2, []byte("m"), []byte("z"), 0))
+
+	s.Observe(2, []byte("n"), OpWrite, 0, LabelS3)
+	s.Flush()
+	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
+	require.Len(t, rows, 1)
+	require.True(t, rows[0].Aggregate)
+	require.Equal(t, LabelLegacy, rows[0].Label)
+	require.Equal(t, uint64(1), rows[0].Writes)
+}
+
+func labelInAllLabels(label Label) bool {
+	for _, candidate := range AllLabels {
+		if candidate == label {
+			return true
+		}
+	}
+	return false
+}
diff --git a/keyviz/sampler.go b/keyviz/sampler.go
index 5a9c124ae..e9133e815 100644
--- a/keyviz/sampler.go
+++ b/keyviz/sampler.go
@@ -32,6 +32,7 @@ package keyviz
 import (
 	"bytes"
 	"encoding/binary"
+	"log/slog"
 	"math"
 	"math/bits"
 	"sort"
@@ -76,7 +77,7 @@ type Sampler interface {
 	// counter; pass valueLen 0 for read-only ops where the response
 	// size is irrelevant. Implementations must no-op (not panic) when
 	// invoked on a typed-nil receiver.
-	Observe(routeID uint64, key []byte, op Op, valueLen int)
+	Observe(routeID uint64, key []byte, op Op, valueLen int, label Label)
 }
 
 // Defaults for MemSamplerOptions when fields are left zero.
@@ -159,6 +160,10 @@ type MemSamplerOptions struct {
 	// [1, MaxKeyBucketsPerRoute] at construction. Virtual aggregate
 	// buckets are never sub-divided regardless of this value.
 	KeyBucketsPerRoute int
+	// KeyVizLabelsEnabled opts into one sampler slot per known adapter
+	// label in addition to the legacy unlabeled slot. When false, only
+	// the legacy slot is pre-created and labels are ignored on Observe.
+	KeyVizLabelsEnabled bool
 	// HotKeysEnabled opts in to per-route Top-K hot-key tracking that
 	// backs the heatmap drill-down (Phase 2-A++; see
 	// docs/design/2026_05_28_proposed_keyviz_hot_key_topk.md). When
@@ -299,7 +304,7 @@ func (s *MemSampler) graceWindow() time.Duration {
 type routeTable struct {
 	// slots is the live route → slot map. Lookups under the hot path
 	// run against this snapshot.
-	slots map[uint64]*routeSlot
+	slots map[slotKey]*routeSlot
 	// virtualForRoute maps a real RouteID that didn't fit under
 	// MaxTrackedRoutes to its virtual-bucket slot. Observe consults
 	// this fallback when slots[routeID] is missing.
@@ -324,6 +329,7 @@ type routeTable struct {
 type routeSlot struct {
 	metaMu  sync.RWMutex
 	RouteID uint64
+	Label   Label
 	// GroupID is the Raft group this route belongs to. Phase 2-C+
 	// stamps this on every emitted MatrixRow so the cluster fan-out
 	// aggregator can dedupe write samples by (raftGroupID,
@@ -429,6 +435,7 @@ type MatrixColumn struct {
 // taken at flush time.
 type MatrixRow struct {
 	RouteID      uint64
+	Label        Label
 	Start, End   []byte
 	Aggregate    bool
 	MemberRoutes []uint64
@@ -514,17 +521,17 @@ func NewMemSampler(opts MemSamplerOptions) *MemSampler {
 	return s
 }
 
-// HotKeysSnapshot returns the most-recently-published per-route Top-K
+// HotKeysSnapshot returns the most-recently-published per-route/label Top-K
 // snapshot for the given individual route, or nil if hot-keys tracking
 // is disabled, the route is unknown, the route is an aggregate, or no
 // publish has fired yet. Lock-free: an atomic.Pointer.Load (Codex-P1
 // fix from the design's round-4 review — no shared mutable PRNG state,
 // no per-route lock).
-func (s *MemSampler) HotKeysSnapshot(routeID uint64) *KeyvizHotKeysSnapshot {
+func (s *MemSampler) HotKeysSnapshot(routeID uint64, label Label) *KeyvizHotKeysSnapshot {
 	if s == nil {
 		return nil
 	}
-	slot := lookupSlotForRoute(s.table.Load(), routeID)
+	slot := lookupSlotForRoute(s.table.Load(), routeID, label)
 	if slot == nil {
 		return nil
 	}
@@ -543,7 +550,7 @@ func (s *MemSampler) HotKeysOptions() (enabled bool, capacity, sampleRate, maxKe
 }
 
 // SubBucketBoundsFor returns the [lo, hi) key bounds of sub-bucket
-// subBucket within the individual route routeID, mirroring what Flush
+// subBucket within the individual route/label routeID, mirroring what Flush
 // emits as a MatrixRow's Start/End. The admin hot-keys handler uses
 // this to filter the route's top-m snapshot to keys in the
 // drill-down-clicked sub-range (design §5).
@@ -556,11 +563,11 @@ func (s *MemSampler) HotKeysOptions() (enabled bool, capacity, sampleRate, maxKe
 // route's unbounded tail.
 //
 // nil-receiver-safe.
-func (s *MemSampler) SubBucketBoundsFor(routeID uint64, subBucket int) (lo, hi []byte, ok bool) {
+func (s *MemSampler) SubBucketBoundsFor(routeID uint64, label Label, subBucket int) (lo, hi []byte, ok bool) {
 	if s == nil || subBucket < 0 {
 		return nil, nil, false
 	}
-	slot := lookupSlotForRoute(s.table.Load(), routeID)
+	slot := lookupSlotForRoute(s.table.Load(), routeID, label)
 	if slot == nil {
 		return nil, nil, false
 	}
@@ -623,27 +630,33 @@ func (s *MemSampler) snapshotGroupTerms() map[uint64]uint64 {
 
 func newEmptyRouteTable() *routeTable {
 	return &routeTable{
-		slots:           map[uint64]*routeSlot{},
+		slots:           map[slotKey]*routeSlot{},
 		virtualForRoute: map[uint64]*routeSlot{},
 	}
 }
 
+func (s *MemSampler) labelsToCreate() []Label {
+	if s.opts.KeyVizLabelsEnabled {
+		return allLabelsWithLegacy()
+	}
+	return []Label{LabelLegacy}
+}
+
 // Observe records one request against a route. Cost on a hit:
 // atomic.Pointer.Load + plain map lookup + 2× atomic.AddUint64 (count
 // and bytes). Misses (RouteID never registered) drop silently — the
 // route-watch subscriber is responsible for Register before the
 // coordinator publishes the new RouteID.
-func (s *MemSampler) Observe(routeID uint64, key []byte, op Op, valueLen int) {
+func (s *MemSampler) Observe(routeID uint64, key []byte, op Op, valueLen int, label Label) {
 	if s == nil {
 		return
 	}
-	tbl := s.table.Load()
-	slot, ok := tbl.slots[routeID]
-	if !ok {
-		slot, ok = tbl.virtualForRoute[routeID]
-		if !ok {
-			return
-		}
+	if !s.opts.KeyVizLabelsEnabled {
+		label = LabelLegacy
+	}
+	slot := s.table.Load().slotForObservation(routeID, label)
+	if slot == nil {
+		return
 	}
 	// Sub-range bucketing: pick the counter for the key's sub-bucket.
 	// subBucketIndex reads only immutable layout fields (lock-free) and
@@ -672,6 +685,16 @@ func (s *MemSampler) Observe(routeID uint64, key []byte, op Op, valueLen int) {
 	}
 }
 
+func (tbl *routeTable) slotForObservation(routeID uint64, label Label) *routeSlot {
+	if tbl == nil {
+		return nil
+	}
+	if slot := tbl.slots[slotKey{RouteID: routeID, Label: label}]; slot != nil {
+		return slot
+	}
+	return tbl.virtualForRoute[routeID]
+}
+
 // observeHotKey is the per-Observe hot-key sampler dispatch, kept out of
 // Observe itself to stay under the cyclop ceiling. v1 tracks WRITES
 // only (design §5 series-picker note); reads follow in v2 once the
@@ -683,7 +706,7 @@ func (s *MemSampler) observeHotKey(routeID uint64, slot *routeSlot, key []byte)
 	if s.hotKeys == nil || slot.Aggregate {
 		return
 	}
-	s.hotKeys.observe(routeID, key)
+	s.hotKeys.observe(routeID, slot.Label, key)
 }
 
 // subBucketIndex maps key to a sub-range bucket index in
@@ -967,7 +990,7 @@ func (s *MemSampler) RegisterRoute(routeID uint64, start, end []byte, groupID ui
 	defer s.routesMu.Unlock()
 
 	cur := s.table.Load()
-	if _, ok := cur.slots[routeID]; ok {
+	if _, ok := cur.slots[slotKey{RouteID: routeID, Label: LabelLegacy}]; ok {
 		return true
 	}
 	if _, ok := cur.virtualForRoute[routeID]; ok {
@@ -975,45 +998,39 @@ func (s *MemSampler) RegisterRoute(routeID uint64, start, end []byte, groupID ui
 	}
 
 	next := copyRouteTable(cur)
-	if len(next.slots) < s.opts.MaxTrackedRoutes {
-		slot := s.reclaimRetiredSlot(routeID)
-		if slot == nil {
-			slot = &routeSlot{
-				RouteID:           routeID,
-				GroupID:           groupID,
-				Start:             cloneBytes(start),
-				End:               cloneBytes(end),
-				MemberRoutesTotal: 1,
+	slotsPerRoute := 1
+	if s.opts.KeyVizLabelsEnabled {
+		slotsPerRoute = len(AllLabels) + 1
+	}
+	if len(next.slots)/slotsPerRoute < s.opts.MaxTrackedRoutes {
+		for _, label := range s.labelsToCreate() {
+			slot := s.reclaimRetiredSlot(routeID, label)
+			if slot == nil {
+				slot = &routeSlot{
+					RouteID:           routeID,
+					Label:             label,
+					GroupID:           groupID,
+					Start:             cloneBytes(start),
+					End:               cloneBytes(end),
+					MemberRoutesTotal: 1,
+				}
+				s.initSubLayout(slot, start, end)
+			} else {
+				// Re-registering the same (routeID, label) inside the
+				// grace window reuses the retired slot so in-flight
+				// Observe writers and new traffic drain through one
+				// slot. The immutable sub-range layout is intentionally
+				// preserved; see design §4.2.
+				slot.metaMu.Lock()
+				slot.GroupID = groupID
+				slot.Start = cloneBytes(start)
+				slot.End = cloneBytes(end)
+				slot.MemberRoutesTotal = 1
+				slot.metaMu.Unlock()
 			}
-			s.initSubLayout(slot, start, end)
-		} else {
-			// Re-registering the same routeID inside the grace window:
-			// reuse the retired slot so any in-flight Observe writers
-			// hitting the prior table snapshot land on the same slot
-			// the new traffic uses, and Flush emits a single row per
-			// RouteID instead of two (one live + one retired) with
-			// counts split across them. Refresh the metadata fields to
-			// match the new registration; counters are preserved.
-			//
-			// The sub-range layout (subPrefixLen/subStart/subEnd/subSpan
-			// + subBuckets) is intentionally NOT recomputed here: it is
-			// immutable for the slot's lifetime so the lock-free hot path
-			// can read it without racing this writer, and the counters
-			// must be preserved (not zeroed/resized) to honour the
-			// no-loss contract. A same-RouteID re-registration carries
-			// the same range in practice; the rare changed-range case
-			// keeps the original sub-ranges for the reused slot's
-			// lifetime — a bounded cosmetic mislabel, no lost counts.
-			// See design §4.2.
-			slot.metaMu.Lock()
-			slot.GroupID = groupID
-			slot.Start = cloneBytes(start)
-			slot.End = cloneBytes(end)
-			slot.MemberRoutesTotal = 1
-			slot.metaMu.Unlock()
+			next.slots[slotKey{RouteID: routeID, Label: label}] = slot
+			next.sortedSlots = appendSorted(next.sortedSlots, slot)
 		}
-		next.slots[routeID] = slot
-		next.sortedSlots = appendSorted(next.sortedSlots, slot)
 		s.table.Store(next)
 		return true
 	}
@@ -1025,6 +1042,10 @@ func (s *MemSampler) RegisterRoute(routeID uint64, start, end []byte, groupID ui
 	// for the exact selection.
 	bucket := findVirtualBucket(next.sortedSlots, start)
 	if bucket == nil {
+		slog.Warn("keyviz route coarsened into virtual bucket",
+			slog.Uint64("route_id", routeID),
+			slog.Int("max_tracked_routes", s.opts.MaxTrackedRoutes),
+		)
 		bucket = &routeSlot{
 			RouteID:           s.nextVirtualBucketID(),
 			Start:             cloneBytes(start),
@@ -1115,14 +1136,17 @@ func (s *MemSampler) RemoveRoute(routeID uint64) {
 	s.routesMu.Lock()
 	defer s.routesMu.Unlock()
 	cur := s.table.Load()
-	individual, isIndividual := cur.slots[routeID]
+	individualSlots := s.individualSlotsForRoute(cur, routeID)
+	isIndividual := len(individualSlots) > 0
 	bucket, isVirtual := cur.virtualForRoute[routeID]
 	if !isIndividual && !isVirtual {
 		return
 	}
 
 	next := copyRouteTable(cur)
-	delete(next.slots, routeID)
+	for _, slot := range individualSlots {
+		delete(next.slots, slotKey{RouteID: routeID, Label: slot.Label})
+	}
 	delete(next.virtualForRoute, routeID)
 
 	retiredAt := s.now()
@@ -1135,7 +1159,9 @@ func (s *MemSampler) RemoveRoute(routeID uint64) {
 		// in-flight write is caught by a later drain rather than
 		// silently lost.
 		s.retiredMu.Lock()
-		s.retiredSlots = append(s.retiredSlots, retiredSlot{slot: individual, retiredAt: retiredAt})
+		for _, slot := range individualSlots {
+			s.retiredSlots = append(s.retiredSlots, retiredSlot{slot: slot, retiredAt: retiredAt})
+		}
 		s.retiredMu.Unlock()
 	case isVirtual:
 		// Defer pruning until after the bucket's pre-removal counters
@@ -1284,22 +1310,22 @@ func (s *MemSampler) nextVirtualBucketID() uint64 {
 }
 
 // reclaimRetiredSlot looks for a non-aggregate retired slot whose
-// RouteID matches the supplied routeID and, if found, removes it
+// (RouteID, Label) matches the supplied key and, if found, removes it
 // from retiredSlots and returns it for reuse. This guarantees a
-// route removed and re-registered inside the grace window is
+// route/label removed and re-registered inside the grace window is
 // represented by a single *routeSlot — Flush would otherwise emit
-// two rows with the same RouteID (one from the new live slot, one
+// two rows with the same (RouteID, Label) (one from the new live slot, one
 // from the still-draining retired slot) and split counts across
 // them. Aggregate (orphaned virtual bucket) entries are left in
 // place because their RouteID lives in the synthetic namespace and
 // a real-ID match against an aggregate would be coincidental.
-func (s *MemSampler) reclaimRetiredSlot(routeID uint64) *routeSlot {
+func (s *MemSampler) reclaimRetiredSlot(routeID uint64, label Label) *routeSlot {
 	s.retiredMu.Lock()
 	defer s.retiredMu.Unlock()
 	var reclaimed *routeSlot
 	keep := s.retiredSlots[:0]
 	for _, r := range s.retiredSlots {
-		if reclaimed == nil && !r.slot.Aggregate && r.slot.RouteID == routeID {
+		if reclaimed == nil && !r.slot.Aggregate && r.slot.RouteID == routeID && r.slot.Label == label {
 			reclaimed = r.slot
 			continue
 		}
@@ -1310,6 +1336,19 @@ func (s *MemSampler) reclaimRetiredSlot(routeID uint64) *routeSlot {
 	return reclaimed
 }
 
+func (s *MemSampler) individualSlotsForRoute(tbl *routeTable, routeID uint64) []*routeSlot {
+	if tbl == nil {
+		return nil
+	}
+	out := make([]*routeSlot, 0, len(AllLabels)+1)
+	for _, label := range allLabelsWithLegacy() {
+		if slot := tbl.slots[slotKey{RouteID: routeID, Label: label}]; slot != nil {
+			out = append(out, slot)
+		}
+	}
+	return out
+}
+
 // memberRoutesContains reports whether routeID is already listed in
 // members. Used as a dedup guard so re-registering a routeID inside
 // the prune grace window doesn't add a duplicate MemberRoutes entry.
@@ -1436,6 +1475,7 @@ func appendDrainedRow(rows []MatrixRow, slot *routeSlot, terms map[uint64]uint64
 		}
 		rows = append(rows, MatrixRow{
 			RouteID:           slot.RouteID,
+			Label:             slot.Label,
 			RaftGroupID:       groupID,
 			LeaderTerm:        terms[groupID],
 			Start:             rowStart,
@@ -1473,7 +1513,7 @@ func (s *MemSampler) Snapshot(from, to time.Time) []MatrixColumn {
 
 func copyRouteTable(src *routeTable) *routeTable {
 	dst := &routeTable{
-		slots:           make(map[uint64]*routeSlot, len(src.slots)+1),
+		slots:           make(map[slotKey]*routeSlot, len(src.slots)+1),
 		virtualForRoute: make(map[uint64]*routeSlot, len(src.virtualForRoute)+1),
 		sortedSlots:     append([]*routeSlot(nil), src.sortedSlots...),
 	}
@@ -1488,7 +1528,7 @@ func copyRouteTable(src *routeTable) *routeTable {
 
 func appendSorted(slots []*routeSlot, slot *routeSlot) []*routeSlot {
 	idx := sort.Search(len(slots), func(i int) bool {
-		return bytesGE(slots[i].Start, slot.Start)
+		return routeSlotLessOrEqual(slot, slots[i])
 	})
 	slots = append(slots, nil)
 	copy(slots[idx+1:], slots[idx:])
@@ -1496,6 +1536,20 @@ func appendSorted(slots []*routeSlot, slot *routeSlot) []*routeSlot {
 	return slots
 }
 
+func routeSlotLess(a, b *routeSlot) bool {
+	if c := bytes.Compare(a.Start, b.Start); c != 0 {
+		return c < 0
+	}
+	if a.RouteID != b.RouteID {
+		return a.RouteID < b.RouteID
+	}
+	return a.Label < b.Label
+}
+
+func routeSlotLessOrEqual(a, b *routeSlot) bool {
+	return !routeSlotLess(b, a)
+}
+
 func rebuildSorted(tbl *routeTable) []*routeSlot {
 	out := make([]*routeSlot, 0, len(tbl.slots)+len(tbl.virtualForRoute))
 	seen := make(map[*routeSlot]struct{}, cap(out))
@@ -1513,9 +1567,7 @@ func rebuildSorted(tbl *routeTable) []*routeSlot {
 		seen[s] = struct{}{}
 		out = append(out, s)
 	}
-	sort.Slice(out, func(i, j int) bool {
-		return bytesLT(out[i].Start, out[j].Start)
-	})
+	sort.Slice(out, func(i, j int) bool { return routeSlotLess(out[i], out[j]) })
 	return out
 }
 
@@ -1554,4 +1606,3 @@ func cloneBytes(b []byte) []byte {
 func bytesLT(a, b []byte) bool { return bytes.Compare(a, b) < 0 }
 func bytesLE(a, b []byte) bool { return bytes.Compare(a, b) <= 0 }
 func bytesGT(a, b []byte) bool { return bytes.Compare(a, b) > 0 }
-func bytesGE(a, b []byte) bool { return bytes.Compare(a, b) >= 0 }
diff --git a/keyviz/sampler_subrange_test.go b/keyviz/sampler_subrange_test.go
index 67a10328f..755046f1d 100644
--- a/keyviz/sampler_subrange_test.go
+++ b/keyviz/sampler_subrange_test.go
@@ -167,7 +167,7 @@ func TestSamplerUnboundedRouteEmitsSubRanges(t *testing.T) {
 	s := NewMemSampler(MemSamplerOptions{Step: time.Second, HistoryColumns: 4, KeyBucketsPerRoute: 4})
 	require.True(t, s.RegisterRoute(1, nil, nil, 0)) // whole keyspace, unbounded both ends
 	for _, key := range [][]byte{{0x10}, {0x50}, {0x90}, {0xD0}} {
-		s.Observe(1, key, OpWrite, 0)
+		s.Observe(1, key, OpWrite, 0, LabelLegacy)
 	}
 	s.Flush()
 	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
@@ -190,7 +190,7 @@ func TestSamplerUnboundedHighStartValidBounds(t *testing.T) {
 	start := []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF} // window 0xFF..FD + suffix
 	require.True(t, s.RegisterRoute(1, start, nil, 0))
 	for _, key := range [][]byte{start, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE}} {
-		s.Observe(1, key, OpWrite, 0)
+		s.Observe(1, key, OpWrite, 0, LabelLegacy)
 	}
 	s.Flush()
 	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
@@ -291,9 +291,9 @@ func TestSamplerSubRangeHotKeyOnDistinctRow(t *testing.T) {
 
 	// 100 writes into sub-bucket 3 ([0x30,0x40)), 1 into sub-bucket 0.
 	for i := 0; i < 100; i++ {
-		s.Observe(1, []byte{0x38}, OpWrite, 0)
+		s.Observe(1, []byte{0x38}, OpWrite, 0, LabelLegacy)
 	}
-	s.Observe(1, []byte{0x01}, OpWrite, 0)
+	s.Observe(1, []byte{0x01}, OpWrite, 0, LabelLegacy)
 	s.Flush()
 
 	cols := s.Snapshot(time.Time{}, time.Time{})
@@ -323,7 +323,7 @@ func TestSamplerSubRangeBoundsTileExactly(t *testing.T) {
 	require.True(t, s.RegisterRoute(1, routeStart, routeEnd, 0))
 	// Hit every sub-bucket so all K rows are emitted.
 	for _, key := range [][]byte{{0x00}, {0x10}, {0x20}, {0x30}} {
-		s.Observe(1, key, OpWrite, 0)
+		s.Observe(1, key, OpWrite, 0, LabelLegacy)
 	}
 	s.Flush()
 	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
@@ -349,15 +349,15 @@ func TestSamplerGraceWindowReRegistrationKeepsStaleLayout(t *testing.T) {
 
 	rangeAStart, rangeAEnd := []byte{0x00}, []byte{0x40}
 	require.True(t, s.RegisterRoute(1, rangeAStart, rangeAEnd, 0))
-	origStart := s.table.Load().slots[1].subStart
-	origSpan := s.table.Load().slots[1].subSpan
-	s.Observe(1, []byte{0x10}, OpWrite, 0)
+	origStart := s.table.Load().slots[slotKey{RouteID: 1, Label: LabelLegacy}].subStart
+	origSpan := s.table.Load().slots[slotKey{RouteID: 1, Label: LabelLegacy}].subSpan
+	s.Observe(1, []byte{0x10}, OpWrite, 0, LabelLegacy)
 
 	// Remove + re-register with a DIFFERENT range, inside the grace
 	// window -> reclaimRetiredSlot reuses the slot, layout unchanged.
 	s.RemoveRoute(1)
 	require.True(t, s.RegisterRoute(1, []byte{0x80}, []byte{0xC0}, 0))
-	reused := s.table.Load().slots[1]
+	reused := s.table.Load().slots[slotKey{RouteID: 1, Label: LabelLegacy}]
 	require.Equal(t, origStart, reused.subStart, "layout subStart must NOT be recomputed on in-grace re-registration")
 	require.Equal(t, origSpan, reused.subSpan, "layout subSpan must NOT be recomputed")
 
@@ -372,7 +372,7 @@ func TestSamplerGraceWindowReRegistrationKeepsStaleLayout(t *testing.T) {
 	clk.Advance(s.graceWindow() + time.Second)
 	s.Flush() // drop the retired slot
 	require.True(t, s.RegisterRoute(1, []byte{0x80}, []byte{0xC0}, 0))
-	fresh := s.table.Load().slots[1]
+	fresh := s.table.Load().slots[slotKey{RouteID: 1, Label: LabelLegacy}]
 	freshStart := windowUint64([]byte{0x80}, 0)
 	require.Equal(t, freshStart, fresh.subStart, "fresh post-grace registration must use the new range's layout")
 }
@@ -385,7 +385,7 @@ func TestSamplerK1MatchesRouteLevel(t *testing.T) {
 	s := NewMemSampler(MemSamplerOptions{Step: time.Second, HistoryColumns: 4, KeyBucketsPerRoute: 1})
 	require.True(t, s.RegisterRoute(1, []byte{0x00}, []byte{0xFF}, 0))
 	for _, key := range [][]byte{{0x01}, {0x80}, {0xFE}} {
-		s.Observe(1, key, OpWrite, 0)
+		s.Observe(1, key, OpWrite, 0, LabelLegacy)
 	}
 	s.Flush()
 	rows := s.Snapshot(time.Time{}, time.Time{})[0].Rows
@@ -421,7 +421,7 @@ func BenchmarkObserveSubRange(b *testing.B) {
 			b.ReportAllocs()
 			b.ResetTimer()
 			for i := 0; i < b.N; i++ {
-				s.Observe(1, key, OpWrite, 64)
+				s.Observe(1, key, OpWrite, 64, LabelLegacy)
 			}
 		})
 	}
diff --git a/keyviz/sampler_test.go b/keyviz/sampler_test.go
index 54270e5b7..674c757dc 100644
--- a/keyviz/sampler_test.go
+++ b/keyviz/sampler_test.go
@@ -36,7 +36,7 @@ func (c *fakeClock) Advance(d time.Duration) {
 func TestNilSamplerObserveSafe(t *testing.T) {
 	t.Parallel()
 	var s *MemSampler // nil
-	s.Observe(1, make([]byte, 10), OpRead, 20)
+	s.Observe(1, make([]byte, 10), OpRead, 20, LabelLegacy)
 	if s.RegisterRoute(1, []byte("a"), []byte("b"), 0) {
 		t.Fatal("nil RegisterRoute should return false")
 	}
@@ -53,9 +53,9 @@ func TestObserveAndFlushBasic(t *testing.T) {
 	if !s.RegisterRoute(1, []byte("a"), []byte("c"), 0) {
 		t.Fatal("RegisterRoute(1) returned false")
 	}
-	s.Observe(1, make([]byte, 5), OpRead, 10)
-	s.Observe(1, make([]byte, 5), OpRead, 10)
-	s.Observe(1, make([]byte, 5), OpWrite, 100)
+	s.Observe(1, make([]byte, 5), OpRead, 10, LabelLegacy)
+	s.Observe(1, make([]byte, 5), OpRead, 10, LabelLegacy)
+	s.Observe(1, make([]byte, 5), OpWrite, 100, LabelLegacy)
 
 	s.Flush()
 	clk.Advance(time.Second)
@@ -106,7 +106,7 @@ func TestNoCountsLostAcrossFlush(t *testing.T) {
 					return
 				default:
 				}
-				s.Observe(1, make([]byte, 1), OpRead, 0)
+				s.Observe(1, make([]byte, 1), OpRead, 0, LabelLegacy)
 			}
 		}()
 	}
@@ -141,9 +141,9 @@ func TestNoCountsLostAcrossFlush(t *testing.T) {
 func TestRouteBudgetCoarsensIntoVirtualBucket(t *testing.T) {
 	t.Parallel()
 	s := budgetSetup(t)
-	s.Observe(1, make([]byte, 1), OpRead, 0)
-	s.Observe(2, make([]byte, 1), OpRead, 0)
-	s.Observe(3, make([]byte, 1), OpRead, 0)
+	s.Observe(1, make([]byte, 1), OpRead, 0, LabelLegacy)
+	s.Observe(2, make([]byte, 1), OpRead, 0, LabelLegacy)
+	s.Observe(3, make([]byte, 1), OpRead, 0, LabelLegacy)
 	s.Flush()
 	rows := budgetSingleColumnRows(t, s)
 	agg := findAggregateRow(t, rows)
@@ -200,7 +200,7 @@ func TestSnapshotRangeFilters(t *testing.T) {
 	s, clk := newTestSampler(t, MemSamplerOptions{Step: time.Second, HistoryColumns: 8})
 	s.RegisterRoute(1, []byte("a"), []byte("b"), 0)
 	for i := 0; i < 5; i++ {
-		s.Observe(1, make([]byte, 0), OpRead, 0)
+		s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
 		s.Flush()
 		clk.Advance(time.Second)
 	}
@@ -224,7 +224,7 @@ func TestRingBufferDropsOldest(t *testing.T) {
 	s, clk := newTestSampler(t, MemSamplerOptions{Step: time.Second, HistoryColumns: 3})
 	s.RegisterRoute(1, []byte("a"), []byte("b"), 0)
 	for i := 0; i < 5; i++ {
-		s.Observe(1, make([]byte, 0), OpRead, 0)
+		s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
 		s.Flush()
 		clk.Advance(time.Second)
 	}
@@ -244,9 +244,9 @@ func TestRemoveRouteSilencesObserve(t *testing.T) {
 	t.Parallel()
 	s, _ := newTestSampler(t, MemSamplerOptions{Step: time.Second, HistoryColumns: 4})
 	s.RegisterRoute(1, []byte("a"), []byte("b"), 0)
-	s.Observe(1, make([]byte, 0), OpRead, 0)
+	s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.RemoveRoute(1)
-	s.Observe(1, make([]byte, 0), OpRead, 0) // silently dropped
+	s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy) // silently dropped
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	for _, c := range cols {
@@ -266,7 +266,7 @@ func TestRemoveRouteHarvestsPendingCounts(t *testing.T) {
 	s, _ := newTestSampler(t, MemSamplerOptions{Step: time.Second, HistoryColumns: 4})
 	s.RegisterRoute(1, []byte("a"), []byte("b"), 0)
 	for i := 0; i < 7; i++ {
-		s.Observe(1, make([]byte, 1), OpRead, 0)
+		s.Observe(1, make([]byte, 1), OpRead, 0, LabelLegacy)
 	}
 	// Remove BEFORE flushing — pending 7 reads must surface.
 	s.RemoveRoute(1)
@@ -296,12 +296,12 @@ func TestRemoveVirtualMemberPrunesMemberRoutes(t *testing.T) {
 	// Drain at least once within grace, then advance past grace so the
 	// next Flush actually executes the prune. One more Flush captures
 	// the post-prune MemberRoutes state in a row.
-	s.Observe(3, make([]byte, 1), OpRead, 0)
+	s.Observe(3, make([]byte, 1), OpRead, 0, LabelLegacy)
 	s.Flush()
 	clk.Advance(s.graceWindow() + time.Second)
-	s.Observe(3, make([]byte, 1), OpRead, 0)
+	s.Observe(3, make([]byte, 1), OpRead, 0, LabelLegacy)
 	s.Flush()
-	s.Observe(3, make([]byte, 1), OpRead, 0)
+	s.Observe(3, make([]byte, 1), OpRead, 0, LabelLegacy)
 	s.Flush()
 
 	agg := findAggregateRow(t, lastSnapshotColumn(t, s).Rows)
@@ -325,7 +325,7 @@ func TestRemoveVirtualMemberPruneDeferred(t *testing.T) {
 	// so each Flush sees now-retiredAt == 0 < grace and keeps the
 	// prune entry.
 	for i := 0; i < 2; i++ {
-		s.Observe(3, make([]byte, 1), OpRead, 0)
+		s.Observe(3, make([]byte, 1), OpRead, 0, LabelLegacy)
 		s.Flush()
 		col := lastSnapshotColumn(t, s)
 		agg := findAggregateRow(t, col.Rows)
@@ -427,7 +427,7 @@ func TestRegisterDoesNotRaceFlushOnVirtualBucket(t *testing.T) {
 func TestObserveOnUnknownRouteIsNoop(t *testing.T) {
 	t.Parallel()
 	s, _ := newTestSampler(t, MemSamplerOptions{Step: time.Second, HistoryColumns: 4})
-	s.Observe(42, make([]byte, 0), OpRead, 0)
+	s.Observe(42, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	for _, c := range cols {
@@ -467,7 +467,7 @@ func TestConcurrentRegisterAndObserveRace(t *testing.T) {
 				default:
 				}
 				for i := uint64(1); i <= routes; i++ {
-					s.Observe(i, make([]byte, 0), OpRead, 0)
+					s.Observe(i, make([]byte, 0), OpRead, 0, LabelLegacy)
 					observed.Add(1)
 				}
 			}
@@ -507,7 +507,7 @@ func TestRemoveLastVirtualMemberHarvestsBucket(t *testing.T) {
 	if s.RegisterRoute(2, []byte("c"), []byte("d"), 0) {
 		t.Fatal("route 2 over budget should fold into virtual bucket")
 	}
-	s.Observe(2, make([]byte, 5), OpRead, 7)
+	s.Observe(2, make([]byte, 5), OpRead, 7, LabelLegacy)
 	s.RemoveRoute(2)
 	s.Flush()
 
@@ -530,10 +530,10 @@ func TestFlushSortsMixedLiveAndRetiredRows(t *testing.T) {
 	mustRegister(t, s, 1, "a", "b")
 	mustRegister(t, s, 2, "m", "n")
 	mustRegister(t, s, 3, "z", "{")
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.RemoveRoute(2)
-	s.Observe(1, make([]byte, 0), OpRead, 0)
-	s.Observe(3, make([]byte, 0), OpRead, 0)
+	s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
+	s.Observe(3, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 	flushedRowsSorted(t, s)
 }
@@ -551,7 +551,7 @@ func TestRetiredSlotGracePeriod(t *testing.T) {
 	if !s.RegisterRoute(1, []byte("a"), []byte("b"), 0) {
 		t.Fatal("RegisterRoute(1) returned false")
 	}
-	s.Observe(1, make([]byte, 1), OpRead, 2)
+	s.Observe(1, make([]byte, 1), OpRead, 2, LabelLegacy)
 	s.RemoveRoute(1)
 
 	lateSlot := graceQueueSingleSlot(t, s)
@@ -619,10 +619,10 @@ func TestRegisterFoldLowerStartReorders(t *testing.T) {
 	if s.RegisterRoute(4, []byte("a"), []byte("b"), 0) {
 		t.Fatal("route 4 over budget should fold into virtual bucket")
 	}
-	s.Observe(1, make([]byte, 0), OpRead, 0)
-	s.Observe(2, make([]byte, 0), OpRead, 0)
-	s.Observe(3, make([]byte, 0), OpRead, 0)
-	s.Observe(4, make([]byte, 0), OpRead, 0)
+	s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
+	s.Observe(3, make([]byte, 0), OpRead, 0, LabelLegacy)
+	s.Observe(4, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 
 	rows := flushedRowsSorted(t, s)
@@ -665,7 +665,7 @@ func TestSnapshotReturnsDeepCopy(t *testing.T) {
 	if !s.RegisterRoute(1, []byte("aaaa"), []byte("bbbb"), 0) {
 		t.Fatal("RegisterRoute(1) returned false")
 	}
-	s.Observe(1, make([]byte, 1), OpRead, 2)
+	s.Observe(1, make([]byte, 1), OpRead, 2, LabelLegacy)
 	s.Flush()
 
 	first := s.Snapshot(time.Time{}, time.Time{})
@@ -702,7 +702,7 @@ func TestVirtualBucketRouteIDIsSynthetic(t *testing.T) {
 	if s.RegisterRoute(2, []byte("c"), []byte("d"), 0) {
 		t.Fatal("route 2 should fold into a fresh virtual bucket")
 	}
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 
 	rows := lastSnapshotColumn(t, s).Rows
@@ -739,8 +739,8 @@ func TestRejoinAsIndividualLetsBucketPruneFire(t *testing.T) {
 	if s.RegisterRoute(3, []byte("y"), []byte("z"), 0) {
 		t.Fatal("route 3 should fold (same bucket)")
 	}
-	s.Observe(2, make([]byte, 0), OpRead, 0)
-	s.Observe(3, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
+	s.Observe(3, make([]byte, 0), OpRead, 0, LabelLegacy)
 	// Free capacity (route 1) and remove the virtual member (route 3),
 	// which queues a prune against the bucket. Route 2 still keeps the
 	// bucket alive in virtualForRoute.
@@ -753,9 +753,9 @@ func TestRejoinAsIndividualLetsBucketPruneFire(t *testing.T) {
 	// Two flushes after grace: the first executes the prune, the
 	// second emits a row with the post-prune MemberRoutes.
 	clk.Advance(s.graceWindow() + time.Second)
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 
 	rows := lastSnapshotColumn(t, s).Rows
@@ -779,10 +779,10 @@ func TestReRegisterIndividualReusesRetiredSlot(t *testing.T) {
 		HistoryColumns: 4,
 	})
 	mustRegister(t, s, 1, "a", "b")
-	s.Observe(1, make([]byte, 0), OpRead, 0)
+	s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.RemoveRoute(1)
 	mustRegister(t, s, 1, "a", "b")
-	s.Observe(1, make([]byte, 0), OpRead, 0)
+	s.Observe(1, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 
 	rows := lastSnapshotColumn(t, s).Rows
@@ -824,7 +824,7 @@ func TestReRegisterDuringPruneGraceCancelsPrune(t *testing.T) {
 	}
 
 	clk.Advance(s.graceWindow() + time.Second)
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 
 	rows := lastSnapshotColumn(t, s).Rows
@@ -855,7 +855,7 @@ func TestRegisterRouteCarriesGroupID(t *testing.T) {
 	if !s.RegisterRoute(1, []byte("a"), []byte("b"), 42) {
 		t.Fatal("RegisterRoute returned false")
 	}
-	s.Observe(1, make([]byte, 16), OpWrite, 64)
+	s.Observe(1, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	if len(cols) != 1 || len(cols[0].Rows) != 1 {
@@ -878,12 +878,12 @@ func TestSetLeaderTermStampsRows(t *testing.T) {
 		t.Fatal("RegisterRoute returned false")
 	}
 	s.SetLeaderTerm(7, 100)
-	s.Observe(1, make([]byte, 16), OpWrite, 64)
+	s.Observe(1, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	s.Flush()
 	clk.Advance(time.Second)
 
 	s.SetLeaderTerm(7, 101)
-	s.Observe(1, make([]byte, 16), OpWrite, 64)
+	s.Observe(1, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	s.Flush()
 
 	cols := s.Snapshot(time.Time{}, time.Time{})
@@ -919,7 +919,7 @@ func TestSetLeaderTermZeroGroupIDDoesNotPolluteVirtualBucket(t *testing.T) {
 	t.Parallel()
 	s, _ := setupOneIndividualPlusVirtualBucket(t)
 	s.SetLeaderTerm(0, 999) // bug case: caller passes the reserved groupID
-	s.Observe(2, make([]byte, 16), OpWrite, 64)
+	s.Observe(2, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	if len(cols) == 0 {
@@ -963,7 +963,7 @@ func TestVirtualBucketRaftGroupIDIsZero(t *testing.T) {
 	if s.RegisterRoute(2, []byte("c"), []byte("d"), 42) {
 		t.Fatal("route 2 should fold into virtual bucket (group 42, over budget)")
 	}
-	s.Observe(2, make([]byte, 16), OpWrite, 64)
+	s.Observe(2, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	if len(cols) == 0 {
@@ -999,7 +999,7 @@ func TestRegisterRouteSecondCallIgnoresGroupID(t *testing.T) {
 	if !s.RegisterRoute(1, []byte("a"), []byte("b"), 99) {
 		t.Fatal("second RegisterRoute should be a no-op returning true")
 	}
-	s.Observe(1, make([]byte, 16), OpWrite, 64)
+	s.Observe(1, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	if len(cols) != 1 || len(cols[0].Rows) != 1 {
@@ -1094,7 +1094,7 @@ func TestMemberRoutesCappedAtConfiguredCap(t *testing.T) {
 		if s.RegisterRoute(i, key, append(key, 'z'), 0) {
 			t.Fatalf("route %d should fold (over budget)", i)
 		}
-		s.Observe(i, make([]byte, 1), OpRead, 0)
+		s.Observe(i, make([]byte, 1), OpRead, 0, LabelLegacy)
 	}
 	s.Flush()
 	rows := lastSnapshotColumn(t, s).Rows
@@ -1136,7 +1136,7 @@ func TestPastCapMemberRejoinDoesNotInflateTotal(t *testing.T) {
 	if s.RegisterRoute(4, []byte("g"), []byte("h"), 0) {
 		t.Fatal("route 4 should fold (hidden — past cap)")
 	}
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 	beforeTotal := findAggregateRow(t, lastSnapshotColumn(t, s).Rows).MemberRoutesTotal
 	if beforeTotal != 3 {
@@ -1149,7 +1149,7 @@ func TestPastCapMemberRejoinDoesNotInflateTotal(t *testing.T) {
 	if s.RegisterRoute(3, []byte("e"), []byte("f"), 0) {
 		t.Fatal("route 3 should fold again")
 	}
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 	afterTotal := findAggregateRow(t, lastSnapshotColumn(t, s).Rows).MemberRoutesTotal
 	if afterTotal != 3 {
@@ -1176,11 +1176,11 @@ func TestPastCapMemberPruneDecrementsTotal(t *testing.T) {
 	if s.RegisterRoute(3, []byte("e"), []byte("f"), 0) {
 		t.Fatal("route 3 should fold (hidden — past cap)")
 	}
-	s.Observe(2, make([]byte, 0), OpRead, 0)
+	s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 	s.Flush()
 	require := func(want uint64, ctx string) {
 		t.Helper()
-		s.Observe(2, make([]byte, 0), OpRead, 0)
+		s.Observe(2, make([]byte, 0), OpRead, 0, LabelLegacy)
 		s.Flush()
 		got := findAggregateRow(t, lastSnapshotColumn(t, s).Rows).MemberRoutesTotal
 		if got != want {
@@ -1206,7 +1206,7 @@ func TestRetiredTailClearedAfterDrop(t *testing.T) {
 	t.Parallel()
 	s, clk := newTestSampler(t, MemSamplerOptions{Step: time.Second, HistoryColumns: 4})
 	mustRegister(t, s, 1, "a", "b")
-	s.Observe(1, make([]byte, 1), OpRead, 1)
+	s.Observe(1, make([]byte, 1), OpRead, 1, LabelLegacy)
 	s.RemoveRoute(1)
 
 	s.retiredMu.Lock()
@@ -1244,7 +1244,7 @@ func BenchmarkObserveHit(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		s.Observe(1, make([]byte, 16), OpRead, 64)
+		s.Observe(1, make([]byte, 16), OpRead, 64, LabelLegacy)
 	}
 }
 
@@ -1256,7 +1256,7 @@ func BenchmarkObserveMiss(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		s.Observe(99, make([]byte, 16), OpRead, 64)
+		s.Observe(99, make([]byte, 16), OpRead, 64, LabelLegacy)
 	}
 }
 
@@ -1294,7 +1294,7 @@ func BenchmarkObserveParallel(b *testing.B) {
 		shardBase := (shardIndex * routesPerShard) % numRoutes
 		var i uint64
 		for pb.Next() {
-			s.Observe(shardBase+(i%routesPerShard)+1, make([]byte, 16), OpWrite, 64)
+			s.Observe(shardBase+(i%routesPerShard)+1, make([]byte, 16), OpWrite, 64, LabelLegacy)
 			i++
 		}
 	})
@@ -1361,7 +1361,7 @@ func BenchmarkFlush(b *testing.B) {
 			b.Fatalf("RegisterRoute(%d) returned false", r)
 		}
 		// Pre-seed every slot with traffic so the first Flush has work to swap.
-		s.Observe(r, make([]byte, 16), OpWrite, 64)
+		s.Observe(r, make([]byte, 16), OpWrite, 64, LabelLegacy)
 	}
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -1371,7 +1371,7 @@ func BenchmarkFlush(b *testing.B) {
 		clk.Advance(time.Second)
 		// Reseed so the next Flush still has counters to drain.
 		for r := uint64(1); r <= numRoutes; r++ {
-			s.Observe(r, make([]byte, 16), OpWrite, 64)
+			s.Observe(r, make([]byte, 16), OpWrite, 64, LabelLegacy)
 		}
 		b.StartTimer()
 	}
@@ -1401,7 +1401,7 @@ func BenchmarkSnapshot(b *testing.B) {
 	}
 	for c := 0; c < numColumns; c++ {
 		for r := uint64(1); r <= numRoutes; r++ {
-			s.Observe(r, make([]byte, 16), OpWrite, 64)
+			s.Observe(r, make([]byte, 16), OpWrite, 64, LabelLegacy)
 		}
 		s.Flush()
 		clk.Advance(time.Second)
@@ -1500,7 +1500,7 @@ func runConcurrentBurst(s *MemSampler, numRoutes uint64, writersPerRoute, opsPer
 				ready.Done()
 				start.Wait()
 				for op := 0; op < opsPerWriter; op++ {
-					s.Observe(routeID, make([]byte, keyLen), OpWrite, valueLen)
+					s.Observe(routeID, make([]byte, keyLen), OpWrite, valueLen, LabelLegacy)
 				}
 			}()
 		}
diff --git a/kv/keyviz_label.go b/kv/keyviz_label.go
new file mode 100644
index 000000000..eb1949076
--- /dev/null
+++ b/kv/keyviz_label.go
@@ -0,0 +1,125 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/bootjp/elastickv/keyviz"
+	"github.com/cockroachdb/errors"
+)
+
+type keyVizLabelContextKey struct{}
+
+func contextWithKeyVizLabel(ctx context.Context, label keyviz.Label) context.Context {
+	if label == keyviz.LabelLegacy {
+		return ctx
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, keyVizLabelContextKey{}, label)
+}
+
+func keyVizLabelFromContext(ctx context.Context) keyviz.Label {
+	if ctx == nil {
+		return keyviz.LabelLegacy
+	}
+	label, _ := ctx.Value(keyVizLabelContextKey{}).(keyviz.Label)
+	return label
+}
+
+// WithKeyVizLabel returns a Coordinator wrapper that stamps all dispatches and
+// key-routed lease reads with the supplied adapter label.
+func WithKeyVizLabel(c Coordinator, label keyviz.Label) Coordinator {
+	if c == nil || label == keyviz.LabelLegacy {
+		return c
+	}
+	return keyVizLabeledCoordinator{inner: c, label: label}
+}
+
+type keyVizLabeledCoordinator struct {
+	inner Coordinator
+	label keyviz.Label
+}
+
+func (c keyVizLabeledCoordinator) Dispatch(ctx context.Context, reqs *OperationGroup[OP]) (*CoordinateResponse, error) {
+	if reqs != nil && reqs.KeyVizLabel == keyviz.LabelLegacy {
+		copied := *reqs
+		copied.KeyVizLabel = c.label
+		reqs = &copied
+	}
+	resp, err := c.inner.Dispatch(ctx, reqs)
+	return resp, errors.WithStack(err)
+}
+
+func (c keyVizLabeledCoordinator) IsLeader() bool { return c.inner.IsLeader() }
+
+func (c keyVizLabeledCoordinator) VerifyLeader(ctx context.Context) error {
+	return errors.WithStack(c.inner.VerifyLeader(ctx))
+}
+
+func (c keyVizLabeledCoordinator) LinearizableRead(ctx context.Context) (uint64, error) {
+	idx, err := c.inner.LinearizableRead(ctx)
+	return idx, errors.WithStack(err)
+}
+
+func (c keyVizLabeledCoordinator) LinearizableReadForKey(ctx context.Context, key []byte) (uint64, error) {
+	ctx = contextWithKeyVizLabel(ctx, c.label)
+	if lr, ok := c.inner.(interface {
+		LinearizableReadForKey(context.Context, []byte) (uint64, error)
+	}); ok {
+		idx, err := lr.LinearizableReadForKey(ctx, key)
+		return idx, errors.WithStack(err)
+	}
+	idx, err := c.inner.LinearizableRead(ctx)
+	return idx, errors.WithStack(err)
+}
+
+func (c keyVizLabeledCoordinator) RaftLeader() string { return c.inner.RaftLeader() }
+
+func (c keyVizLabeledCoordinator) IsLeaderForKey(key []byte) bool {
+	return c.inner.IsLeaderForKey(key)
+}
+
+func (c keyVizLabeledCoordinator) VerifyLeaderForKey(ctx context.Context, key []byte) error {
+	return errors.WithStack(c.inner.VerifyLeaderForKey(ctx, key))
+}
+
+func (c keyVizLabeledCoordinator) RaftLeaderForKey(key []byte) string {
+	return c.inner.RaftLeaderForKey(key)
+}
+
+func (c keyVizLabeledCoordinator) Clock() *HLC { return c.inner.Clock() }
+
+func (c keyVizLabeledCoordinator) LeaseRead(ctx context.Context) (uint64, error) {
+	if lr, ok := c.inner.(LeaseReadableCoordinator); ok {
+		idx, err := lr.LeaseRead(ctx)
+		return idx, errors.WithStack(err)
+	}
+	idx, err := c.inner.LinearizableRead(ctx)
+	return idx, errors.WithStack(err)
+}
+
+func (c keyVizLabeledCoordinator) LeaseReadForKey(ctx context.Context, key []byte) (uint64, error) {
+	ctx = contextWithKeyVizLabel(ctx, c.label)
+	if lr, ok := c.inner.(LeaseReadableCoordinator); ok {
+		idx, err := lr.LeaseReadForKey(ctx, key)
+		return idx, errors.WithStack(err)
+	}
+	idx, err := c.inner.LinearizableRead(ctx)
+	return idx, errors.WithStack(err)
+}
+
+func (c keyVizLabeledCoordinator) LeaseReadAllGroups(ctx context.Context) error {
+	if ag, ok := c.inner.(AllGroupsLeaseReadableCoordinator); ok {
+		return errors.WithStack(ag.LeaseReadAllGroups(ctx))
+	}
+	_, err := LeaseReadThrough(c.inner, ctx)
+	return errors.WithStack(err)
+}
+
+func (c keyVizLabeledCoordinator) EngineGroupIDForKey(key []byte) uint64 {
+	if gr, ok := c.inner.(GroupRoutableCoordinator); ok {
+		return gr.EngineGroupIDForKey(key)
+	}
+	return 0
+}
diff --git a/kv/sharded_coordinator.go b/kv/sharded_coordinator.go
index ca18f32f1..c9970bce3 100644
--- a/kv/sharded_coordinator.go
+++ b/kv/sharded_coordinator.go
@@ -354,6 +354,10 @@ type ShardedCoordinator struct {
 	// disabled keyviz wires through to a no-op without branching on
 	// the hot path.
 	sampler keyviz.Sampler
+	// keyvizLabelsEnabled controls whether adapter-supplied labels are
+	// allowed to reach the sampler. When false, observations keep the
+	// legacy unlabeled route-only shape.
+	keyvizLabelsEnabled bool
 	// registrationGate is the Stage 7a §4.1 first-write barrier: when
 	// set, self-originated mutating writes that would land as §4.1
 	// storage envelopes block until this node's writer registration
@@ -534,6 +538,11 @@ func (c *ShardedCoordinator) WithSampler(s keyviz.Sampler) *ShardedCoordinator {
 	return c
 }
 
+func (c *ShardedCoordinator) WithKeyVizLabelsEnabled(enabled bool) *ShardedCoordinator {
+	c.keyvizLabelsEnabled = enabled
+	return c
+}
+
 // WithPartitionResolver wires a PartitionResolver onto the
 // coordinator's underlying ShardRouter. The resolver runs before
 // the byte-range engine on every dispatch, so partition-keyspace
@@ -779,7 +788,7 @@ func (c *ShardedCoordinator) dispatchTxnWithComposed1Retry(ctx context.Context,
 	c.maybeAutoPinObservedRouteVersion(reqs, callerSuppliedStartTS)
 
 	for attempt := 0; attempt <= composed1RetryAttempts; attempt++ {
-		resp, err := c.dispatchTxn(ctx, reqs.StartTS, reqs.CommitTS, reqs.PrevCommitTS, reqs.Elems, reqs.ReadKeys, reqs.ObservedRouteVersion)
+		resp, err := c.dispatchTxn(ctx, reqs.StartTS, reqs.CommitTS, reqs.PrevCommitTS, reqs.Elems, reqs.ReadKeys, reqs.ObservedRouteVersion, reqs.KeyVizLabel)
 		if err == nil {
 			return resp, nil
 		}
@@ -1003,11 +1012,11 @@ func (c *ShardedCoordinator) broadcastToAllGroups(ctx context.Context, requests
 	return &CoordinateResponse{CommitIndex: maxIndex.Load()}, nil
 }
 
-func (c *ShardedCoordinator) dispatchTxn(ctx context.Context, startTS uint64, commitTS uint64, prevCommitTS uint64, elems []*Elem[OP], readKeys [][]byte, observedRouteVersion uint64) (*CoordinateResponse, error) {
+func (c *ShardedCoordinator) dispatchTxn(ctx context.Context, startTS uint64, commitTS uint64, prevCommitTS uint64, elems []*Elem[OP], readKeys [][]byte, observedRouteVersion uint64, label keyviz.Label) (*CoordinateResponse, error) {
 	if len(readKeys) > maxReadKeys {
 		return nil, errors.WithStack(ErrInvalidRequest)
 	}
-	grouped, gids, err := c.groupMutations(elems)
+	grouped, gids, err := c.groupMutations(elems, label)
 	if err != nil {
 		return nil, err
 	}
@@ -1521,7 +1530,7 @@ func (c *ShardedCoordinator) LinearizableReadForKey(ctx context.Context, key []b
 	if !ok {
 		return 0, errors.WithStack(ErrLeaderNotFound)
 	}
-	c.observeRead(routeID, key)
+	c.observeRead(ctx, routeID, key)
 	return linearizableReadEngineCtx(ctx, engineForGroup(g))
 }
 
@@ -1543,7 +1552,7 @@ func (c *ShardedCoordinator) LeaseReadForKey(ctx context.Context, key []byte) (u
 	if !ok {
 		return 0, errors.WithStack(ErrLeaderNotFound)
 	}
-	c.observeRead(routeID, key)
+	c.observeRead(ctx, routeID, key)
 	return groupLeaseRead(ctx, g, c.leaseObserver)
 }
 
@@ -1794,7 +1803,7 @@ func (c *ShardedCoordinator) requestLogs(reqs *OperationGroup[OP]) ([]*pb.Reques
 }
 
 func (c *ShardedCoordinator) rawLogs(reqs *OperationGroup[OP]) ([]*pb.Request, error) {
-	grouped, gids, err := c.groupMutations(reqs.Elems)
+	grouped, gids, err := c.groupMutations(reqs.Elems, reqs.KeyVizLabel)
 	if err != nil {
 		return nil, err
 	}
@@ -1818,7 +1827,7 @@ func (c *ShardedCoordinator) rawLogs(reqs *OperationGroup[OP]) ([]*pb.Request, e
 func (c *ShardedCoordinator) txnLogs(reqs *OperationGroup[OP]) ([]*pb.Request, error) {
 	// NOTE: ShardedCoordinator implements distributed transactions directly in
 	// Dispatch. txnLogs is retained for compatibility and single-shard helpers.
-	grouped, gids, err := c.groupMutations(reqs.Elems)
+	grouped, gids, err := c.groupMutations(reqs.Elems, reqs.KeyVizLabel)
 	if err != nil {
 		return nil, err
 	}
@@ -1838,11 +1847,11 @@ func (c *ShardedCoordinator) txnLogs(reqs *OperationGroup[OP]) ([]*pb.Request, e
 // visualisation). The early return keeps the disabled-keyviz hot
 // path allocation-free. Reads have their own observeReadKey helper
 // (LinearizableReadForKey / LeaseReadForKey).
-func (c *ShardedCoordinator) observeMutation(routeID uint64, mut *pb.Mutation) {
+func (c *ShardedCoordinator) observeMutation(routeID uint64, mut *pb.Mutation, label keyviz.Label) {
 	if c.sampler == nil {
 		return
 	}
-	c.sampler.Observe(routeID, mut.Key, keyviz.OpWrite, len(mut.Value))
+	c.sampler.Observe(routeID, mut.Key, keyviz.OpWrite, len(mut.Value), c.keyVizObserveLabel(label))
 }
 
 // observeRead records a single linearizable / lease read against the
@@ -1862,14 +1871,21 @@ func (c *ShardedCoordinator) observeMutation(routeID uint64, mut *pb.Mutation) {
 // MVCCStore.GetAt without going through the coordinator) still
 // bypass keyviz; sampling those is task B in the design's Phase 2
 // follow-up.
-func (c *ShardedCoordinator) observeRead(routeID uint64, key []byte) {
+func (c *ShardedCoordinator) observeRead(ctx context.Context, routeID uint64, key []byte) {
 	if c.sampler == nil {
 		return
 	}
-	c.sampler.Observe(routeID, key, keyviz.OpRead, 0)
+	c.sampler.Observe(routeID, key, keyviz.OpRead, 0, c.keyVizObserveLabel(keyVizLabelFromContext(ctx)))
+}
+
+func (c *ShardedCoordinator) keyVizObserveLabel(label keyviz.Label) keyviz.Label {
+	if !c.keyvizLabelsEnabled {
+		return keyviz.LabelLegacy
+	}
+	return label
 }
 
-func (c *ShardedCoordinator) groupMutations(reqs []*Elem[OP]) (map[uint64][]*pb.Mutation, []uint64, error) {
+func (c *ShardedCoordinator) groupMutations(reqs []*Elem[OP], label keyviz.Label) (map[uint64][]*pb.Mutation, []uint64, error) {
 	grouped := make(map[uint64][]*pb.Mutation)
 	for _, req := range reqs {
 		if req == nil {
@@ -1887,7 +1903,7 @@ func (c *ShardedCoordinator) groupMutations(reqs []*Elem[OP]) (map[uint64][]*pb.
 		if route, found := c.engine.GetRoute(routeKey(mut.Key)); found {
 			routeID = route.RouteID
 		}
-		c.observeMutation(routeID, mut)
+		c.observeMutation(routeID, mut, label)
 		grouped[gid] = append(grouped[gid], mut)
 	}
 	gids := make([]uint64, 0, len(grouped))
diff --git a/kv/sharded_coordinator_sampler_test.go b/kv/sharded_coordinator_sampler_test.go
index 4ec1a0e26..080a29027 100644
--- a/kv/sharded_coordinator_sampler_test.go
+++ b/kv/sharded_coordinator_sampler_test.go
@@ -22,12 +22,13 @@ type recordingSampler struct {
 type sampleCall struct {
 	routeID  uint64
 	op       keyviz.Op
+	label    keyviz.Label
 	key      []byte
 	keyLen   int
 	valueLen int
 }
 
-func (r *recordingSampler) Observe(routeID uint64, key []byte, op keyviz.Op, valueLen int) {
+func (r *recordingSampler) Observe(routeID uint64, key []byte, op keyviz.Op, valueLen int, label keyviz.Label) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	// Copy the key: the sampler contract lets callers reuse the buffer,
@@ -37,6 +38,7 @@ func (r *recordingSampler) Observe(routeID uint64, key []byte, op keyviz.Op, val
 	r.calls = append(r.calls, sampleCall{
 		routeID:  routeID,
 		op:       op,
+		label:    label,
 		key:      append([]byte(nil), key...),
 		keyLen:   len(key),
 		valueLen: valueLen,
@@ -102,6 +104,7 @@ func TestShardedCoordinatorObservesEveryDispatchedMutation(t *testing.T) {
 		require.Equal(t, sampleCall{
 			routeID:  route.RouteID,
 			op:       keyviz.OpWrite,
+			label:    keyviz.LabelLegacy,
 			key:      append([]byte(nil), elem.Key...),
 			keyLen:   len(elem.Key),
 			valueLen: len(elem.Value),
@@ -166,7 +169,7 @@ func TestShardedCoordinatorWithoutSamplerStaysSafe(t *testing.T) {
 
 // TestShardedCoordinatorObservesLeaseAndLinearizableReads pins the
 // read-side wiring: LeaseReadForKey and LinearizableReadForKey each
-// produce one Observe(routeID, OpRead, len(key), 0) call. valueLen
+// produce one Observe(routeID, key, OpRead, 0, label) call. valueLen
 // is always zero at this layer because the consistency check doesn't
 // fetch data — the actual GetAt happens further down the stack and
 // is sampled separately (Phase 2 follow-up for adapter direct reads).
@@ -199,6 +202,7 @@ func TestShardedCoordinatorObservesLeaseAndLinearizableReads(t *testing.T) {
 	want := sampleCall{
 		routeID:  route.RouteID,
 		op:       keyviz.OpRead,
+		label:    keyviz.LabelLegacy,
 		key:      append([]byte(nil), key...),
 		keyLen:   len(key),
 		valueLen: 0,
@@ -207,6 +211,56 @@ func TestShardedCoordinatorObservesLeaseAndLinearizableReads(t *testing.T) {
 	require.Equal(t, want, calls[1], "lease read must forward the full key bytes")
 }
 
+func TestShardedCoordinatorKeyVizLabelGate(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	engine := distribution.NewEngine()
+	engine.UpdateRoute([]byte("a"), nil, 1)
+	st := store.NewMVCCStore()
+	r, stop := newSingleRaft(t, "kv-sampler-label-gate", NewKvFSMWithHLC(st, NewHLC()))
+	t.Cleanup(stop)
+	groups := map[uint64]*ShardGroup{
+		1: {Engine: r, Store: st, Txn: NewLeaderProxyWithEngine(r)},
+	}
+
+	t.Run("disabled overrides to legacy", func(t *testing.T) {
+		rec := &recordingSampler{}
+		coord := NewShardedCoordinator(engine, groups, 1, NewHLC(), NewShardStore(engine, groups)).WithSampler(rec)
+		_, err := coord.Dispatch(ctx, &OperationGroup[OP]{
+			KeyVizLabel: keyviz.LabelRedis,
+			Elems:       []*Elem[OP]{{Op: Put, Key: []byte("b"), Value: []byte("v")}},
+		})
+		require.NoError(t, err)
+		require.Equal(t, keyviz.LabelLegacy, rec.snapshot()[0].label)
+	})
+
+	t.Run("enabled preserves wrapper label", func(t *testing.T) {
+		rec := &recordingSampler{}
+		base := NewShardedCoordinator(engine, groups, 1, NewHLC(), NewShardStore(engine, groups)).
+			WithSampler(rec).
+			WithKeyVizLabelsEnabled(true)
+		coord := WithKeyVizLabel(base, keyviz.LabelRedis)
+		ops := &OperationGroup[OP]{
+			Elems: []*Elem[OP]{{Op: Put, Key: []byte("c"), Value: []byte("v")}},
+		}
+		_, err := coord.Dispatch(ctx, ops)
+		require.NoError(t, err)
+		require.Equal(t, keyviz.LabelLegacy, ops.KeyVizLabel, "wrapper must not mutate caller-owned request")
+
+		reader, ok := coord.(interface {
+			LinearizableReadForKey(context.Context, []byte) (uint64, error)
+		})
+		require.True(t, ok, "wrapper must preserve key-routed read capability")
+		_, err = reader.LinearizableReadForKey(ctx, []byte("d"))
+		require.NoError(t, err)
+
+		calls := rec.snapshot()
+		require.Len(t, calls, 2)
+		require.Equal(t, keyviz.LabelRedis, calls[0].label)
+		require.Equal(t, keyviz.LabelRedis, calls[1].label)
+	})
+}
+
 // TestShardedCoordinatorSkipsObserveForLeadershipChecks pins the
 // negative contract: leadership-only entries (IsLeaderForKey,
 // VerifyLeaderForKey, RaftLeaderForKey) MUST NOT produce read
diff --git a/kv/transcoder.go b/kv/transcoder.go
index cce1a932f..0f0071995 100644
--- a/kv/transcoder.go
+++ b/kv/transcoder.go
@@ -1,5 +1,7 @@
 package kv
 
+import "github.com/bootjp/elastickv/keyviz"
+
 // OP is an operation type.
 type OP int
 
@@ -23,6 +25,9 @@ type Elem[T OP] struct {
 type OperationGroup[T OP] struct {
 	Elems []*Elem[T]
 	IsTxn bool
+	// KeyVizLabel tags this operation group for KeyViz attribution.
+	// The zero value is the legacy unlabeled route-only view.
+	KeyVizLabel keyviz.Label
 	// StartTS is a logical timestamp captured at transaction begin.
 	// It is ignored for non-transactional groups.
 	StartTS uint64
diff --git a/main.go b/main.go
index 742af112d..ea2b4d654 100644
--- a/main.go
+++ b/main.go
@@ -195,6 +195,7 @@ var (
 	keyvizMaxMemberRoutesPerSlot = flag.Int("keyvizMaxMemberRoutesPerSlot", keyviz.DefaultMaxMemberRoutesPerSlot, "Maximum members listed on a virtual bucket; excess routes still drive the bucket counters")
 	keyvizHistoryColumns         = flag.Int("keyvizHistoryColumns", keyviz.DefaultHistoryColumns, "Maximum matrix columns retained in the keyviz ring buffer (each column = one Step)")
 	keyvizKeyBucketsPerRoute     = flag.Int("keyvizKeyBucketsPerRoute", keyviz.DefaultKeyBucketsPerRoute, "Order-preserving sub-range buckets per individual route for the hot-key heatmap; 1 disables sub-bucketing (route-granular, today's behaviour). Capped at 256; memory is ~K*32 bytes/route, so K_max ~= memBudget/(32*keyvizMaxTrackedRoutes)")
+	keyvizLabelsEnabled          = flag.Bool("keyvizLabelsEnabled", false, "Enable per-adapter KeyViz row labels. Default false keeps legacy route-only rows during rolling upgrades")
 
 	// Hot-key drill-down (Phase 2-A++; design 2026_05_28_proposed_keyviz_hot_key_topk).
 	// Off by default — the disabled-case adds one early-return branch
@@ -425,6 +426,7 @@ func run() error {
 	coordinate := kv.NewShardedCoordinator(cfg.engine, shardGroups, cfg.defaultGroup, clock, shardStore).
 		WithLeaseReadObserver(metricsRegistry.LeaseReadObserver()).
 		WithSampler(keyVizSamplerForCoordinator(sampler)).
+		WithKeyVizLabelsEnabled(*keyvizLabelsEnabled).
 		WithPartitionResolver(buildSQSPartitionResolver(cfg.sqsFifoPartitionMap))
 
 	// SQS HT-FIFO §8 leadership-refusal: install per-group
@@ -2046,6 +2048,7 @@ func buildKeyVizSampler() *keyviz.MemSampler {
 		MaxTrackedRoutes:       *keyvizMaxTrackedRoutes,
 		MaxMemberRoutesPerSlot: *keyvizMaxMemberRoutesPerSlot,
 		KeyBucketsPerRoute:     *keyvizKeyBucketsPerRoute,
+		KeyVizLabelsEnabled:    *keyvizLabelsEnabled,
 		HotKeysEnabled:         *keyvizHotKeysEnabled,
 		HotKeysPerRoute:        *keyvizHotKeysPerRoute,
 		HotKeysSampleRate:      *keyvizHotKeysSampleRate,
diff --git a/main_keyviz_test.go b/main_keyviz_test.go
index ee8e0afce..cdd902b48 100644
--- a/main_keyviz_test.go
+++ b/main_keyviz_test.go
@@ -46,7 +46,7 @@ func TestSeedKeyVizRoutesCopiesEngineCatalogue(t *testing.T) {
 	seedKeyVizRoutes(s, engine)
 
 	for _, r := range engine.Stats() {
-		s.Observe(r.RouteID, make([]byte, 1), keyviz.OpRead, 1)
+		s.Observe(r.RouteID, make([]byte, 1), keyviz.OpRead, 1, keyviz.LabelLegacy)
 	}
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
@@ -74,7 +74,7 @@ func TestStartKeyVizFlusherReturnsAfterCancel(t *testing.T) {
 	t.Parallel()
 	s := keyviz.NewMemSampler(keyviz.MemSamplerOptions{Step: time.Millisecond, HistoryColumns: 4})
 	require.True(t, s.RegisterRoute(1, []byte("a"), []byte("b"), 0))
-	s.Observe(1, make([]byte, 0), keyviz.OpRead, 0)
+	s.Observe(1, make([]byte, 0), keyviz.OpRead, 0, keyviz.LabelLegacy)
 
 	ctx, cancel := context.WithCancel(context.Background())
 	eg, _ := errgroup.WithContext(ctx)
@@ -109,7 +109,7 @@ func TestPublishLeaderTermsFromSnapshotsStampsRows(t *testing.T) {
 	publishLeaderTermsFromSnapshots(s, []groupTermSnapshot{
 		{groupID: 7, term: 42},
 	})
-	s.Observe(1, make([]byte, 16), keyviz.OpWrite, 64)
+	s.Observe(1, make([]byte, 16), keyviz.OpWrite, 64, keyviz.LabelLegacy)
 	s.Flush()
 	cols := s.Snapshot(time.Time{}, time.Time{})
 	require.Len(t, cols, 1)
diff --git a/proto/admin.pb.go b/proto/admin.pb.go
index 1467c5636..ace6b3462 100644
--- a/proto/admin.pb.go
+++ b/proto/admin.pb.go
@@ -702,10 +702,12 @@ func (x *GetAdapterSummaryResponse) GetSummaries() []*AdapterSummary {
 
 type KeyVizRow struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
-	// bucket_id is either "route:<routeID>" or "virtual:<lineageID-or-hash>".
-	BucketId          string       `protobuf:"bytes,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"`
-	Start             []byte       `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"`
-	End               []byte       `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"`
+	// bucket_id is "route:<routeID>", "route:<routeID>:<label>", or
+	// "virtual:<lineageID-or-hash>".
+	BucketId string `protobuf:"bytes,1,opt,name=bucket_id,json=bucketId,proto3" json:"bucket_id,omitempty"`
+	Start    []byte `protobuf:"bytes,2,opt,name=start,proto3" json:"start,omitempty"`
+	End      []byte `protobuf:"bytes,3,opt,name=end,proto3" json:"end,omitempty"`
+	// label is the per-adapter KeyViz label; empty for legacy and virtual rows.
 	Label             string       `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"`
 	Aggregate         bool         `protobuf:"varint,5,opt,name=aggregate,proto3" json:"aggregate,omitempty"`
 	RouteIds          []uint64     `protobuf:"varint,6,rep,packed,name=route_ids,json=routeIds,proto3" json:"route_ids,omitempty"`
diff --git a/proto/admin.proto b/proto/admin.proto
index 507143d43..aae54e45a 100644
--- a/proto/admin.proto
+++ b/proto/admin.proto
@@ -88,10 +88,12 @@ enum SampleRole {
 }
 
 message KeyVizRow {
-  // bucket_id is either "route:<routeID>" or "virtual:<lineageID-or-hash>".
+  // bucket_id is "route:<routeID>", "route:<routeID>:<label>", or
+  // "virtual:<lineageID-or-hash>".
   string bucket_id = 1;
   bytes start = 2;
   bytes end = 3;
+  // label is the per-adapter KeyViz label; empty for legacy and virtual rows.
   string label = 4;
   bool aggregate = 5;
   repeated uint64 route_ids = 6;
diff --git a/scripts/rolling-update.env.example b/scripts/rolling-update.env.example
index d47805b0e..83c79badf 100644
--- a/scripts/rolling-update.env.example
+++ b/scripts/rolling-update.env.example
@@ -126,6 +126,10 @@ ADMIN_ENABLED="false"
 # full design.
 KEYVIZ_ENABLED="false"
 # KEYVIZ_FANOUT_NODES="10.0.0.1:8080,10.0.0.2:8080,10.0.0.3:8080"
+# Per-adapter heatmap rows. Keep false during a normal rolling binary
+# update; after every node runs a build that supports labels, flip true
+# and restart to allocate route:<id>:<label> slots.
+KEYVIZ_LABELS_ENABLED="false"
 
 # KeyViz hot-key Top-K drill-down (Phase 2-A++). When
 # KEYVIZ_HOT_KEYS_ENABLED=true (and KEYVIZ_ENABLED is also true), every
diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh
index 5dd6ad2fe..424168703 100755
--- a/scripts/rolling-update.sh
+++ b/scripts/rolling-update.sh
@@ -301,6 +301,7 @@ ADMIN_ALLOW_INSECURE_DEV_COOKIE="${ADMIN_ALLOW_INSECURE_DEV_COOKIE:-false}"
 # state); it just produces no callers without --adminEnabled.
 KEYVIZ_ENABLED="${KEYVIZ_ENABLED:-false}"
 KEYVIZ_FANOUT_NODES="${KEYVIZ_FANOUT_NODES:-}"
+KEYVIZ_LABELS_ENABLED="${KEYVIZ_LABELS_ENABLED:-false}"
 # Sub-range (hot-key) buckets per route. Empty omits the flag (binary
 # default 1 = route-level). A positive integer (e.g. 64) divides each
 # route into that many order-preserving sub-ranges so the heatmap shows
@@ -328,7 +329,7 @@ KEYVIZ_HOT_KEYS_MAX_KEY_LEN="${KEYVIZ_HOT_KEYS_MAX_KEY_LEN:-}"
 # who typed "True", "1", or a stray quote sees a script-level error
 # pointing at the variable name instead of an inscrutable failure
 # inside the SSH heredoc.
-for _bool_var in DRY_RUN ADMIN_ENABLED ADMIN_ALLOW_PLAINTEXT_NON_LOOPBACK ADMIN_ALLOW_INSECURE_DEV_COOKIE KEYVIZ_ENABLED KEYVIZ_HOT_KEYS_ENABLED ENABLE_S3 ENABLE_SQS; do
+for _bool_var in DRY_RUN ADMIN_ENABLED ADMIN_ALLOW_PLAINTEXT_NON_LOOPBACK ADMIN_ALLOW_INSECURE_DEV_COOKIE KEYVIZ_ENABLED KEYVIZ_LABELS_ENABLED KEYVIZ_HOT_KEYS_ENABLED ENABLE_S3 ENABLE_SQS; do
   case "${!_bool_var}" in
     true|false) ;;
     *)
@@ -576,6 +577,7 @@ print_dry_run_plan() {
   fi
   if [[ "$KEYVIZ_ENABLED" == "true" ]]; then
     echo "[rolling-update] KEYVIZ_FANOUT_NODES=$KEYVIZ_FANOUT_NODES"
+    echo "[rolling-update] KEYVIZ_LABELS_ENABLED=$KEYVIZ_LABELS_ENABLED"
     echo "[rolling-update] KEYVIZ_KEY_BUCKETS_PER_ROUTE=$KEYVIZ_KEY_BUCKETS_PER_ROUTE"
     echo "[rolling-update] KEYVIZ_HOT_KEYS_ENABLED=$KEYVIZ_HOT_KEYS_ENABLED"
     if [[ "$KEYVIZ_HOT_KEYS_ENABLED" == "true" ]]; then
@@ -743,6 +745,7 @@ update_one_node() {
       ADMIN_ALLOW_INSECURE_DEV_COOKIE="$ADMIN_ALLOW_INSECURE_DEV_COOKIE" \
       KEYVIZ_ENABLED="$KEYVIZ_ENABLED" \
       KEYVIZ_FANOUT_NODES="$KEYVIZ_FANOUT_NODES_Q" \
+      KEYVIZ_LABELS_ENABLED="$KEYVIZ_LABELS_ENABLED" \
       KEYVIZ_KEY_BUCKETS_PER_ROUTE="$KEYVIZ_KEY_BUCKETS_PER_ROUTE_Q" \
       KEYVIZ_HOT_KEYS_ENABLED="$KEYVIZ_HOT_KEYS_ENABLED" \
       KEYVIZ_HOT_KEYS_PER_ROUTE="$KEYVIZ_HOT_KEYS_PER_ROUTE_Q" \
@@ -1240,6 +1243,9 @@ build_keyviz_flags() {
   if [[ -n "$fanout_nodes" ]]; then
     _flags+=(--keyvizFanoutNodes "$fanout_nodes")
   fi
+  if [[ "${KEYVIZ_LABELS_ENABLED:-false}" == "true" ]]; then
+    _flags+=(--keyvizLabelsEnabled)
+  fi
 
   local key_buckets="${KEYVIZ_KEY_BUCKETS_PER_ROUTE:-}"
   if [[ -n "$key_buckets" ]]; then
@@ -1462,6 +1468,7 @@ running_status="$(docker inspect --format "{{.State.Status}}" "$CONTAINER_NAME"
 # unset deploy knob hashes as the empty string consistently.
 config_fp() {
   local keyviz_fanout_nodes_fp=""
+  local keyviz_labels_enabled_fp=""
   local keyviz_key_buckets_per_route_fp=""
   local keyviz_hot_keys_enabled_fp=""
   local keyviz_hot_keys_per_route_fp=""
@@ -1470,6 +1477,7 @@ config_fp() {
   local keyviz_hot_keys_max_key_len_fp=""
   if [[ "$KEYVIZ_ENABLED" == "true" ]]; then
     keyviz_fanout_nodes_fp="$KEYVIZ_FANOUT_NODES"
+    keyviz_labels_enabled_fp="$KEYVIZ_LABELS_ENABLED"
     keyviz_key_buckets_per_route_fp="$KEYVIZ_KEY_BUCKETS_PER_ROUTE"
     keyviz_hot_keys_enabled_fp="$KEYVIZ_HOT_KEYS_ENABLED"
     if [[ "$KEYVIZ_HOT_KEYS_ENABLED" == "true" ]]; then
@@ -1499,7 +1507,7 @@ config_fp() {
     "$ADMIN_SESSION_SIGNING_KEY_FILE" "$ADMIN_SESSION_SIGNING_KEY_PREVIOUS_FILE" \
     "$ADMIN_TLS_CERT_FILE" "$ADMIN_TLS_KEY_FILE" \
     "$ADMIN_ALLOW_PLAINTEXT_NON_LOOPBACK" "$ADMIN_ALLOW_INSECURE_DEV_COOKIE" \
-    "$KEYVIZ_ENABLED" "$keyviz_fanout_nodes_fp" "$keyviz_key_buckets_per_route_fp" \
+    "$KEYVIZ_ENABLED" "$keyviz_fanout_nodes_fp" "$keyviz_labels_enabled_fp" "$keyviz_key_buckets_per_route_fp" \
     "$keyviz_hot_keys_enabled_fp" "$keyviz_hot_keys_per_route_fp" \
     "$keyviz_hot_keys_sample_rate_fp" "$keyviz_hot_keys_queue_size_fp" \
     "$keyviz_hot_keys_max_key_len_fp" \
@@ -1725,7 +1733,7 @@ RAFT_TO_SQS_MAP_Q="$(printf '%q' "$RAFT_TO_SQS_MAP")"
 # the login shell once, so every value the operator might set has to
 # survive that pass intact. printf %q is the same hardening every
 # other forwarded path-like variable above gets.
-# The boolean flags (ADMIN_ENABLED, ADMIN_ALLOW_*, KEYVIZ_ENABLED)
+# The boolean flags (ADMIN_ENABLED, ADMIN_ALLOW_*, KEYVIZ_*)
 # are validated at the top of the local script to be the literal
 # "true" or "false", so they need no extra escaping — kept unquoted
 # at the env site for readability.
diff --git a/web/admin/src/api/client.ts b/web/admin/src/api/client.ts
index 1354f3deb..a401c0d64 100644
--- a/web/admin/src/api/client.ts
+++ b/web/admin/src/api/client.ts
@@ -413,6 +413,7 @@ export interface KeyVizHotKey {
 
 export interface KeyVizHotKeysResponse {
   route_id: number;
+  label?: string;
   // Omitted by the server when the route was registered with K=1
   // (no sub-bucket axis); the SPA treats absence as "whole route".
   sub_bucket?: number;
@@ -433,6 +434,7 @@ export interface KeyVizHotKeysResponse {
 
 export interface KeyVizHotKeysParams {
   route_id: number;
+  label?: string;
   // Sub-key-range bucket WITHIN the route (parallel to the matrix
   // row's `#<n>` suffix). Omit for K=1 routes; the server validates
   // the range and returns 400 invalid_query on out-of-range.
@@ -597,6 +599,7 @@ export const api = {
     apiFetch<KeyVizHotKeysResponse>("/keyviz/hotkeys", {
       query: {
         route_id: params.route_id,
+        label: params.label,
         sub_bucket: params.sub_bucket,
         series: params.series,
         top: params.top,
diff --git a/web/admin/src/pages/KeyViz.test.ts b/web/admin/src/pages/KeyViz.test.ts
new file mode 100644
index 000000000..40d4ba492
--- /dev/null
+++ b/web/admin/src/pages/KeyViz.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+
+import { parseBucketID } from "./KeyViz";
+
+describe("parseBucketID", () => {
+  it("parses legacy and labeled route bucket IDs", () => {
+    expect(parseBucketID("route:7")).toEqual({ kind: "route", routeID: 7 });
+    expect(parseBucketID("route:7#3")).toEqual({ kind: "route", routeID: 7, subBucket: 3 });
+    expect(parseBucketID("route:7:redis")).toEqual({ kind: "route", routeID: 7, label: "redis" });
+    expect(parseBucketID("route:7:redis#3")).toEqual({ kind: "route", routeID: 7, label: "redis", subBucket: 3 });
+  });
+
+  it("rejects malformed labeled route bucket IDs", () => {
+    expect(parseBucketID("route:7:")).toBeNull();
+    expect(parseBucketID("route:7:redis:extra")).toBeNull();
+    expect(parseBucketID("route:7:redis#")).toBeNull();
+  });
+});
diff --git a/web/admin/src/pages/KeyViz.tsx b/web/admin/src/pages/KeyViz.tsx
index fd3a6110b..0281224b7 100644
--- a/web/admin/src/pages/KeyViz.tsx
+++ b/web/admin/src/pages/KeyViz.tsx
@@ -585,13 +585,16 @@ function RowDetail({ row, index }: RowDetailProps) {
 //
 //   "virtual:<routeID>"            — coarsened aggregate, no drill-down
 //   "route:<routeID>"              — K=1 route, no sub-bucket axis
+//   "route:<routeID>:<label>"      — labeled K=1 route
 //   "route:<routeID>#<subBucket>"  — sub-bucket row of a K>1 route
+//   "route:<routeID>:<label>#<subBucket>" — labeled sub-bucket row
 //
 // Returns null when the format is unrecognised so the panel can render
 // a clear "unsupported bucket type" placeholder rather than throw.
 interface BucketIDParts {
   kind: "virtual" | "route";
   routeID: number;
+  label?: string;
   subBucket?: number;
 }
 
@@ -605,7 +608,18 @@ function parseUint(raw: string): number | null {
   return Number(raw);
 }
 
-function parseBucketID(id: string): BucketIDParts | null {
+function parseRouteAndLabel(raw: string): { routeID: number; label?: string } | null {
+  const parts = raw.split(":");
+  if (parts.length < 1 || parts.length > 2) return null;
+  const routeID = parseUint(parts[0]);
+  if (routeID === null) return null;
+  if (parts.length === 1) return { routeID };
+  const label = parts[1];
+  if (!/^[A-Za-z0-9_-]+$/.test(label)) return null;
+  return { routeID, label };
+}
+
+export function parseBucketID(id: string): BucketIDParts | null {
   // parseUint enforces digit-only segments. Belt-and-braces against
   // both Number.parseInt's prefix-tolerance (parseInt("42abc") → 42)
   // and Number's empty-string coercion (Number("") → 0); the server's
@@ -620,14 +634,14 @@ function parseBucketID(id: string): BucketIDParts | null {
     const rest = id.slice("route:".length);
     const hash = rest.indexOf("#");
     if (hash < 0) {
-      const n = parseUint(rest);
-      if (n === null) return null;
-      return { kind: "route", routeID: n };
+      const parsed = parseRouteAndLabel(rest);
+      if (parsed === null) return null;
+      return { kind: "route", ...parsed };
     }
-    const routeID = parseUint(rest.slice(0, hash));
+    const parsed = parseRouteAndLabel(rest.slice(0, hash));
     const sub = parseUint(rest.slice(hash + 1));
-    if (routeID === null || sub === null) return null;
-    return { kind: "route", routeID, subBucket: sub };
+    if (parsed === null || sub === null) return null;
+    return { kind: "route", ...parsed, subBucket: sub };
   }
   return null;
 }
@@ -692,7 +706,7 @@ function HotKeysPanel({ row, column, columnUnixMs, series, onClose }: HotKeysPan
         <HotKeysUnsupportedNotice row={row} parts={parts} series={series} />
       )}
       {supported && parts && parts.kind === "route" && (
-        <HotKeysContent routeID={parts.routeID} subBucket={parts.subBucket} />
+        <HotKeysContent routeID={parts.routeID} label={parts.label} subBucket={parts.subBucket} />
       )}
     </div>
   );
@@ -740,22 +754,24 @@ function HotKeysUnsupportedNotice({ row, parts, series }: HotKeysUnsupportedNoti
 
 interface HotKeysContentProps {
   routeID: number;
+  label?: string;
   subBucket?: number;
 }
 
-function HotKeysContent({ routeID, subBucket }: HotKeysContentProps) {
+function HotKeysContent({ routeID, label, subBucket }: HotKeysContentProps) {
   const query = useApiQuery(
     (signal) =>
       api.keyVizHotKeys(
         {
           route_id: routeID,
+          label,
           sub_bucket: subBucket,
           series: "writes",
           top: hotKeysTopK,
         },
         signal,
       ),
-    [routeID, subBucket],
+    [routeID, label, subBucket],
   );
   // useApiQuery keeps the previous response in `data` while a new
   // request is in flight (it doesn't reset on dep change), so when the
@@ -768,6 +784,7 @@ function HotKeysContent({ routeID, subBucket }: HotKeysContentProps) {
   const hasMatchingData =
     !!query.data &&
     query.data.route_id === routeID &&
+    (query.data.label ?? "") === (label ?? "") &&
     query.data.sub_bucket === subBucket;
   if (query.loading && !hasMatchingData) {
     return <p className="text-xs text-muted">Loading hot keys…</p>;