docs(adr-0013): reconcile with the shipped fused-kernel design

The refactor removed Mask and the FilterKernel/MapKernel/ReduceKernel
interfaces (§1-§3) in favor of the fused single-pass kernels
Compute.filteredSum / filteredAggregate — no intermediate selection
bitmap. Update ADR 0013's Status to say so and add an Implementation
note documenting the pivot (§1-§3 preserved below as the original
proposal, read as history). §4/§5/§6 are unchanged and implemented.

Slim the TODO item to match: the residual/boundary tier landed; what
remains are the deferred follow-ups (benchmark, encoded-domain
specialization, transducer façade ADR 0019).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

TODO.md

@@ -85,23 +85,18 @@ Per-encoding gotchas:
 
 ## Compute
 
-- [ ] **Compute primitives — masks, kernels, no-materialize** — pushdown filter/compare/aggregate
-  kernels operating on Lazy arrays without materializing. See [ADR-0013](docs/adr/0013-compute-primitives.md)
-  (Proposed). Gate: a concrete downstream consumer (e.g. the vortex-arrow bridge or filter pushdown).
-  Done: §6 read-side surface — `ScanIterator.columnZoneStats(col)` exposes per-zone
-  min/max/sum/null count, decoding sum from the `vortex.stats` zone-map table (matches files from
-  Rust, whose flat writer omits per-flat sum). Calcite `VortexAggregates.SUM`/`AVG` now fold those
-  per-zone sums (metadata-only), falling back to a full scan only when a column has no zone map.
-  The fold is a reusable `reader.compute.ZoneReducer.sum(col)` (the seam a future `vortex-compute`
-  extracts), consumed by the planner: `VortexAggregatePushDownRule` rewrites a whole-table
-  `MIN`/`MAX`/`COUNT`/`SUM`/`AVG` to a single-row `Values`, abandoning to the scan only when a zone
-  carries no usable sum (an all-null column answers SQL `NULL`; `AVG` reduces to `SUM`/`COUNT`). The
-  rule auto-registers over a bare `jdbc:calcite:` connection via `VortexTableScan.register()`, so
-  SQL over JDBC is rewritten with no caller wiring. A `SUM` with a `WHERE` still abandons (whole-zone
-  stats can't answer a filtered aggregate) — that is the residual tier below.
-  Next: the residual tier — give `ZoneReducer` predicate support (whole-zone fold for fully-selected
-  zones + boundary-zone streaming for partially-selected ones), then let the rule push `SUM` with a
-  `WHERE`. `Mask`/`Predicate`/kernel vocab on top.
+- [ ] **Compute primitives — encoded-domain specialization & façade** — the remaining ADR-0013
+  follow-ups now the fused kernels have shipped. See [ADR-0013](docs/adr/0013-compute-primitives.md).
+  Done: §4 `Predicate`; §5 `RowFilter` unified over `Predicate`; §6 zone-map aggregate push-down in
+  both tiers — the whole-zone `ZoneReducer` fold wired into `VortexAggregatePushDownRule` (rewrites a
+  whole-table `MIN`/`MAX`/`COUNT`/`SUM`/`AVG` to a single-row `Values`, auto-registered over a bare
+  `jdbc:calcite:` connection), plus the boundary/residual tier so a `SUM`/`MIN`/`MAX`/`COUNT` with a
+  `WHERE` folds fully-selected zones from stats and decodes only the straddling boundary chunks via
+  the fused `Compute.filteredAggregate`. §1–§3 (`Mask`, the `FilterKernel`/`MapKernel`/`ReduceKernel`
+  interfaces) were built then removed for the fused single-pass kernels — no intermediate bitmap.
+  Next: (1) benchmark the fused-kernel speedup (`ComputeKernelBenchmark`, 100M rows) to record §6's
+  payoff; (2) encoded-domain kernel specialization — push the predicate into the ALP/FoR/Dict integer
+  domain without decoding (its own perf ADR); (3) the columnar transducer façade (ADR 0019).
 
 ## Encodings
 

docs/adr/0013-compute-primitives.md

@@ -1,14 +1,17 @@
 # ADR 0013: Compute primitives — masks, kernels, no-materialize contract
 
-- **Status:** Accepted — §1 (Mask), §4 (Predicate), §2/§3 (filter/reduce kernels, a generic
-  streaming baseline plus a type-specialized boxing-free fast lane, behind a minimal `Compute`
-  entry point), §5 (`RowFilter` unified over `Predicate` — a `RowFilter.Column` binds a column to a
-  shared public `Predicate`; the same predicate is compiled against zone-map stats for pruning and
-  against the decoded array for the boundary fold), and §6 (zone-map aggregate push-down, both the
-  whole-zone and boundary-zone tiers) are implemented in `reader.compute`. Deferred: encoded-domain
-  kernel specialization (perf escalation — pushing the predicate into the ALP/FoR/Dict integer
-  domain without decoding), and the ergonomic façade (a columnar transducer — its own ADR).
-  `MapKernel` is unbuilt (no consumer yet).
+- **Status:** Accepted, implemented — with §1–§3 superseded in implementation (see the
+  *Implementation note* below). Built in `reader.compute`: §4 (`Predicate`), §5 (`RowFilter`
+  unified over `Predicate` — a `RowFilter.Column` binds a column to a shared public `Predicate`,
+  the same predicate compiled against zone-map stats for pruning and against the decoded array for
+  the boundary fold), and §6 (zone-map aggregate push-down, both the whole-zone and boundary-zone
+  tiers). §1 (`Mask`) and §2/§3 (the `FilterKernel`/`MapKernel`/`ReduceKernel` interfaces and the
+  mask-based no-materialize contract) were built and then **removed**: the shipped design is the
+  fused single-pass kernels `Compute.filteredSum` / `filteredAggregate`, which fold filter and
+  reduce in one scan with **no intermediate selection bitmap** — a stronger no-materialize
+  guarantee than a `Mask` could give. Deferred to their own ADRs: encoded-domain kernel
+  specialization (perf escalation — pushing the predicate into the ALP/FoR/Dict integer domain
+  without decoding) and the ergonomic façade (a columnar transducer, ADR 0019).
 - **Date:** 2026-06-15
 - **Deciders:** project maintainer
 - **Supersedes:** —
@@ -18,6 +21,26 @@
   [ADR 0010 — Lazy decode](0010-lazy-decode.md),
   [ADR 0012 — Zero-copy layout decoding](0012-zero-copy-layout-decoding.md)
 
+## Implementation note (2026-07-01)
+
+The primitives shipped, but §1–§3 as drawn below did not survive the perf work. The `Mask` sealed
+type, the `FilterKernel` / `MapKernel` / `ReduceKernel` interfaces, and the mask-based
+no-materialize contract were implemented, benchmarked, and then removed. A materialized selection
+`Mask` is a positional bitmap the reduce must re-scan — strictly slower than fusing the filter and
+the reduce into one pass. The shipped surface is two fused kernels behind the minimal public
+`Compute` entry point, with everything else package-private:
+
+- `Compute.filteredSum(filterColumn, predicate, aggColumn)` — one filter column, one summed column.
+- `Compute.filteredAggregate(chunk, filter, aggColumn)` — an n-ary `AND` `RowFilter` and a
+  `SUM` / `MIN` / `MAX` / non-null-count fold over the rows it selects.
+
+Both fold filter and reduce in a single scan with no intermediate bitmap, honoring §3's
+no-materialize intent more strictly than a `Mask` pipeline would; each is type-specialized into
+boxing-free long / double lanes with a generic boxing fallback. `MapKernel` was never built (no
+consumer). The `Predicate` (§4) and `RowFilter` unification (§5) vocabulary is unchanged and is what
+these kernels consume. The sections below are preserved as the original proposal; read §1–§3 as
+history, not as the built design.
+
 ## Context
 
 ADR 0010 establishes that the reader defers transform work until access