From 885d94c1a398b25cdc51c250faf6bbfad1e5a11b Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 04:01:50 -0400
Subject: [PATCH 01/68] Integer-proxy chunks: backend-agnostic join and reduce
 over (key_hash, value_id)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A boundary where only integers cross: a storage backend presents each
record as ((key_hash, value_id), time, diff) — integer proxies for data
it keeps in its own layout — the operators own all the lattice/time
logic over those integers, and the backend supplies value semantics via
callbacks. Any columnar (or otherwise opaque-to-DD) value store can
then reuse join and reduce without materializing values.

- trace/chunk/int_proxy: ProxyChunk, a cursor-less Chunk of proxy
  columns, with from_unsorted (integer sort+consolidate with
  representative provenance) as the presentation-building helper.
- operators/int_proxy: ProxyJoinTactic / ProxyReduceTactic for the
  join_with_tactic and reduce_with_tactic seams (made pub here), and
  the backend traits: present-as-proxies (read), value callback with
  hash-minted output ids (write), materialize (egress). Reduce output
  ids are content hashes, so an output arrangement re-presents with the
  same ids downstream with no registry; pending interesting times are
  keyed by the stable key_hash across retires. The module doc carries
  the boundary contract and design notes (why value_id is not
  order-preserving; collision risk); each tactic and the in-memory
  reference backend (VecChunk arrangements, fnv hashes) sit in their
  own file under the module.
- Tests: join and count/distinct/min reduces against the row operators
  over multi-round retracting inputs, and a scripted Product-time
  retire sequence exercising synthetic corrections and pending.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/join.rs           | 136 +++++
 .../src/operators/int_proxy/mod.rs            |  96 ++++
 .../src/operators/int_proxy/reduce.rs         | 306 +++++++++++
 .../src/operators/int_proxy/reference.rs      | 258 +++++++++
 differential-dataflow/src/operators/join.rs   |   6 +-
 differential-dataflow/src/operators/mod.rs    |   1 +
 differential-dataflow/src/operators/reduce.rs |   4 +-
 .../src/trace/chunk/int_proxy.rs              | 505 ++++++++++++++++++
 differential-dataflow/src/trace/chunk/mod.rs  |   1 +
 differential-dataflow/tests/int_proxy.rs      | 341 ++++++++++++
 10 files changed, 1649 insertions(+), 5 deletions(-)
 create mode 100644 differential-dataflow/src/operators/int_proxy/join.rs
 create mode 100644 differential-dataflow/src/operators/int_proxy/mod.rs
 create mode 100644 differential-dataflow/src/operators/int_proxy/reduce.rs
 create mode 100644 differential-dataflow/src/operators/int_proxy/reference.rs
 create mode 100644 differential-dataflow/src/trace/chunk/int_proxy.rs
 create mode 100644 differential-dataflow/tests/int_proxy.rs

diff --git a/differential-dataflow/src/operators/int_proxy/join.rs b/differential-dataflow/src/operators/int_proxy/join.rs
new file mode 100644
index 000000000..386eadc1a
--- /dev/null
+++ b/differential-dataflow/src/operators/int_proxy/join.rs
@@ -0,0 +1,136 @@
+//! The proxy join: equi-match by `key_hash`, value work by matched index lists.
+
+use std::collections::VecDeque;
+
+use timely::ContainerBuilder;
+use timely::dataflow::operators::Capability;
+use timely::dataflow::operators::generic::OutputBuilderSession;
+
+use crate::difference::{Multiply, Semigroup};
+use crate::lattice::Lattice;
+use crate::trace::BatchReader;
+use crate::trace::chunk::int_proxy::ProxyChunk;
+use crate::operators::join::{EffortBuilder, Fresh, JoinTactic};
+
+/// The join backend: value semantics for a proxy-space equijoin.
+///
+/// Protocol (per deferred work unit, driven by [`ProxyJoinTactic`]): one `present0`, one
+/// `present1`, then at most one `cross` whose indices refer to those two presentations.
+/// The backend must keep each presentation's alignment (run index → real record) until
+/// the `cross` call.
+pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
+    /// Diff type presented for the first input.
+    type R0: Semigroup + Multiply<Self::R1, Output = Self::ROut>;
+    /// Diff type presented for the second input.
+    type R1: Semigroup;
+    /// Diff type of matched records (`R0 * R1`), computed by the tactic.
+    type ROut: Semigroup;
+    /// The output container built from matched index lists.
+    type Output;
+
+    /// (read) Flatten `batches` into one sorted, consolidated proxy run.
+    fn present0(&mut self, batches: &[B0]) -> ProxyChunk<B0::Time, Self::R0>;
+    /// (read) As `present0`, for the second input.
+    fn present1(&mut self, batches: &[B1]) -> ProxyChunk<B0::Time, Self::R1>;
+    /// (value work) The projection. `left[i]`/`right[i]` index the current presentations;
+    /// each pair matched on `key_hash`. `times[i]`/`diffs[i]` are the DD-computed lattice
+    /// join of the pair's times and product of its diffs, to carry through per record.
+    fn cross(&mut self, left: &[usize], right: &[usize], times: Vec<B0::Time>, diffs: Vec<Self::ROut>) -> Self::Output;
+}
+
+/// A proxy-space [`JoinTactic`]: matches records of the two presented runs by `key_hash`,
+/// cross-products matched records with DD-computed times (lattice join) and diffs
+/// (product), and hands the backend the matched index lists for the value work.
+///
+/// Work units are queued by arrival direction (as in the cursor tactic) and currently
+/// drained eagerly; fuel budgeting is a later refinement.
+pub struct ProxyJoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, Bk> {
+    backend: Bk,
+    todo0: VecDeque<JoinUnit<B0, B1>>,
+    todo1: VecDeque<JoinUnit<B0, B1>>,
+}
+
+/// A deferred bilinear join unit: a fresh batch list against the accumulated other side.
+struct JoinUnit<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
+    left: Vec<B0>,
+    right: Vec<B1>,
+    capability: Capability<B0::Time>,
+}
+
+impl<B0: BatchReader, B1: BatchReader<Time = B0::Time>, Bk> ProxyJoinTactic<B0, B1, Bk> {
+    /// A tactic deferring all value semantics to `backend`.
+    pub fn new(backend: Bk) -> Self {
+        ProxyJoinTactic { backend, todo0: VecDeque::new(), todo1: VecDeque::new() }
+    }
+}
+
+impl<B0, B1, Bk, CB> JoinTactic<B0, B1, CB> for ProxyJoinTactic<B0, B1, Bk>
+where
+    B0: BatchReader,
+    B1: BatchReader<Time = B0::Time>,
+    Bk: ProxyJoinBackend<B0, B1>,
+    CB: ContainerBuilder<Container = Bk::Output>,
+{
+    fn defer(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, capability: Capability<B0::Time>) {
+        let unit = JoinUnit { left: input0, right: input1, capability };
+        match fresh {
+            Fresh::Input0 => self.todo0.push_back(unit),
+            Fresh::Input1 => self.todo1.push_back(unit),
+        }
+    }
+
+    fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>) {
+        while let Some(unit) = self.todo0.pop_front() {
+            join_unit(&mut self.backend, unit, output);
+        }
+        while let Some(unit) = self.todo1.pop_front() {
+            join_unit(&mut self.backend, unit, output);
+        }
+        *fuel = 0;
+    }
+}
+
+/// Join one deferred unit: present both sides, merge-match key runs over the sorted
+/// hashes, cross-product matched records, and hand the backend the index lists.
+fn join_unit<B0, B1, Bk, CB>(backend: &mut Bk, unit: JoinUnit<B0, B1>, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>)
+where
+    B0: BatchReader,
+    B1: BatchReader<Time = B0::Time>,
+    Bk: ProxyJoinBackend<B0, B1>,
+    CB: ContainerBuilder<Container = Bk::Output>,
+{
+    let p0 = backend.present0(&unit.left);
+    let p1 = backend.present1(&unit.right);
+    if p0.is_empty() || p1.is_empty() { return; }
+    let (k0, k1) = (p0.key_hashes(), p1.key_hashes());
+
+    let (mut li, mut ri) = (Vec::new(), Vec::new());
+    let (mut ot, mut od) = (Vec::new(), Vec::new());
+    let (mut i, mut j) = (0usize, 0usize);
+    while i < k0.len() && j < k1.len() {
+        if k0[i] < k1[j] {
+            i += 1;
+        } else if k1[j] < k0[i] {
+            j += 1;
+        } else {
+            let key = k0[i];
+            let mut e0 = i;
+            while e0 < k0.len() && k0[e0] == key { e0 += 1; }
+            let mut e1 = j;
+            while e1 < k1.len() && k1[e1] == key { e1 += 1; }
+            for a in i..e0 {
+                for b in j..e1 {
+                    li.push(a);
+                    ri.push(b);
+                    ot.push(p0.times()[a].join(&p1.times()[b]));
+                    od.push(p0.diffs()[a].clone().multiply(&p1.diffs()[b]));
+                }
+            }
+            i = e0;
+            j = e1;
+        }
+    }
+    if li.is_empty() { return; }
+    let mut container = backend.cross(&li, &ri, ot, od);
+    output.session_with_builder(&unit.capability).give_container(&mut container);
+}
diff --git a/differential-dataflow/src/operators/int_proxy/mod.rs b/differential-dataflow/src/operators/int_proxy/mod.rs
new file mode 100644
index 000000000..e102d456d
--- /dev/null
+++ b/differential-dataflow/src/operators/int_proxy/mod.rs
@@ -0,0 +1,96 @@
+//! Backend-agnostic join and reduce over integer proxies.
+//!
+//! The tactics here run DD's operator logic over [`ProxyChunk`]s — sorted, consolidated
+//! runs of `((key_hash, value_id), time, diff)` — while a backend keeps the real keys and
+//! values in whatever (typically columnar) layout it likes. Only integers cross the
+//! boundary, in both directions:
+//!
+//! * **Read side.** The backend *presents* a batch list as one proxy run
+//!   ([`ProxyJoinBackend::present0`], [`ProxyReduceBackend::present_input`], ...). DD
+//!   navigates the run — grouping by `key_hash`, consolidating diffs by `value_id`, and
+//!   running all lattice/time logic — and refers back to backend records only by *index
+//!   into the presented run*.
+//! * **Write side.** Reduce produces `((key_hash, value_id), time, diff)` deltas. The
+//!   `key_hash` is carried from the input key; output `value_id`s are *minted by hashing
+//!   the produced value* ([`ProxyReduceBackend::reduce`]), and the backend's
+//!   [`materialize`](ProxyReduceBackend::materialize) seals the proxy records into a real
+//!   output batch — a real arrangement, fit to be a downstream operator's input, where
+//!   the same value presents with the same id because the id *is* its content hash.
+//!
+//! The tactics implement the seams in [`join`](crate::operators::join) and
+//! [`reduce`](crate::operators::reduce): [`ProxyJoinTactic`] is a [`JoinTactic`] for
+//! [`join_with_tactic`](crate::operators::join::join_with_tactic), [`ProxyReduceTactic`] a
+//! [`ReduceTactic`] for [`reduce_with_tactic`](crate::operators::reduce::reduce_with_tactic).
+//! Neither driver requires `Navigable` of its input, so a cursor-less backend arrangement
+//! (a [`Chunk`](crate::trace::chunk::Chunk) that skips the navigation capability) suffices.
+//! The [`reference`](mod@reference) module supplies an in-memory backend over the
+//! [`VecChunk`](crate::trace::chunk::vec::VecChunk) layout, so the framework is testable
+//! without any columnar engine.
+//!
+//! [`JoinTactic`]: crate::operators::join::JoinTactic
+//! [`ReduceTactic`]: crate::operators::reduce::ReduceTactic
+//!
+//! # The two integers
+//!
+//! * `key_hash: u64` — a content hash of the key, stable across the whole system with no
+//!   registry: the same key hashes identically in every operator, including across the
+//!   output→input boundary. The hash function is a property of the *backend* (all of its
+//!   operators must share it); DD never hashes anything.
+//! * `value_id: u64` — an intra-key value identifier, consistent within one operator
+//!   computation: equal ids ⇒ equal values there, which is what consolidation and
+//!   presence need. On the write side ids must be content hashes (see above); on the
+//!   read side a backend may use any per-computation-consistent scheme, and `id =
+//!   hash(value)` is the natural choice since it makes the read and write id spaces
+//!   coincide (min "reusing an input value's id" is then automatic).
+//!
+//! # Design note: `value_id` is *not* order-preserving
+//!
+//! We considered assigning `value_id`s in value order within each key, which would let
+//! the reduce tactic compute order-sensitive reductions (min/max) directly over the
+//! integers. We decided against it; min/max fall to the value callback. Why:
+//!
+//! 1. **It would reimport the cost the framework exists to avoid.** Order-preserving ids
+//!    require the backend to rank values by their *semantic* order per key per
+//!    presentation. Columnar backends deliberately order by their own structural
+//!    comparison (any consistent total order is fine for arrangement maintenance);
+//!    imposing the semantic `Ord` is exactly the row-wise value-comparison cost being
+//!    removed.
+//! 2. **The write side scrambles order anyway.** Minted ids must be stable content
+//!    hashes, and hashes are order-blind. An order-preserving read side would be a second
+//!    id regime living alongside the hashed one; a single hash-based scheme serves both.
+//! 3. **Division of labor stays clean.** The tactic's competence is time/lattice logic,
+//!    for which id *equality* suffices. Order is value semantics, and all value semantics
+//!    live behind the callback — which sees one key's few present values, the same work
+//!    a row backend does for min today, without the value materialization elsewhere.
+//!
+//! The cost: min/max cannot be answered purely in proxy space. The callback does one pass
+//! over the key's present values — acceptable, and recoverable later backend-side with a
+//! columnar min primitive applied across many keys per wave.
+//!
+//! # Collision risk
+//!
+//! Ids are 64-bit content hashes. Colliding *keys* merge two groups (a join would
+//! cross-match them; a reduce would reduce their union); colliding output *values* would
+//! alias two outputs. By the birthday bound the probability of any collision among `n`
+//! distinct keys (or values) is ≈ `n²/2⁶⁵`: about `5·10⁻⁸` at a million, `5·10⁻²` at a
+//! billion. This is the accepted risk of the design — it buys global id stability with no
+//! registry and no coordination. If a deployment's key cardinality makes the bound
+//! uncomfortable, the upgrade path is widening the id to 128 bits (a second id column),
+//! not a registry.
+//!
+//! # What DD owns vs what the backend owns
+//!
+//! DD (the tactics, written once): interesting-time discovery (joins of input times),
+//! wave navigation, per-`(key, time)` desired-vs-current deltas, `pending` keyed by the
+//! stable `key_hash` across retires, held-capability bucket routing, output batch
+//! descriptions, and all sorting/merging/consolidation of proxy runs. The backend:
+//! hashing, the value function, and building real columns from ids. The backend never
+//! sees a timestamp except as an opaque payload.
+
+pub mod join;
+pub mod reduce;
+pub mod reference;
+
+pub use crate::trace::chunk::int_proxy::ProxyChunk;
+pub use join::{ProxyJoinBackend, ProxyJoinTactic};
+pub use reduce::{ProxyReduceBackend, ProxyReduceTactic};
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
new file mode 100644
index 000000000..cad65aadf
--- /dev/null
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -0,0 +1,306 @@
+//! The proxy reduce: all interesting-time logic in proxy space, value work by callback.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use timely::PartialOrder;
+use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
+
+use crate::difference::{Abelian, IsZero, Semigroup};
+use crate::lattice::Lattice;
+use crate::trace::{BatchReader, Description};
+use crate::trace::chunk::int_proxy::ProxyChunk;
+use crate::operators::reduce::ReduceTactic;
+
+/// The reduce backend: value semantics for a proxy-space reduction.
+///
+/// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `key_hashes` (over the
+/// new input batches), one `present_input`, one `present_output`, any number of `reduce`
+/// calls whose indices refer to the input presentation, then one `materialize` per output
+/// batch. Within one retire the backend must be able to resolve every presented
+/// `key_hash` to its key and every presented or minted `value_id` to its value.
+pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
+    /// Diff type presented for the input.
+    type RIn: Semigroup;
+    /// Diff type of the output; the desired-vs-current delta needs negation.
+    type ROut: Abelian + 'static;
+
+    /// The `key_hash`es appearing in `batches`, sorted and deduplicated. Used by the
+    /// tactic to find the keys whose output can change this interval.
+    fn key_hashes(&self, batches: &[B1]) -> Vec<u64>;
+    /// (read) Flatten the input history (`history` ∪ `novel`, the accumulated trace and
+    /// the freshly arrived batches) into one sorted, consolidated proxy run, restricted to
+    /// the sorted `keys`. The restriction is load-bearing: presenting only changed keys is
+    /// what keeps small-delta recursion from re-reading the accumulated trace each round.
+    fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, Self::RIn>;
+    /// (read) As `present_input`, for the operator's own output trace. The `value_id`s
+    /// here are the stable output-value hashes and must agree with ids minted by
+    /// [`reduce`](Self::reduce) — which they do for free when both hash the value.
+    fn present_output(&mut self, batches: &[B2], keys: &[u64]) -> ProxyChunk<B1::Time, Self::ROut>;
+    /// (value callback) Apply the reduction to one key's accumulated input: `input` holds
+    /// one entry per value with a nonzero accumulation — a representative record index
+    /// into the current input presentation, and the accumulated diff. Never called with
+    /// `input` empty. Returns the reduced output as `(value_id, diff)`, minting ids for
+    /// produced values (`id = hash(value)`) and recording `id → value` for `materialize`.
+    fn reduce(&mut self, key_hash: u64, input: &[(usize, Self::RIn)]) -> Vec<(u64, Self::ROut)>;
+    /// (egress) Seal proxy-space output records into a real output batch: resolve each
+    /// record's `key_hash` and `value_id` to real data, order by the backend's own record
+    /// order, and build the batch with the given description. `records` may be empty (the
+    /// description still advances the output trace).
+    fn materialize(&mut self, records: ProxyChunk<B1::Time, Self::ROut>, description: Description<B1::Time>) -> B2;
+}
+
+/// A proxy-space [`ReduceTactic`]: owns all interesting-time logic over
+/// `(key_hash, value_id, time, diff)`, calling the backend only for value semantics.
+///
+/// Per changed key (keys touched by new input, plus keys carrying pending times) it
+/// derives the active times in `[lower, upper)` — joins of input times, seeded by the
+/// novel times — and at each, consolidates the input by `value_id` (presence), asks the
+/// backend for the desired output, subtracts the current output (committed history plus
+/// deltas emitted this pass), and emits the difference into the held-time bucket. Times
+/// at or beyond `upper` are pended, keyed by the stable `key_hash`, so they survive
+/// retires without any reference to backend state.
+pub struct ProxyReduceTactic<T, Bk> {
+    backend: Bk,
+    /// Outstanding interesting `(key, time)` moments at or beyond the last interval,
+    /// keyed by the stable key hash (a `BTreeMap` for deterministic iteration).
+    pending: BTreeMap<u64, Vec<T>>,
+}
+
+impl<T, Bk> ProxyReduceTactic<T, Bk> {
+    /// A tactic deferring all value semantics to `backend`.
+    pub fn new(backend: Bk) -> Self {
+        ProxyReduceTactic { backend, pending: BTreeMap::new() }
+    }
+}
+
+/// The active times for an interval `[lower, upper)`: joins of input times (`novel` +
+/// `prior`) reachable from the `novel` seeds that are not at or beyond `upper`; those at
+/// or beyond are `pended` for a future interval. Over-derivation is sound (a non-changing
+/// time yields a zero delta).
+fn active_times<T: Lattice + Ord + Clone>(
+    upper: AntichainRef<T>,
+    prior: &[T],
+    novel: &[T],
+    active: &mut BTreeSet<T>,
+    pended: &mut BTreeSet<T>,
+) {
+    let mut todo: BTreeSet<T> = novel.iter().cloned().collect();
+    while let Some(next) = todo.pop_first() {
+        if upper.less_equal(&next) {
+            pended.insert(next);
+        } else if active.insert(next.clone()) {
+            for t in novel.iter().chain(prior.iter()) {
+                let join = next.join(t);
+                if !active.contains(&join) {
+                    todo.insert(join);
+                }
+            }
+        }
+    }
+}
+
+impl<B1, B2, Bk> ReduceTactic<B1, B2> for ProxyReduceTactic<B1::Time, Bk>
+where
+    B1: BatchReader,
+    B2: BatchReader<Time = B1::Time>,
+    Bk: ProxyReduceBackend<B1, B2>,
+{
+    fn retire(
+        &mut self,
+        source_batches: Vec<B1>,
+        output_batches: Vec<B2>,
+        input_batches: Vec<B1>,
+        lower: &Antichain<B1::Time>,
+        upper: &Antichain<B1::Time>,
+        held: &Antichain<B1::Time>,
+    ) -> (Vec<(B1::Time, B2)>, Antichain<B1::Time>) {
+        // Only work if we hold a time we can actually ship in [.., upper).
+        if held.elements().iter().all(|t| upper.less_equal(t)) {
+            return (Vec::new(), held.clone());
+        }
+
+        // Only keys touched by the new input delta or carrying pending times can change
+        // output in [lower, upper); everything else is untouched. This restriction keeps
+        // per-retire cost proportional to the delta, not the accumulation.
+        let mut changed: BTreeSet<u64> = self.backend.key_hashes(&input_batches).into_iter().collect();
+        changed.extend(self.pending.keys().copied());
+        if changed.is_empty() {
+            // No input delta and no carried pending: no key's output can change, and
+            // nothing remains to hold. Downgrade to the EMPTY frontier — returning `held`
+            // would keep the capability forever and deadlock a recursive scope.
+            self.pending.clear();
+            return (Vec::new(), Antichain::new());
+        }
+        let changed: Vec<u64> = changed.into_iter().collect();
+
+        // The two read-side presentations, restricted to the changed keys: the full input
+        // history (accumulated ∪ new) and the output history. Sorted by (key, val, time).
+        let p_in = self.backend.present_input(&source_batches, &input_batches, &changed);
+        let p_out = self.backend.present_output(&output_batches, &changed);
+
+        // One output-record bucket per held time; a delta at `t` routes to the largest
+        // held time `<= t`.
+        let held_elems: Vec<B1::Time> = held.elements().to_vec();
+        let mut buckets: Vec<Vec<((u64, u64), B1::Time, Bk::ROut)>> = vec![Vec::new(); held_elems.len()];
+
+        let mut new_pending: BTreeMap<u64, Vec<B1::Time>> = BTreeMap::new();
+
+        // March through the changed keys; both presentations hold only changed keys, in
+        // hash order, so the ranges advance monotonically.
+        let (mut is, mut os) = (0usize, 0usize);
+        for &key in &changed {
+            while is < p_in.len() && p_in.key_hashes()[is] < key { is += 1; }
+            let i0 = is;
+            while is < p_in.len() && p_in.key_hashes()[is] == key { is += 1; }
+            let i1 = is;
+            while os < p_out.len() && p_out.key_hashes()[os] < key { os += 1; }
+            let o0 = os;
+            while os < p_out.len() && p_out.key_hashes()[os] == key { os += 1; }
+            let o1 = os;
+
+            // Seeds: input times in [lower, upper) plus carried pending times; join
+            // partners: input times before `lower`.
+            let mut novel: Vec<B1::Time> = p_in.times()[i0..i1]
+                .iter()
+                .filter(|t| lower.less_equal(t) && !upper.less_equal(t))
+                .cloned()
+                .collect();
+            if let Some(p) = self.pending.get(&key) {
+                novel.extend(p.iter().cloned());
+            }
+            novel.sort();
+            novel.dedup();
+            let prior: Vec<B1::Time> = p_in.times()[i0..i1]
+                .iter()
+                .filter(|t| !lower.less_equal(t))
+                .cloned()
+                .collect();
+
+            let mut active = BTreeSet::new();
+            let mut pended = BTreeSet::new();
+            active_times(upper.borrow(), &prior, &novel, &mut active, &mut pended);
+            if !pended.is_empty() {
+                new_pending.entry(key).or_default().extend(pended);
+            }
+            if active.is_empty() {
+                continue;
+            }
+
+            // Deltas emitted for this key earlier in this pass; part of "current output".
+            let mut emitted: Vec<(u64, B1::Time, Bk::ROut)> = Vec::new();
+            for t in active {
+                // Input accumulation at `t`, consolidated by value id: the key's records
+                // are sorted by (value_id, time), so each id is one contiguous run.
+                let mut acc: Vec<(usize, Bk::RIn)> = Vec::new();
+                let mut a = i0;
+                while a < i1 {
+                    let vid = p_in.value_ids()[a];
+                    let rep = a;
+                    let mut net: Option<Bk::RIn> = None;
+                    while a < i1 && p_in.value_ids()[a] == vid {
+                        if p_in.times()[a].less_equal(&t) {
+                            match net.as_mut() {
+                                Some(n) => n.plus_equals(&p_in.diffs()[a]),
+                                None => net = Some(p_in.diffs()[a].clone()),
+                            }
+                        }
+                        a += 1;
+                    }
+                    if let Some(n) = net {
+                        if !n.is_zero() {
+                            acc.push((rep, n));
+                        }
+                    }
+                }
+
+                // Current output at `t`: committed history plus this pass's deltas.
+                let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
+                for o in o0..o1 {
+                    if p_out.times()[o].less_equal(&t) {
+                        match cur.entry(p_out.value_ids()[o]) {
+                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&p_out.diffs()[o]),
+                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(p_out.diffs()[o].clone()); }
+                        }
+                    }
+                }
+                for (vid, et, d) in emitted.iter() {
+                    if et.less_equal(&t) {
+                        match cur.entry(*vid) {
+                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
+                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(d.clone()); }
+                        }
+                    }
+                }
+                cur.retain(|_, d| !d.is_zero());
+
+                if acc.is_empty() && cur.is_empty() {
+                    continue;
+                }
+                // The desired output; the value callback is only consulted for non-empty
+                // input (matching the row reduce contract) — an empty accumulation's
+                // desired output is empty, and the delta below retracts `cur`.
+                let desired = if acc.is_empty() { Vec::new() } else { self.backend.reduce(key, &acc) };
+
+                // delta = desired − current, in proxy space.
+                let mut delta: BTreeMap<u64, Bk::ROut> = cur;
+                for d in delta.values_mut() {
+                    d.negate();
+                }
+                for (vid, d) in desired {
+                    match delta.entry(vid) {
+                        std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
+                        std::collections::btree_map::Entry::Vacant(e) => { e.insert(d); }
+                    }
+                }
+                delta.retain(|_, d| !d.is_zero());
+                if delta.is_empty() {
+                    continue;
+                }
+
+                let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
+                for (vid, d) in delta {
+                    emitted.push((vid, t.clone(), d.clone()));
+                    buckets[idx].push(((key, vid), t.clone(), d));
+                }
+            }
+        }
+
+        self.pending = new_pending;
+
+        // Build one output batch per held time, tiling [lower, upper): batch `i`'s upper
+        // is `upper` joined with the later held times, so the descriptions abut.
+        let mut produced = Vec::new();
+        let mut out_lower = lower.clone();
+        for (index, rows) in buckets.into_iter().enumerate() {
+            let mut out_upper = upper.clone();
+            for t in &held_elems[index + 1..] {
+                out_upper.insert(t.clone());
+            }
+            if out_upper != out_lower {
+                let description = Description::new(out_lower.clone(), out_upper.clone(), Antichain::from_elem(<B1::Time as Timestamp>::minimum()));
+                let (mut ks, mut vs) = (Vec::with_capacity(rows.len()), Vec::with_capacity(rows.len()));
+                let (mut ts, mut ds) = (Vec::with_capacity(rows.len()), Vec::with_capacity(rows.len()));
+                for ((k, v), t, d) in rows {
+                    ks.push(k);
+                    vs.push(v);
+                    ts.push(t);
+                    ds.push(d);
+                }
+                let (records, _reps) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
+                let batch = self.backend.materialize(records, description);
+                produced.push((held_elems[index].clone(), batch));
+                out_lower = out_upper;
+            }
+        }
+
+        // New held frontier: the lower envelope of all carried pending times.
+        let mut frontier = Antichain::new();
+        for times in self.pending.values() {
+            for t in times {
+                frontier.insert_ref(t);
+            }
+        }
+        (produced, frontier)
+    }
+}
diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
new file mode 100644
index 000000000..93250c3e4
--- /dev/null
+++ b/differential-dataflow/src/operators/int_proxy/reference.rs
@@ -0,0 +1,258 @@
+//! The in-memory reference backend: real data in [`VecChunk`] arrangements, ids by
+//! hashing the real keys and values with the crate's [`Hashable`] (a deterministic,
+//! process-wide-stable content hash — the "system-wide hash function" every backend must
+//! fix for itself).
+//!
+//! [`VecChunk`]: crate::trace::chunk::vec::VecChunk
+//! [`Hashable`]: crate::hashable::Hashable
+
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+use timely::progress::Timestamp;
+
+use crate::difference::{Abelian, Multiply, Semigroup};
+use crate::hashable::Hashable;
+use crate::lattice::Lattice;
+use crate::trace::{Builder, Description, Navigable};
+use crate::trace::cursor::Cursor;
+use crate::trace::chunk::{ChunkBatch, ChunkBuilder};
+use crate::trace::chunk::int_proxy::ProxyChunk;
+use crate::trace::chunk::vec::VecChunk;
+
+use super::join::ProxyJoinBackend;
+use super::reduce::ProxyReduceBackend;
+
+/// The backend's stable content hash: same input → same `u64`, everywhere in the
+/// process, with no registry.
+pub fn stable_hash<D: Hash>(data: &D) -> u64 {
+    data.hashed()
+}
+
+/// A batch of the reference backend's arrangements.
+pub type RefBatch<K, V, T, R> = Rc<ChunkBatch<VecChunk<K, V, T, R>>>;
+
+/// Read `batches` (restricted to keys whose hash is in the sorted `filter`, if any)
+/// into parallel proxy and real columns, one entry per `(key, val, time, diff)` record.
+fn read_rows<K, V, T, R>(
+    batches: &[RefBatch<K, V, T, R>],
+    filter: Option<&[u64]>,
+    keys: &mut Vec<u64>,
+    vals: &mut Vec<u64>,
+    times: &mut Vec<T>,
+    diffs: &mut Vec<R>,
+    reals: &mut Vec<(K, V)>,
+) where
+    K: Ord + Clone + Hash + 'static,
+    V: Ord + Clone + Hash + 'static,
+    T: Lattice + Timestamp,
+    R: Ord + Semigroup + 'static,
+{
+    for batch in batches {
+        let mut cursor = batch.cursor();
+        while let Some(k) = cursor.get_key(batch) {
+            let kh = stable_hash(k);
+            if filter.is_none_or(|f| f.binary_search(&kh).is_ok()) {
+                while let Some(v) = cursor.get_val(batch) {
+                    let vh = stable_hash(v);
+                    cursor.map_times(batch, |t, d| {
+                        keys.push(kh);
+                        vals.push(vh);
+                        times.push(t.clone());
+                        diffs.push(d.clone());
+                        reals.push((k.clone(), v.clone()));
+                    });
+                    cursor.step_val(batch);
+                }
+            }
+            cursor.step_key(batch);
+        }
+    }
+}
+
+/// Present a batch list as a sorted, consolidated proxy run plus the aligned real
+/// records (entry `i` is presented record `i`'s real `(key, val)`).
+fn present<K, V, T, R>(batches: &[&[RefBatch<K, V, T, R>]], filter: Option<&[u64]>) -> (ProxyChunk<T, R>, Vec<(K, V)>)
+where
+    K: Ord + Clone + Hash + 'static,
+    V: Ord + Clone + Hash + 'static,
+    T: Lattice + Timestamp,
+    R: Ord + Semigroup + 'static,
+{
+    let (mut ks, mut vs) = (Vec::new(), Vec::new());
+    let (mut ts, mut ds) = (Vec::new(), Vec::new());
+    let mut reals = Vec::new();
+    for list in batches {
+        read_rows(list, filter, &mut ks, &mut vs, &mut ts, &mut ds, &mut reals);
+    }
+    let (chunk, reps) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
+    let aligned = reps.iter().map(|&i| reals[i].clone()).collect();
+    (chunk, aligned)
+}
+
+/// The join backend: presents [`VecChunk`] batches by hashing, applies a
+/// `(key, val0, val1) → data` projection to matched index pairs, and emits
+/// `Vec<(data, time, diff)>` containers.
+pub struct VecJoinBackend<K, V0, V1, D, L> {
+    logic: L,
+    /// Real records aligned with the current first-input presentation.
+    left: Vec<(K, V0)>,
+    /// Real values aligned with the current second-input presentation.
+    right: Vec<V1>,
+    marker: PhantomData<fn() -> D>,
+}
+
+impl<K, V0, V1, D, L> VecJoinBackend<K, V0, V1, D, L> {
+    /// A backend applying `logic` to each matched `(key, val0, val1)`.
+    pub fn new(logic: L) -> Self {
+        VecJoinBackend { logic, left: Vec::new(), right: Vec::new(), marker: PhantomData }
+    }
+}
+
+impl<K, V0, V1, T, R0, R1, RO, D, L> ProxyJoinBackend<RefBatch<K, V0, T, R0>, RefBatch<K, V1, T, R1>> for VecJoinBackend<K, V0, V1, D, L>
+where
+    K: Ord + Clone + Hash + 'static,
+    V0: Ord + Clone + Hash + 'static,
+    V1: Ord + Clone + Hash + 'static,
+    T: Lattice + Timestamp,
+    R0: Ord + Semigroup + Multiply<R1, Output = RO> + 'static,
+    R1: Ord + Semigroup + 'static,
+    RO: Semigroup + 'static,
+    D: 'static,
+    L: FnMut(&K, &V0, &V1) -> D,
+{
+    type R0 = R0;
+    type R1 = R1;
+    type ROut = RO;
+    type Output = Vec<(D, T, RO)>;
+
+    fn present0(&mut self, batches: &[RefBatch<K, V0, T, R0>]) -> ProxyChunk<T, R0> {
+        let (chunk, reals) = present(&[batches], None);
+        self.left = reals;
+        chunk
+    }
+
+    fn present1(&mut self, batches: &[RefBatch<K, V1, T, R1>]) -> ProxyChunk<T, R1> {
+        let (chunk, reals) = present(&[batches], None);
+        self.right = reals.into_iter().map(|(_, v)| v).collect();
+        chunk
+    }
+
+    fn cross(&mut self, left: &[usize], right: &[usize], times: Vec<T>, diffs: Vec<RO>) -> Vec<(D, T, RO)> {
+        let mut out = Vec::with_capacity(left.len());
+        for (((&l, &r), t), d) in left.iter().zip(right).zip(times).zip(diffs) {
+            let (k, v0) = &self.left[l];
+            let v1 = &self.right[r];
+            out.push(((self.logic)(k, v0, v1), t, d));
+        }
+        out
+    }
+}
+
+/// The reduce backend: presents [`VecChunk`] batches by hashing, applies the
+/// user's reduction logic (row-reduce-shaped: `(key, &[(val, diff)], &mut output)`)
+/// per key, mints output ids by hashing produced values, and materializes proxy records
+/// back into [`VecChunk`] output batches.
+pub struct VecReduceBackend<K, V, V2, L> {
+    logic: L,
+    /// `key_hash → key`, primed by the presentations of the current retire.
+    keys: HashMap<u64, K>,
+    /// Real values aligned with the current input presentation.
+    in_vals: Vec<V>,
+    /// `value_id → output value`, primed by the output presentation and by minting.
+    out_vals: HashMap<u64, V2>,
+}
+
+impl<K, V, V2, L> VecReduceBackend<K, V, V2, L> {
+    /// A backend applying `logic` — shaped like the row reduce's closure — per key.
+    pub fn new(logic: L) -> Self {
+        VecReduceBackend { logic, keys: HashMap::new(), in_vals: Vec::new(), out_vals: HashMap::new() }
+    }
+}
+
+impl<K, V, V2, T, RIn, ROut, L> ProxyReduceBackend<RefBatch<K, V, T, RIn>, RefBatch<K, V2, T, ROut>> for VecReduceBackend<K, V, V2, L>
+where
+    K: Ord + Clone + Hash + 'static,
+    V: Ord + Clone + Hash + 'static,
+    V2: Ord + Clone + Hash + 'static,
+    T: Lattice + Timestamp,
+    RIn: Ord + Semigroup + 'static,
+    ROut: Ord + Abelian + 'static,
+    L: FnMut(&K, &[(&V, RIn)], &mut Vec<(V2, ROut)>),
+{
+    type RIn = RIn;
+    type ROut = ROut;
+
+    fn key_hashes(&self, batches: &[RefBatch<K, V, T, RIn>]) -> Vec<u64> {
+        let mut hashes = Vec::new();
+        for batch in batches {
+            let mut cursor = batch.cursor();
+            while let Some(k) = cursor.get_key(batch) {
+                hashes.push(stable_hash(k));
+                cursor.step_key(batch);
+            }
+        }
+        hashes.sort_unstable();
+        hashes.dedup();
+        hashes
+    }
+
+    fn present_input(&mut self, history: &[RefBatch<K, V, T, RIn>], novel: &[RefBatch<K, V, T, RIn>], keys: &[u64]) -> ProxyChunk<T, RIn> {
+        let (chunk, reals) = present(&[history, novel], Some(keys));
+        for (k, _) in &reals {
+            self.keys.entry(stable_hash(k)).or_insert_with(|| k.clone());
+        }
+        self.in_vals = reals.into_iter().map(|(_, v)| v).collect();
+        chunk
+    }
+
+    fn present_output(&mut self, batches: &[RefBatch<K, V2, T, ROut>], keys: &[u64]) -> ProxyChunk<T, ROut> {
+        let (chunk, reals) = present(&[batches], Some(keys));
+        for (i, (k, v)) in reals.into_iter().enumerate() {
+            self.keys.entry(chunk.key_hashes()[i]).or_insert(k);
+            self.out_vals.entry(chunk.value_ids()[i]).or_insert(v);
+        }
+        chunk
+    }
+
+    fn reduce(&mut self, key_hash: u64, input: &[(usize, RIn)]) -> Vec<(u64, ROut)> {
+        let key = self.keys.get(&key_hash).expect("key presented this retire");
+        // The value semantics are the backend's: the reduction contract presents
+        // values in their `Ord` order, so sort the (hash-ordered) accumulation.
+        let mut pairs: Vec<(&V, RIn)> = input.iter().map(|&(i, ref d)| (&self.in_vals[i], d.clone())).collect();
+        pairs.sort_by(|a, b| a.0.cmp(b.0));
+        let mut produced = Vec::new();
+        (self.logic)(key, &pairs, &mut produced);
+        produced
+            .into_iter()
+            .map(|(v, d)| {
+                let id = stable_hash(&v);
+                self.out_vals.entry(id).or_insert(v);
+                (id, d)
+            })
+            .collect()
+    }
+
+    fn materialize(&mut self, records: ProxyChunk<T, ROut>, description: Description<T>) -> RefBatch<K, V2, T, ROut> {
+        // Resolve ids to real data and re-order by the *real* record order — the proxy
+        // ordering (by hash) is not the arrangement's ordering.
+        let mut rows: Vec<((K, V2), T, ROut)> = (0..records.len())
+            .map(|i| {
+                let k = self.keys.get(&records.key_hashes()[i]).expect("key presented this retire").clone();
+                let v = self.out_vals.get(&records.value_ids()[i]).expect("value presented or minted this retire").clone();
+                ((k, v), records.times()[i].clone(), records.diffs()[i].clone())
+            })
+            .collect();
+        crate::consolidation::consolidate_updates(&mut rows);
+        let mut chunk = VecChunk::default();
+        for row in rows {
+            use timely::container::PushInto;
+            chunk.push_into(row);
+        }
+        let mut builder = ChunkBuilder::<VecChunk<K, V2, T, ROut>>::with_capacity(0, 0, 0);
+        builder.push(&mut chunk);
+        builder.done(description)
+    }
+}
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index b2771432c..9bd9d9341 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -53,7 +53,7 @@ impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
 }
 
 /// A type that can manage the joining of lists of batches.
-pub(crate) trait JoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, CB: ContainerBuilder> {
+pub trait JoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, CB: ContainerBuilder> {
     /// Prepare for work the join of two lists of corresponding batches, against a sufficient capability.
     ///
     /// `fresh` names which input contributed the freshly-arrived batch; its times all lie at or beyond
@@ -70,7 +70,7 @@ pub(crate) trait JoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, C
 /// The fresh batch's times all lie at or beyond the capability, so its side is not advanced by the
 /// capability's meet; the opposing accumulated trace is. The marker also selects which queue a unit
 /// joins, so a burst on one input cannot starve the other.
-pub(crate) enum Fresh {
+pub enum Fresh {
     /// The first input (`B0`) contributed the fresh batch.
     Input0,
     /// The second input (`B1`) contributed the fresh batch.
@@ -108,7 +108,7 @@ where
 /// compaction) and routes the per-batch work through the tactic. It requires only `TraceReader` of its
 /// inputs, never `Navigable`: it extracts trace batches via `batches_through`, and building cursors over
 /// them (if that is how the join proceeds) is the tactic's concern.
-pub(crate) fn join_with_tactic<'scope, Tr1, Tr2, T, CB>(arranged1: Arranged<'scope, Tr1>, arranged2: Arranged<'scope, Tr2>, mut tactic: T) -> Stream<'scope, Tr1::Time, CB::Container>
+pub fn join_with_tactic<'scope, Tr1, Tr2, T, CB>(arranged1: Arranged<'scope, Tr1>, arranged2: Arranged<'scope, Tr2>, mut tactic: T) -> Stream<'scope, Tr1::Time, CB::Container>
 where
     Tr1: TraceReader+'static,
     Tr2: TraceReader<Time = Tr1::Time>+'static,
diff --git a/differential-dataflow/src/operators/mod.rs b/differential-dataflow/src/operators/mod.rs
index a2e0a32b2..ea4242048 100644
--- a/differential-dataflow/src/operators/mod.rs
+++ b/differential-dataflow/src/operators/mod.rs
@@ -9,6 +9,7 @@ pub use self::count::CountTotal;
 pub use self::threshold::ThresholdTotal;
 
 pub mod arrange;
+pub mod int_proxy;
 pub mod reduce;
 pub mod iterate;
 pub mod join;
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 55210ace4..9feb66bbb 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -29,7 +29,7 @@ use crate::trace::implementations::containers::BatchContainer;
 /// Unlike join, reduce does not suspend: its output is at most linear in its input, so a single
 /// `retire` runs the whole `[lower, upper)` interval to completion rather than yielding under a fuel
 /// budget.
-pub(crate) trait ReduceTactic<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
+pub trait ReduceTactic<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
     /// Retire the interval `[lower, upper)`, producing the output batches it informs.
     ///
     /// It is presented with the pre-existing input batches and output batches (those before `lower`),
@@ -85,7 +85,7 @@ pub use reference::reduce_trace_reference;
 /// `TraceReader` of its input and `Trace` of its output, never `Navigable`: it extracts batches via
 /// `batches_through`, and building cursors over them (if that is how the reduce proceeds) is the
 /// tactic's concern.
-pub(crate) fn reduce_with_tactic<'scope, Tr1, Tr2, T>(trace: Arranged<'scope, Tr1>, name: &str, mut tactic: T) -> Arranged<'scope, TraceAgent<Tr2>>
+pub fn reduce_with_tactic<'scope, Tr1, Tr2, T>(trace: Arranged<'scope, Tr1>, name: &str, mut tactic: T) -> Arranged<'scope, TraceAgent<Tr2>>
 where
     Tr1: TraceReader + 'static,
     Tr2: Trace<Time = Tr1::Time> + 'static,
diff --git a/differential-dataflow/src/trace/chunk/int_proxy.rs b/differential-dataflow/src/trace/chunk/int_proxy.rs
new file mode 100644
index 000000000..5d2595091
--- /dev/null
+++ b/differential-dataflow/src/trace/chunk/int_proxy.rs
@@ -0,0 +1,505 @@
+//! [`ProxyChunk`]: sorted, consolidated runs of `((key_hash, value_id), time, diff)` — the
+//! integers-only boundary between DD's operator logic and a columnar value backend.
+//!
+//! A backend arrangement keeps its real keys and values in whatever layout it likes; what
+//! crosses to DD is a *projection* of each record onto two integers:
+//!
+//! * `key_hash: u64` — a content hash of the key, **stable across the whole system**: the
+//!   same key hashes identically in every operator, including across the output→input
+//!   boundary (a reduce output re-ingested as a downstream input), with no registry.
+//!   It drives grouping, ordering, and merging. Collisions are an accepted risk (see the
+//!   note in [`operators::int_proxy`](crate::operators::int_proxy)).
+//! * `value_id: u64` — an intra-key identifier for a value, **ephemeral**: consistent only
+//!   within a single operator computation (one presentation, one retire's waves). Equal
+//!   ids ⇒ equal values there, which is all DD needs to consolidate diffs per value and
+//!   decide presence. It is *not* order-preserving with respect to the value type's
+//!   semantic order — see the design note in [`operators::int_proxy`](crate::operators::int_proxy).
+//!
+//! Chunks sort by `(key_hash, value_id, time)` — an arbitrary but consistent total order
+//! over which DD's sort/merge/consolidate machinery is completely data-blind. Time and
+//! diff stay DD-native: the backend never needs to understand timestamps.
+//!
+//! # Relation to the `Chunk` / `NavigableChunk` split
+//!
+//! `ProxyChunk` implements [`Chunk`], so it slots directly into the #778 machinery: batches
+//! (`ChunkBatch<ProxyChunk>`), fueled merging (`ChunkBatchMerger`), grading (`settle`) all
+//! come for free, entirely in integer space. Like a columnar backend's chunk (and unlike
+//! [`VecChunk`](super::vec::VecChunk)) it is deliberately **not** [`NavigableChunk`](super::NavigableChunk):
+//! its consumers are whole-chunk tactics that read the columns in bulk, not cursors.
+//! (`u64` keys and values are `Ord`, so the capability could be added if a cursor-driven
+//! consumer ever wants it.)
+//!
+//! Only the ids live here; the real data stays in the backend. Read-side chunks are
+//! produced by a backend's `present` (see [`operators::int_proxy`](crate::operators::int_proxy)),
+//! which retains the alignment from record index to real record. Write-side chunks are
+//! assembled by the reduce tactic from `((key_hash, value_id), time, diff)` deltas and
+//! handed back to the backend's `materialize` to become a real output batch.
+
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
+
+use crate::difference::Semigroup;
+use crate::lattice::Lattice;
+
+use super::{pack, Chunk};
+
+/// The grading target. Records are four machine words plus time; small chunks would
+/// under-amortize per-chunk overhead, and the fueled merger wants to yield.
+const TARGET: usize = 8192;
+
+/// Shared, immutable chunk contents; `Clone` of an [`ProxyChunk`] is an `Rc` bump.
+struct Inner<T, R> {
+    /// Key hash column, aligned with the others, sorted by `(key, val, time)`.
+    keys: Vec<u64>,
+    /// Value id column.
+    vals: Vec<u64>,
+    /// Per-record times (the lattice algebra lives DD-side; ids never meet time).
+    times: Vec<T>,
+    /// Per-record diffs.
+    diffs: Vec<R>,
+}
+
+/// A sorted, consolidated run of `((key_hash, value_id), time, diff)`, shared via `Rc`.
+pub struct ProxyChunk<T, R>(Rc<Inner<T, R>>);
+
+impl<T, R> Clone for ProxyChunk<T, R> {
+    fn clone(&self) -> Self { ProxyChunk(Rc::clone(&self.0)) }
+}
+
+impl<T, R> Default for ProxyChunk<T, R> {
+    fn default() -> Self {
+        ProxyChunk(Rc::new(Inner { keys: Vec::new(), vals: Vec::new(), times: Vec::new(), diffs: Vec::new() }))
+    }
+}
+
+impl<T, R> ProxyChunk<T, R> {
+    /// The number of records.
+    pub fn len(&self) -> usize { self.0.times.len() }
+    /// True iff there are no records.
+    pub fn is_empty(&self) -> bool { self.len() == 0 }
+    /// The key hash column.
+    pub fn key_hashes(&self) -> &[u64] { &self.0.keys }
+    /// The value id column.
+    pub fn value_ids(&self) -> &[u64] { &self.0.vals }
+    /// The time column.
+    pub fn times(&self) -> &[T] { &self.0.times }
+    /// The diff column.
+    pub fn diffs(&self) -> &[R] { &self.0.diffs }
+}
+
+impl<T: Clone + Ord, R: Clone> ProxyChunk<T, R> {
+    /// Assemble a chunk from columns already sorted by `(key, val, time)` with no two
+    /// records equal in all three (i.e. consolidated).
+    pub fn from_sorted(keys: Vec<u64>, vals: Vec<u64>, times: Vec<T>, diffs: Vec<R>) -> Self {
+        debug_assert!(keys.len() == vals.len() && vals.len() == times.len() && times.len() == diffs.len());
+        debug_assert!((1..keys.len()).all(|i| {
+            (keys[i - 1], vals[i - 1], &times[i - 1]) < (keys[i], vals[i], &times[i])
+        }));
+        ProxyChunk(Rc::new(Inner { keys, vals, times, diffs }))
+    }
+
+    /// Extract the columns, copying only if the `Rc` is shared.
+    fn into_parts(self) -> (Vec<u64>, Vec<u64>, Vec<T>, Vec<R>) {
+        match Rc::try_unwrap(self.0) {
+            Ok(inner) => (inner.keys, inner.vals, inner.times, inner.diffs),
+            Err(rc) => (rc.keys.clone(), rc.vals.clone(), rc.times.clone(), rc.diffs.clone()),
+        }
+    }
+
+    /// The records at `idx`, as a new chunk (the integer `gather`).
+    fn gather(&self, idx: impl Iterator<Item = usize> + Clone) -> Self {
+        let inner = &*self.0;
+        ProxyChunk(Rc::new(Inner {
+            keys: idx.clone().map(|i| inner.keys[i]).collect(),
+            vals: idx.clone().map(|i| inner.vals[i]).collect(),
+            times: idx.clone().map(|i| inner.times[i].clone()).collect(),
+            diffs: idx.map(|i| inner.diffs[i].clone()).collect(),
+        }))
+    }
+}
+
+impl<T, R> ProxyChunk<T, R>
+where
+    T: Clone + Ord,
+    R: Semigroup + Clone,
+{
+    /// Sort columns by `(key, val, time)` and consolidate equal triples (summing diffs,
+    /// dropping zeros). Returns the chunk and, per retained record, the original index of
+    /// a *representative* input record — the link a backend needs to keep its real columns
+    /// aligned with the id run it presents (equal ids denote equal values, so any member
+    /// of a consolidated group serves).
+    pub fn from_unsorted(keys: Vec<u64>, vals: Vec<u64>, times: Vec<T>, diffs: Vec<R>) -> (Self, Vec<usize>) {
+        let n = times.len();
+        debug_assert!(keys.len() == n && vals.len() == n && diffs.len() == n);
+        let mut perm: Vec<usize> = (0..n).collect();
+        perm.sort_by(|&a, &b| (keys[a], vals[a], &times[a]).cmp(&(keys[b], vals[b], &times[b])));
+
+        let (mut ok, mut ov) = (Vec::new(), Vec::new());
+        let (mut ot, mut od) = (Vec::new(), Vec::new());
+        let mut reps = Vec::new();
+        let mut i = 0;
+        while i < n {
+            let r = perm[i];
+            let (k, v, t) = (keys[r], vals[r], &times[r]);
+            let mut d = diffs[r].clone();
+            let mut j = i + 1;
+            while j < n && {
+                let s = perm[j];
+                keys[s] == k && vals[s] == v && times[s] == *t
+            } {
+                d.plus_equals(&diffs[perm[j]]);
+                j += 1;
+            }
+            if !d.is_zero() {
+                ok.push(k);
+                ov.push(v);
+                ot.push(t.clone());
+                od.push(d);
+                reps.push(r);
+            }
+            i = j;
+        }
+        (ProxyChunk(Rc::new(Inner { keys: ok, vals: ov, times: ot, diffs: od })), reps)
+    }
+}
+
+/// Column builders for one output chunk, emitted at `TARGET`.
+struct OutBuf<T, R> {
+    keys: Vec<u64>,
+    vals: Vec<u64>,
+    times: Vec<T>,
+    diffs: Vec<R>,
+}
+
+impl<T: Clone + Ord, R: Clone> OutBuf<T, R> {
+    fn new() -> Self {
+        OutBuf { keys: Vec::new(), vals: Vec::new(), times: Vec::new(), diffs: Vec::new() }
+    }
+    fn push(&mut self, k: u64, v: u64, t: T, d: R) {
+        self.keys.push(k);
+        self.vals.push(v);
+        self.times.push(t);
+        self.diffs.push(d);
+    }
+    fn len(&self) -> usize { self.times.len() }
+    /// Emit the buffered records if at `TARGET` (or `force` and non-empty).
+    fn flush(&mut self, force: bool, out: &mut VecDeque<ProxyChunk<T, R>>) {
+        if self.len() >= TARGET || (force && self.len() > 0) {
+            let full = std::mem::replace(self, OutBuf::new());
+            out.push_back(ProxyChunk(Rc::new(Inner {
+                keys: full.keys,
+                vals: full.vals,
+                times: full.times,
+                diffs: full.diffs,
+            })));
+        }
+    }
+}
+
+impl<T, R> Chunk for ProxyChunk<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    type Time = T;
+    const TARGET: usize = TARGET;
+
+    fn len(&self) -> usize { self.0.times.len() }
+
+    /// Two-pointer merge of the two front chunks through their shared horizon,
+    /// consolidating equal `((key, val), time)` triples. Processes only the two front
+    /// chunks per call (the `Chunk` contract permits it — "consume at least one input; the
+    /// harness may re-invoke"); the survivor's suffix is pushed back once.
+    fn merge(in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>) {
+        let c1 = in1.pop_front().unwrap();
+        let c2 = in2.pop_front().unwrap();
+        let (a, b) = (&*c1.0, &*c2.0);
+        let (n1, n2) = (a.times.len(), b.times.len());
+
+        let mut buf = OutBuf::new();
+        let (mut p1, mut p2) = (0usize, 0usize);
+        while p1 < n1 && p2 < n2 {
+            match (a.keys[p1], a.vals[p1], &a.times[p1]).cmp(&(b.keys[p2], b.vals[p2], &b.times[p2])) {
+                std::cmp::Ordering::Less => {
+                    buf.push(a.keys[p1], a.vals[p1], a.times[p1].clone(), a.diffs[p1].clone());
+                    p1 += 1;
+                }
+                std::cmp::Ordering::Greater => {
+                    buf.push(b.keys[p2], b.vals[p2], b.times[p2].clone(), b.diffs[p2].clone());
+                    p2 += 1;
+                }
+                std::cmp::Ordering::Equal => {
+                    let mut d = a.diffs[p1].clone();
+                    d.plus_equals(&b.diffs[p2]);
+                    if !d.is_zero() {
+                        buf.push(a.keys[p1], a.vals[p1], a.times[p1].clone(), d);
+                    }
+                    p1 += 1;
+                    p2 += 1;
+                }
+            }
+            buf.flush(false, out);
+        }
+        buf.flush(true, out);
+
+        // Push back the survivor's unconsumed suffix (all `>` the horizon).
+        if p1 < n1 { in1.push_front(c1.gather(p1..n1)); }
+        if p2 < n2 { in2.push_front(c2.gather(p2..n2)); }
+    }
+
+    fn extract(
+        input: &mut VecDeque<Self>,
+        frontier: AntichainRef<T>,
+        residual: &mut Antichain<T>,
+        keep: &mut VecDeque<Self>,
+        ship: &mut VecDeque<Self>,
+    ) {
+        // One input chunk per call: partition into keep (`>= frontier`) and ship pieces.
+        let Some(chunk) = input.pop_front() else { return };
+        let times = chunk.times();
+        let (mut ki, mut si) = (Vec::new(), Vec::new());
+        for (i, t) in times.iter().enumerate() {
+            if frontier.less_equal(t) {
+                residual.insert_ref(t);
+                ki.push(i);
+            } else {
+                si.push(i);
+            }
+        }
+        if !ki.is_empty() { keep.push_back(chunk.gather(ki.iter().copied())); }
+        if !si.is_empty() { ship.push_back(chunk.gather(si.iter().copied())); }
+    }
+
+    fn advance(
+        input: &mut VecDeque<Self>,
+        frontier: AntichainRef<T>,
+        done: bool,
+        out: &mut VecDeque<Self>,
+    ) {
+        // Concatenate the pushed-back carry with the newly-arrived chunks, then advance
+        // and consolidate each *complete* `(key, val)` group; withhold the trailing group
+        // as the carry unless `done`.
+        if input.is_empty() { return; }
+        let (mut keys, mut vals) = (Vec::new(), Vec::new());
+        let (mut times, mut diffs) = (Vec::new(), Vec::new());
+        for chunk in input.drain(..) {
+            let (mut k, mut v, mut t, mut d) = chunk.into_parts();
+            keys.append(&mut k);
+            vals.append(&mut v);
+            times.append(&mut t);
+            diffs.append(&mut d);
+        }
+        let n = times.len();
+        if n == 0 { return; }
+
+        // Giant-key case: the whole buffer is one `(key, val)` — no group provably complete.
+        if !done && (keys[0], vals[0]) == (keys[n - 1], vals[n - 1]) {
+            input.push_front(ProxyChunk(Rc::new(Inner { keys, vals, times, diffs })));
+            return;
+        }
+
+        // Withhold the trailing group as the carry unless `done`.
+        let end = if done {
+            n
+        } else {
+            let last = (keys[n - 1], vals[n - 1]);
+            let mut start = n;
+            while start > 0 && (keys[start - 1], vals[start - 1]) == last { start -= 1; }
+            start
+        };
+        if end < n {
+            input.push_front(ProxyChunk(Rc::new(Inner {
+                keys: keys[end..].to_vec(),
+                vals: vals[end..].to_vec(),
+                times: times[end..].to_vec(),
+                diffs: diffs[end..].to_vec(),
+            })));
+        }
+
+        // Advance + consolidate each complete group; emit `TARGET`-sized chunks.
+        let mut buf = OutBuf::new();
+        let mut i = 0;
+        while i < end {
+            let mut j = i;
+            while j < end && (keys[j], vals[j]) == (keys[i], vals[i]) { j += 1; }
+            let mut pairs: Vec<(T, R)> = (i..j)
+                .map(|k| {
+                    let mut t = times[k].clone();
+                    t.advance_by(frontier);
+                    (t, diffs[k].clone())
+                })
+                .collect();
+            // Advancing is lattice-monotone but not total-order-monotone; re-sort by time.
+            pairs.sort_by(|x, y| x.0.cmp(&y.0));
+            let mut k = 0;
+            while k < pairs.len() {
+                let t = pairs[k].0.clone();
+                let mut d = pairs[k].1.clone();
+                k += 1;
+                while k < pairs.len() && pairs[k].0 == t {
+                    d.plus_equals(&pairs[k].1);
+                    k += 1;
+                }
+                if !d.is_zero() {
+                    buf.push(keys[i], vals[i], t, d);
+                    buf.flush(false, out);
+                }
+            }
+            i = j;
+        }
+        buf.flush(true, out);
+    }
+
+    /// Maximal packing via the harness [`pack`]: coalesce by extending the columns in
+    /// place, split by copying the ranges, seal as a no-op.
+    fn settle(input: &mut VecDeque<Self>, done: bool, out: &mut VecDeque<Self>) {
+        pack(
+            input,
+            done,
+            out,
+            |acc, next| {
+                let (mut k, mut v, mut t, mut d) = std::mem::take(acc).into_parts();
+                let (mut k2, mut v2, mut t2, mut d2) = next.into_parts();
+                k.append(&mut k2);
+                v.append(&mut v2);
+                t.append(&mut t2);
+                d.append(&mut d2);
+                *acc = ProxyChunk(Rc::new(Inner { keys: k, vals: v, times: t, diffs: d }));
+            },
+            |chunk, m| {
+                let n = chunk.len();
+                let l = chunk.gather(0..m);
+                let r = chunk.gather(m..n);
+                (l, r)
+            },
+            |chunk| chunk,
+        );
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::{BTreeMap, VecDeque};
+    use super::{Chunk, ProxyChunk};
+    use crate::trace::chunk::{is_graded, ChunkBatch, ChunkBatchMerger};
+    use crate::trace::{Description, Merger};
+    use timely::progress::Antichain;
+
+    fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+    /// Build a single sorted+consolidated chunk from `((key, val), time, diff)` rows.
+    fn chunk(rows: &[((u64, u64), u64, i64)]) -> ProxyChunk<u64, i64> {
+        let mut m: BTreeMap<((u64, u64), u64), i64> = BTreeMap::new();
+        for &(kv, t, d) in rows { *m.entry((kv, t)).or_insert(0) += d; }
+        m.retain(|_, d| *d != 0);
+        ProxyChunk::from_sorted(
+            m.keys().map(|((k, _), _)| *k).collect(),
+            m.keys().map(|((_, v), _)| *v).collect(),
+            m.keys().map(|(_, t)| *t).collect(),
+            m.values().copied().collect(),
+        )
+    }
+
+    fn read_batch(b: &ChunkBatch<ProxyChunk<u64, i64>>) -> BTreeMap<((u64, u64), u64), i64> {
+        let mut m = BTreeMap::new();
+        for ch in &b.chunks {
+            for i in 0..ProxyChunk::len(ch) {
+                *m.entry(((ch.key_hashes()[i], ch.value_ids()[i]), ch.times()[i])).or_insert(0) += ch.diffs()[i];
+            }
+        }
+        m.retain(|_, d| *d != 0);
+        m
+    }
+
+    fn reference(u1: &[((u64, u64), u64, i64)], u2: &[((u64, u64), u64, i64)], f: u64) -> BTreeMap<((u64, u64), u64), i64> {
+        let mut m = BTreeMap::new();
+        // `advance_by` on totally-ordered `u64` is `max`.
+        for u in u1.iter().chain(u2) { *m.entry((u.0, u.1.max(f))).or_insert(0) += u.2; }
+        m.retain(|_, d| *d != 0);
+        m
+    }
+
+    /// Cut a consolidated set into a batch of small chunks (globally sorted; groups straddle).
+    fn batch(rows: &[((u64, u64), u64, i64)], sz: usize) -> ChunkBatch<ProxyChunk<u64, i64>> {
+        let mut m: BTreeMap<((u64, u64), u64), i64> = BTreeMap::new();
+        for &(kv, t, d) in rows { *m.entry((kv, t)).or_insert(0) += d; }
+        m.retain(|_, d| *d != 0);
+        let all: Vec<((u64, u64), u64, i64)> = m.into_iter().map(|((kv, t), d)| (kv, t, d)).collect();
+        let chunks: Vec<_> = all.chunks(sz.max(1)).map(chunk).collect();
+        let desc = Description::new(Antichain::from_elem(0u64), Antichain::from_elem(10u64), Antichain::from_elem(0u64));
+        ChunkBatch::new(chunks, desc)
+    }
+
+    // The resumable merge→advance→settle pipeline, driven with tiny fuel so it suspends
+    // and settles on nearly every tick, must match a one-shot reference and stay graded.
+    #[test]
+    fn batch_merger_resumable_matches_reference() {
+        let mut seed = 0x9E3779B97F4A7C15u64;
+        for _ in 0..200 {
+            let gen = |seed: &mut u64| -> Vec<((u64, u64), u64, i64)> {
+                let n = (xorshift(seed) % 40) as usize + 1;
+                (0..n).map(|_| {
+                    let k = xorshift(seed) % 10;
+                    let v = xorshift(seed) % 3;
+                    let t = xorshift(seed) % 6;
+                    let d = if xorshift(seed) % 4 == 0 { -1 } else { 1 };
+                    ((k, v), t, d)
+                }).collect()
+            };
+            let u1 = gen(&mut seed);
+            let u2 = gen(&mut seed);
+            let sz = (xorshift(&mut seed) % 4) as usize + 1;
+            let f = xorshift(&mut seed) % 6;
+            let (s1, s2) = (batch(&u1, sz), batch(&u2, sz));
+            let frontier = Antichain::from_elem(f);
+
+            let mut merger = ChunkBatchMerger::new(&s1, &s2, frontier.borrow());
+            loop {
+                let mut fuel = 1isize; // tiny → many yields, each settling
+                merger.work(&s1, &s2, &mut fuel);
+                if fuel > 0 { break; }
+            }
+            let result = merger.done();
+            assert!(is_graded(&result.chunks), "ungraded: {:?}", result.chunks.iter().map(Chunk::len).collect::<Vec<_>>());
+            assert_eq!(read_batch(&result), reference(&u1, &u2, f), "u1={u1:?}\nu2={u2:?}\nf={f}");
+        }
+    }
+
+    // `from_unsorted` must sort by `(key, val, time)`, sum diffs of equal triples, drop
+    // zeros, and report a representative original index per retained record.
+    #[test]
+    fn from_unsorted_consolidates_with_provenance() {
+        let keys = vec![2, 1, 2, 1, 1];
+        let vals = vec![7, 5, 7, 5, 6];
+        let times = vec![0u64, 3, 0, 3, 1];
+        let diffs = vec![1i64, 1, 1, -1, 1];
+        let (chunk, reps) = ProxyChunk::from_unsorted(keys, vals, times, diffs);
+        // (1,5)@3 nets to zero and is dropped; (2,7)@0 consolidates to 2.
+        assert_eq!(chunk.key_hashes(), &[1, 2]);
+        assert_eq!(chunk.value_ids(), &[6, 7]);
+        assert_eq!(chunk.times(), &[1, 0]);
+        assert_eq!(chunk.diffs(), &[1, 2]);
+        // Representatives point at original records carrying those (key, val) pairs.
+        assert_eq!(reps.len(), 2);
+        assert_eq!(reps[0], 4); // the only (1,6) record
+        assert!(reps[1] == 0 || reps[1] == 2); // either (2,7) record serves
+    }
+
+    // Settling a run of undersized chunks yields a maximal packing with contents preserved.
+    #[test]
+    fn settle_grades_and_preserves() {
+        let n = 3 * super::TARGET as u64;
+        let mut input: VecDeque<_> = (0..n).map(|i| chunk(&[((i, 0), 0, 1)])).collect();
+        let mut out = VecDeque::new();
+        ProxyChunk::settle(&mut input, true, &mut out);
+        let chunks: Vec<_> = out.into();
+        assert!(is_graded(&chunks));
+        let total: usize = chunks.iter().map(Chunk::len).sum();
+        assert_eq!(total, n as usize);
+        let keys: Vec<u64> = chunks.iter().flat_map(|c| c.key_hashes().iter().copied()).collect();
+        assert!(keys.windows(2).all(|w| w[0] < w[1]));
+    }
+}
diff --git a/differential-dataflow/src/trace/chunk/mod.rs b/differential-dataflow/src/trace/chunk/mod.rs
index 93a4d28aa..04a6c0d0f 100644
--- a/differential-dataflow/src/trace/chunk/mod.rs
+++ b/differential-dataflow/src/trace/chunk/mod.rs
@@ -61,6 +61,7 @@ use crate::trace::{Batch, BatchReader, Description, Navigable};
 use crate::trace::cursor::Cursor;
 use crate::trace::implementations::BatchContainer;
 
+pub mod int_proxy;
 pub mod vec;
 
 /// A non-empty, bounded, consolidated, sorted sequence of `(data, time, diff)`.
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
new file mode 100644
index 000000000..025dfefee
--- /dev/null
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -0,0 +1,341 @@
+//! The integer-proxy chunk framework against the row-based operators.
+//!
+//! An equi-join and reductions (count, distinct) run twice over identical multi-round
+//! inputs with retractions: once through the proxy-space tactics over the in-memory
+//! reference backend (`operators::int_proxy`), once through the stock row-based operators.
+//! The update streams must agree exactly. A scripted `retire` sequence over
+//! partially-ordered `Product` times exercises the synthetic-time and pending machinery
+//! that totally-ordered dataflow rounds cannot reach.
+
+use std::collections::BTreeMap;
+use std::sync::mpsc::channel;
+
+use timely::container::CapacityContainerBuilder;
+use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::capture::Event;
+use timely::dataflow::operators::Capture;
+use timely::order::Product;
+use timely::progress::Antichain;
+
+use differential_dataflow::consolidation::consolidate_updates;
+use differential_dataflow::input::Input;
+use differential_dataflow::operators::arrange::arrangement::arrange_core;
+use differential_dataflow::operators::int_proxy::reference::{RefBatch, VecJoinBackend, VecReduceBackend};
+use differential_dataflow::operators::int_proxy::{ProxyJoinTactic, ProxyReduceTactic};
+use differential_dataflow::operators::join::join_with_tactic;
+use differential_dataflow::operators::reduce::{reduce_with_tactic, ReduceTactic};
+use differential_dataflow::trace::chunk::vec::{ChunkBatcher, ChunkBuilder, ChunkSpine, VecChunk};
+use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+use differential_dataflow::trace::cursor::Cursor;
+use differential_dataflow::trace::{Builder, Description, Navigable};
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+/// Rounds of `((key, val), diff)` updates: fresh insertions plus retractions of
+/// previously inserted records, so histories cancel and consolidate.
+fn gen_rounds(seed: u64, rounds: usize, per_round: usize) -> Vec<Vec<((u64, u64), isize)>> {
+    let mut s = seed;
+    let mut live: Vec<(u64, u64)> = Vec::new();
+    (0..rounds)
+        .map(|_| {
+            let mut round = Vec::new();
+            for _ in 0..per_round {
+                if !live.is_empty() && xorshift(&mut s) % 4 == 0 {
+                    let idx = (xorshift(&mut s) as usize) % live.len();
+                    round.push((live.swap_remove(idx), -1));
+                } else {
+                    let rec = (xorshift(&mut s) % 8, xorshift(&mut s) % 4);
+                    live.push(rec);
+                    round.push((rec, 1));
+                }
+            }
+            round
+        })
+        .collect()
+}
+
+/// Flatten captured events into a consolidated `(data, time) → diff` map.
+fn consolidated<D: Ord>(events: Vec<Event<u64, Vec<(D, u64, isize)>>>) -> BTreeMap<(D, u64), isize> {
+    let mut acc = BTreeMap::new();
+    for event in events {
+        if let Event::Messages(_, data) = event {
+            for (d, t, r) in data {
+                *acc.entry((d, t)).or_insert(0) += r;
+            }
+        }
+    }
+    acc.retain(|_, r| *r != 0);
+    acc
+}
+
+type Chunker<K, V> = ContainerChunker<VecChunk<K, V, u64, isize>>;
+type Batcher<K, V> = ChunkBatcher<K, V, u64, isize>;
+type Bldr<K, V> = ChunkBuilder<K, V, u64, isize>;
+type Spine<K, V> = ChunkSpine<K, V, u64, isize>;
+
+type JoinOut = (u64, (u64, u64));
+
+#[test]
+fn proxy_join_matches_row_join() {
+    let rounds0 = gen_rounds(0x853C49E6748FEA9B, 5, 12);
+    let rounds1 = gen_rounds(0xDA3E39CB94B95BDB, 5, 12);
+
+    // Id path: arranged chunk spines, joined by the id tactic over the reference backend.
+    let (tx, rx) = channel();
+    {
+        let (rounds0, rounds1) = (rounds0.clone(), rounds1.clone());
+        timely::execute_directly(move |worker| {
+            let (mut in0, mut in1) = worker.dataflow::<u64, _, _>(|scope| {
+                let (in0, c0) = scope.new_collection::<(u64, u64), isize>();
+                let (in1, c1) = scope.new_collection::<(u64, u64), isize>();
+                let a0 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c0.inner, Pipeline, "Arrange0");
+                let a1 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c1.inner, Pipeline, "Arrange1");
+                let tactic = ProxyJoinTactic::new(VecJoinBackend::new(|k: &u64, v0: &u64, v1: &u64| (*k, (*v0, *v1))));
+                let joined = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<(JoinOut, u64, isize)>>>(a0, a1, tactic);
+                joined.capture_into(tx);
+                (in0, in1)
+            });
+            for (t, (r0, r1)) in rounds0.iter().zip(rounds1.iter()).enumerate() {
+                for (rec, diff) in r0 { in0.update(*rec, *diff); }
+                for (rec, diff) in r1 { in1.update(*rec, *diff); }
+                in0.advance_to(t as u64 + 1);
+                in1.advance_to(t as u64 + 1);
+                in0.flush();
+                in1.flush();
+                worker.step();
+            }
+        });
+    }
+    let got = consolidated(rx.into_iter().collect());
+
+    // Row path: the stock join over the same inputs.
+    let (tx, rx) = channel();
+    {
+        timely::execute_directly(move |worker| {
+            let (mut in0, mut in1) = worker.dataflow::<u64, _, _>(|scope| {
+                let (in0, c0) = scope.new_collection::<(u64, u64), isize>();
+                let (in1, c1) = scope.new_collection::<(u64, u64), isize>();
+                c0.join(c1).inner.capture_into(tx);
+                (in0, in1)
+            });
+            for (t, (r0, r1)) in rounds0.iter().zip(rounds1.iter()).enumerate() {
+                for (rec, diff) in r0 { in0.update(*rec, *diff); }
+                for (rec, diff) in r1 { in1.update(*rec, *diff); }
+                in0.advance_to(t as u64 + 1);
+                in1.advance_to(t as u64 + 1);
+                in0.flush();
+                in1.flush();
+                worker.step();
+            }
+        });
+    }
+    let want = consolidated(rx.into_iter().collect());
+
+    assert!(!want.is_empty(), "trivial test: row join produced nothing");
+    assert_eq!(got, want);
+}
+
+/// Drive the same rounds through the proxy-space reduce and the row reduce with the same
+/// user logic, and compare the output update streams.
+fn check_reduce<V2, L>(logic: L)
+where
+    V2: differential_dataflow::Data + std::hash::Hash + Send + Sync,
+    L: FnMut(&u64, &[(&u64, isize)], &mut Vec<(V2, isize)>) + Clone + Send + Sync + 'static,
+{
+    let rounds = gen_rounds(0xC0FFEE0DDBA11, 6, 10);
+
+    // Id path.
+    let (tx, rx) = channel();
+    {
+        let rounds = rounds.clone();
+        let logic = logic.clone();
+        timely::execute_directly(move |worker| {
+            let mut input = worker.dataflow::<u64, _, _>(|scope| {
+                let (input, c) = scope.new_collection::<(u64, u64), isize>();
+                let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
+                let tactic = ProxyReduceTactic::new(VecReduceBackend::new(logic));
+                let reduced = reduce_with_tactic::<_, Spine<u64, V2>, _>(arranged, "IdReduce", tactic);
+                reduced.as_collection(|k, v| (*k, v.clone())).inner.capture_into(tx);
+                input
+            });
+            for (t, round) in rounds.iter().enumerate() {
+                for (rec, diff) in round { input.update(*rec, *diff); }
+                input.advance_to(t as u64 + 1);
+                input.flush();
+                worker.step();
+            }
+        });
+    }
+    let got = consolidated(rx.into_iter().collect());
+
+    // Row path.
+    let (tx, rx) = channel();
+    {
+        let rounds = rounds.clone();
+        let logic = logic.clone();
+        timely::execute_directly(move |worker| {
+            let mut input = worker.dataflow::<u64, _, _>(|scope| {
+                let (input, c) = scope.new_collection::<(u64, u64), isize>();
+                let mut logic = logic.clone();
+                c.reduce(move |k, input, output| logic(k, input, output)).inner.capture_into(tx);
+                input
+            });
+            for (t, round) in rounds.iter().enumerate() {
+                for (rec, diff) in round { input.update(*rec, *diff); }
+                input.advance_to(t as u64 + 1);
+                input.flush();
+                worker.step();
+            }
+        });
+    }
+    let want = consolidated(rx.into_iter().collect());
+
+    assert!(!want.is_empty(), "trivial test: row reduce produced nothing");
+    assert_eq!(got, want);
+}
+
+#[test]
+fn proxy_reduce_count_matches_row_reduce() {
+    check_reduce::<isize, _>(|_k, input, output| {
+        let count: isize = input.iter().map(|(_, d)| *d).sum();
+        if count > 0 {
+            output.push((count, 1));
+        }
+    });
+}
+
+#[test]
+fn proxy_reduce_distinct_matches_row_reduce() {
+    check_reduce::<(), _>(|_k, input, output| {
+        if input.iter().any(|(_, d)| *d > 0) {
+            output.push(((), 1));
+        }
+    });
+}
+
+#[test]
+fn proxy_reduce_min_matches_row_reduce() {
+    // Order-sensitive reduction: `value_id`s are hash-ordered, so min MUST come from the
+    // value callback (the design's ordering decision); this pins that path.
+    check_reduce::<u64, _>(|_k, input, output| {
+        if let Some(m) = input.iter().filter(|(_, d)| *d > 0).map(|(v, _)| **v).min() {
+            output.push((m, 1));
+        }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Partially ordered times: a scripted retire sequence over `Product<u64, u64>`.
+// ---------------------------------------------------------------------------
+
+type PT = Product<u64, u64>;
+type PBatch<V> = RefBatch<u64, V, PT, isize>;
+
+fn pt(a: u64, b: u64) -> PT {
+    Product::new(a, b)
+}
+
+/// Build a reference-backend batch from rows (sorted+consolidated internally).
+fn pbatch<V: Ord + Clone + 'static>(mut rows: Vec<((u64, V), PT, isize)>, lower: Vec<PT>, upper: Vec<PT>) -> PBatch<V> {
+    use timely::container::PushInto;
+    consolidate_updates(&mut rows);
+    let mut chunk = VecChunk::default();
+    for row in rows {
+        chunk.push_into(row);
+    }
+    let description = Description::new(
+        Antichain::from_iter(lower),
+        Antichain::from_iter(upper),
+        Antichain::from_elem(pt(0, 0)),
+    );
+    let mut builder = ChunkBuilder::<u64, V, PT, isize>::with_capacity(0, 0, 0);
+    builder.push(&mut chunk);
+    builder.done(description)
+}
+
+fn pbatch_rows<V: Ord + Clone + 'static>(batch: &PBatch<V>) -> Vec<((u64, V), PT, isize)> {
+    let mut rows = Vec::new();
+    let mut cursor = batch.cursor();
+    while let Some(k) = cursor.get_key(batch) {
+        while let Some(v) = cursor.get_val(batch) {
+            cursor.map_times(batch, |t, d| rows.push(((*k, v.clone()), t.clone(), *d)));
+            cursor.step_val(batch);
+        }
+        cursor.step_key(batch);
+    }
+    consolidate_updates(&mut rows);
+    rows
+}
+
+/// Updates at `(0, 1)` and `(1, 0)` must produce a correction at their join `(1, 1)` —
+/// synthesized by the tactic in one interval when `(1, 1)` lies inside it, and *pended*
+/// across retires when it does not. Three scripted retires walk a count reduction
+/// through arrival at `(0, 1)`, arrival at `(1, 0)` with `(1, 1)` beyond the interval
+/// (so it pends), and the pending-driven correction with no new input at all.
+#[test]
+fn proxy_reduce_synthesizes_and_pends_product_times() {
+    let count = |_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
+        let count: isize = input.iter().map(|(_, d)| *d).sum();
+        if count > 0 {
+            output.push((count, 1));
+        }
+    };
+    let mut tactic = ProxyReduceTactic::new(VecReduceBackend::new(count));
+
+    // Retire 1: value 10 arrives at (0, 1); interval [(0,0), {(0,2),(1,0)}).
+    let batch1 = pbatch(vec![((1u64, 10u64), pt(0, 1), 1)], vec![pt(0, 0)], vec![pt(0, 2), pt(1, 0)]);
+    let lower1 = Antichain::from_elem(pt(0, 0));
+    let upper1 = Antichain::from_iter([pt(0, 2), pt(1, 0)]);
+    let held1 = Antichain::from_elem(pt(0, 0));
+    let (produced1, frontier1) = tactic.retire(vec![], vec![], vec![batch1.clone()], &lower1, &upper1, &held1);
+    assert_eq!(produced1.len(), 1);
+    assert_eq!(produced1[0].0, pt(0, 0));
+    assert_eq!(pbatch_rows(&produced1[0].1), vec![((1, 1isize), pt(0, 1), 1)]);
+    assert!(frontier1.is_empty()); // nothing pended
+
+    // Retire 2: value 20 arrives at (1, 0); interval [{(0,2),(1,0)}, {(1,1)}). The
+    // synthetic join (0,1) ∨ (1,0) = (1,1) is at the upper bound, so it must PEND.
+    let batch2 = pbatch(vec![((1u64, 20u64), pt(1, 0), 1)], vec![pt(0, 2), pt(1, 0)], vec![pt(1, 1)]);
+    let lower2 = upper1.clone();
+    let upper2 = Antichain::from_elem(pt(1, 1));
+    let held2 = Antichain::from_elem(pt(1, 0));
+    let (produced2, frontier2) = tactic.retire(
+        vec![batch1.clone()],
+        vec![produced1[0].1.clone()],
+        vec![batch2.clone()],
+        &lower2,
+        &upper2,
+        &held2,
+    );
+    assert_eq!(produced2.len(), 1);
+    assert_eq!(produced2[0].0, pt(1, 0));
+    // At (1, 0) only value 20 is visible ((0,1) is incomparable): count 1.
+    assert_eq!(pbatch_rows(&produced2[0].1), vec![((1, 1isize), pt(1, 0), 1)]);
+    assert_eq!(frontier2, Antichain::from_elem(pt(1, 1))); // (1,1) pended
+
+    // Retire 3: no new input; the pended (1,1) drives the correction. Both values are
+    // now visible (count 2), while the accumulated output claims two counts of 1.
+    let lower3 = upper2.clone();
+    let upper3 = Antichain::new(); // the closed interval: nothing lies beyond
+    let held3 = Antichain::from_elem(pt(1, 1));
+    let (produced3, frontier3) = tactic.retire(
+        vec![batch1, batch2],
+        vec![produced1[0].1.clone(), produced2[0].1.clone()],
+        vec![],
+        &lower3,
+        &upper3,
+        &held3,
+    );
+    assert_eq!(produced3.len(), 1);
+    assert_eq!(produced3[0].0, pt(1, 1));
+    assert_eq!(
+        pbatch_rows(&produced3[0].1),
+        vec![((1, 1isize), pt(1, 1), -2), ((1, 2isize), pt(1, 1), 1)]
+    );
+    assert!(frontier3.is_empty());
+}

From b7f1afef7a1553a67817abb9f1ae37b2f09cd7ba Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 04:20:56 -0400
Subject: [PATCH 02/68] =?UTF-8?q?int=5Fproxy:=20state=20the=20minimal=20va?=
 =?UTF-8?q?lue=5Fid=20contract=20=E2=80=94=20hashing=20is=20one=20scheme,?=
 =?UTF-8?q?=20not=20a=20requirement?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

value_id never outlives one computation (a join unit's presentations;
one reduce retire, whose materialize resolves ids to real data before
anything leaves). The actual contract is a per-computation bijection
with value equality, plus within-retire agreement between the output
presentation and minted ids. Content hashing discharges all of it
statelessly (the reference backend's choice); exact schemes — dense
ordinals from grouping, a per-retire value→id map — are equally valid
and collision-free. Only key_hash must be a stable pure function of the
key (cross-retire pending, changed-key filter), making the key side the
irreducible collision exposure. Persisting ids into an output
arrangement itself would force stable value ids; this design does not.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/mod.rs            | 38 ++++++++++++-------
 .../src/operators/int_proxy/reduce.rs         | 10 +++--
 .../src/trace/chunk/int_proxy.rs              |  5 ++-
 3 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/mod.rs b/differential-dataflow/src/operators/int_proxy/mod.rs
index e102d456d..7835b37c0 100644
--- a/differential-dataflow/src/operators/int_proxy/mod.rs
+++ b/differential-dataflow/src/operators/int_proxy/mod.rs
@@ -37,11 +37,18 @@
 //!   output→input boundary. The hash function is a property of the *backend* (all of its
 //!   operators must share it); DD never hashes anything.
 //! * `value_id: u64` — an intra-key value identifier, consistent within one operator
-//!   computation: equal ids ⇒ equal values there, which is what consolidation and
-//!   presence need. On the write side ids must be content hashes (see above); on the
-//!   read side a backend may use any per-computation-consistent scheme, and `id =
-//!   hash(value)` is the natural choice since it makes the read and write id spaces
-//!   coincide (min "reusing an input value's id" is then automatic).
+//!   computation: equal values ⇔ equal ids there (both directions — a value-id collision
+//!   merges two values' diffs, a correctness bug of the same character as a key
+//!   collision). No id outlives a computation: a join work unit's presentations, or one
+//!   reduce retire — within which the output presentation and minted ids must agree on
+//!   equal values (see [`ProxyReduceBackend`]); `materialize` resolves ids to real data
+//!   before anything leaves the retire. Content hashing (`id = hash(value)`) is the
+//!   stateless scheme that discharges all of this at once — the reference backend's
+//!   choice, and it makes min "reusing an input value's id" automatic — but *exact*
+//!   schemes are equally valid and collision-free: dense ordinals from grouping the
+//!   presented values, plus a per-retire value→id map on the output side. Only a future
+//!   design that persists ids into an output arrangement itself would force stable
+//!   (hashed) value ids.
 //!
 //! # Design note: `value_id` is *not* order-preserving
 //!
@@ -69,14 +76,19 @@
 //!
 //! # Collision risk
 //!
-//! Ids are 64-bit content hashes. Colliding *keys* merge two groups (a join would
-//! cross-match them; a reduce would reduce their union); colliding output *values* would
-//! alias two outputs. By the birthday bound the probability of any collision among `n`
-//! distinct keys (or values) is ≈ `n²/2⁶⁵`: about `5·10⁻⁸` at a million, `5·10⁻²` at a
-//! billion. This is the accepted risk of the design — it buys global id stability with no
-//! registry and no coordination. If a deployment's key cardinality makes the bound
-//! uncomfortable, the upgrade path is widening the id to 128 bits (a second id column),
-//! not a registry.
+//! Key ids are 64-bit content hashes, and colliding *keys* merge two groups (a join
+//! would cross-match them; a reduce would reduce their union). By the birthday bound the
+//! probability of any collision among `n` distinct keys is ≈ `n²/2⁶⁵`: about `5·10⁻⁸` at
+//! a million, `5·10⁻²` at a billion. This is the accepted risk of the design — it buys
+//! key-id stability across the operator's lifetime with no registry and no coordination,
+//! which the cross-retire `pending` set and the changed-key restriction rely on. If a
+//! deployment's key cardinality makes the bound uncomfortable, the upgrade path is
+//! widening the id to 128 bits (a second id column), not a registry.
+//!
+//! Value ids carry the same exposure only if the backend hashes them (as the reference
+//! backend does). Because they are scoped to one computation, a backend can instead
+//! assign them exactly (see above) and eliminate value-side collisions outright; the key
+//! side is the irreducible exposure.
 //!
 //! # What DD owns vs what the backend owns
 //!
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index cad65aadf..1b7c4ee0b 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -34,14 +34,18 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// what keeps small-delta recursion from re-reading the accumulated trace each round.
     fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, Self::RIn>;
     /// (read) As `present_input`, for the operator's own output trace. The `value_id`s
-    /// here are the stable output-value hashes and must agree with ids minted by
-    /// [`reduce`](Self::reduce) — which they do for free when both hash the value.
+    /// here must agree, on equal output values, with the ids [`reduce`](Self::reduce)
+    /// mints later in this retire — desired and current output cancel by id. Content
+    /// hashing achieves this statelessly; an exact per-retire value→id map achieves it
+    /// with no collision risk.
     fn present_output(&mut self, batches: &[B2], keys: &[u64]) -> ProxyChunk<B1::Time, Self::ROut>;
     /// (value callback) Apply the reduction to one key's accumulated input: `input` holds
     /// one entry per value with a nonzero accumulation — a representative record index
     /// into the current input presentation, and the accumulated diff. Never called with
     /// `input` empty. Returns the reduced output as `(value_id, diff)`, minting ids for
-    /// produced values (`id = hash(value)`) and recording `id → value` for `materialize`.
+    /// produced values — by any scheme that agrees with
+    /// [`present_output`](Self::present_output) on equal values within this retire — and
+    /// recording `id → value` for `materialize`.
     fn reduce(&mut self, key_hash: u64, input: &[(usize, Self::RIn)]) -> Vec<(u64, Self::ROut)>;
     /// (egress) Seal proxy-space output records into a real output batch: resolve each
     /// record's `key_hash` and `value_id` to real data, order by the backend's own record
diff --git a/differential-dataflow/src/trace/chunk/int_proxy.rs b/differential-dataflow/src/trace/chunk/int_proxy.rs
index 5d2595091..2d4aa178d 100644
--- a/differential-dataflow/src/trace/chunk/int_proxy.rs
+++ b/differential-dataflow/src/trace/chunk/int_proxy.rs
@@ -11,8 +11,9 @@
 //!   note in [`operators::int_proxy`](crate::operators::int_proxy)).
 //! * `value_id: u64` — an intra-key identifier for a value, **ephemeral**: consistent only
 //!   within a single operator computation (one presentation, one retire's waves). Equal
-//!   ids ⇒ equal values there, which is all DD needs to consolidate diffs per value and
-//!   decide presence. It is *not* order-preserving with respect to the value type's
+//!   values ⇔ equal ids there — a bijection per computation, which is all DD needs to
+//!   consolidate diffs per value and decide presence; a hash is one scheme, not a
+//!   requirement. It is *not* order-preserving with respect to the value type's
 //!   semantic order — see the design note in [`operators::int_proxy`](crate::operators::int_proxy).
 //!
 //! Chunks sort by `(key_hash, value_id, time)` — an arbitrary but consistent total order

From 1cada6151732780007bd5f491a1ebb3a0d9b179a Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 04:33:08 -0400
Subject: [PATCH 03/68] =?UTF-8?q?int=5Fproxy:=20delta-proportional=20prese?=
 =?UTF-8?q?nts,=20checked=20=E2=80=94=20not=20asymptotically=20worse=20tha?=
 =?UTF-8?q?n=20the=20cursor=20tactics?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two regressions found by asking exactly that question, both fixed:

- The reference reduce backend implemented the changed-key restriction
  by scanning every batch and filtering — O(trace) per retire where the
  cursor tactic seeks, O(delta·log). Presents now seek the changed keys
  (novel keys resolve from this retire's delta-sized input batches;
  pending keys from the retire that pended them, which is exactly what
  the persistent hash→key map retains — pruned to the changed set each
  retire, so it is bounded by the delta, and the per-retire value map
  is cleared).

- The join interface had no restriction at all, forcing ANY backend to
  present the entire accumulated side per fresh batch — O(trace·log)
  per unit where the cursor join seeks. present0/present1 now take an
  optional sorted key-hash filter; the tactic presents the fresh side
  first and passes its key set for the accumulated side, the join
  analogue of reduce's changed-key restriction.

The check is mechanical, not wall-clock: counting backend wrappers
measure presented records — with 20k arranged keys and five single-key
rounds, reduce presents 37 records and join 10, where the scanning
versions present Ω(rounds·N) (join: 100,005) and fail the gate. What
remains above the cursor tactics is a log-factor sort of delta-sized
presentations, and per-(key, wave) rescans of a changed key's
presented range where the row replayer consolidates progressively —
same worst-case order, different constants.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/join.rs           |  47 +++-
 .../src/operators/int_proxy/reference.rs      | 200 +++++++++++------
 differential-dataflow/tests/int_proxy.rs      | 207 ++++++++++++++++++
 3 files changed, 383 insertions(+), 71 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/join.rs b/differential-dataflow/src/operators/int_proxy/join.rs
index 386eadc1a..18e31ff9d 100644
--- a/differential-dataflow/src/operators/int_proxy/join.rs
+++ b/differential-dataflow/src/operators/int_proxy/join.rs
@@ -28,10 +28,16 @@ pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     /// The output container built from matched index lists.
     type Output;
 
-    /// (read) Flatten `batches` into one sorted, consolidated proxy run.
-    fn present0(&mut self, batches: &[B0]) -> ProxyChunk<B0::Time, Self::R0>;
+    /// (read) Flatten `batches` into one sorted, consolidated proxy run. When `filter` is
+    /// set (sorted key hashes), restrict to records of those keys: the tactic presents a
+    /// unit's fresh side unfiltered and passes its key set when presenting the
+    /// accumulated side, so per-unit work tracks the fresh batch, not the accumulated
+    /// trace — the join analogue of reduce's changed-key restriction, and just as
+    /// load-bearing (without it, a small update against a large trace re-reads the
+    /// trace).
+    fn present0(&mut self, batches: &[B0], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, Self::R0>;
     /// (read) As `present0`, for the second input.
-    fn present1(&mut self, batches: &[B1]) -> ProxyChunk<B0::Time, Self::R1>;
+    fn present1(&mut self, batches: &[B1], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, Self::R1>;
     /// (value work) The projection. `left[i]`/`right[i]` index the current presentations;
     /// each pair matched on `key_hash`. `times[i]`/`diffs[i]` are the DD-computed lattice
     /// join of the pair's times and product of its diffs, to carry through per record.
@@ -54,6 +60,9 @@ pub struct ProxyJoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, Bk
 struct JoinUnit<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     left: Vec<B0>,
     right: Vec<B1>,
+    /// Which side carried the fresh batch; the other side is presented restricted to the
+    /// fresh side's keys.
+    fresh: Fresh,
     capability: Capability<B0::Time>,
 }
 
@@ -72,11 +81,11 @@ where
     CB: ContainerBuilder<Container = Bk::Output>,
 {
     fn defer(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, capability: Capability<B0::Time>) {
-        let unit = JoinUnit { left: input0, right: input1, capability };
-        match fresh {
-            Fresh::Input0 => self.todo0.push_back(unit),
-            Fresh::Input1 => self.todo1.push_back(unit),
-        }
+        let queue = match fresh {
+            Fresh::Input0 => &mut self.todo0,
+            Fresh::Input1 => &mut self.todo1,
+        };
+        queue.push_back(JoinUnit { left: input0, right: input1, fresh, capability });
     }
 
     fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>) {
@@ -99,8 +108,26 @@ where
     Bk: ProxyJoinBackend<B0, B1>,
     CB: ContainerBuilder<Container = Bk::Output>,
 {
-    let p0 = backend.present0(&unit.left);
-    let p1 = backend.present1(&unit.right);
+    // Present the fresh side first (delta-sized), then the accumulated side restricted
+    // to the fresh side's keys, so a unit's work tracks the fresh batch.
+    let (p0, p1) = match unit.fresh {
+        Fresh::Input0 => {
+            let p0 = backend.present0(&unit.left, None);
+            if p0.is_empty() { return; }
+            let mut keys = p0.key_hashes().to_vec();
+            keys.dedup();
+            let p1 = backend.present1(&unit.right, Some(&keys));
+            (p0, p1)
+        }
+        Fresh::Input1 => {
+            let p1 = backend.present1(&unit.right, None);
+            if p1.is_empty() { return; }
+            let mut keys = p1.key_hashes().to_vec();
+            keys.dedup();
+            let p0 = backend.present0(&unit.left, Some(&keys));
+            (p0, p1)
+        }
+    };
     if p0.is_empty() || p1.is_empty() { return; }
     let (k0, k1) = (p0.key_hashes(), p1.key_hashes());
 
diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
index 93250c3e4..09de067ae 100644
--- a/differential-dataflow/src/operators/int_proxy/reference.rs
+++ b/differential-dataflow/src/operators/int_proxy/reference.rs
@@ -3,6 +3,12 @@
 //! process-wide-stable content hash — the "system-wide hash function" every backend must
 //! fix for itself).
 //!
+//! The backend honors the tactics' delta-proportionality restrictions: a filtered
+//! present *seeks* the requested keys in the batch lists rather than scanning them, so
+//! per-retire (reduce) and per-unit (join) work tracks the delta, not the accumulated
+//! trace — the same access pattern as the cursor tactics. The `work_is_delta_proportional`
+//! tests pin this.
+//!
 //! [`VecChunk`]: crate::trace::chunk::vec::VecChunk
 //! [`Hashable`]: crate::hashable::Hashable
 
@@ -34,73 +40,104 @@ pub fn stable_hash<D: Hash>(data: &D) -> u64 {
 /// A batch of the reference backend's arrangements.
 pub type RefBatch<K, V, T, R> = Rc<ChunkBatch<VecChunk<K, V, T, R>>>;
 
-/// Read `batches` (restricted to keys whose hash is in the sorted `filter`, if any)
-/// into parallel proxy and real columns, one entry per `(key, val, time, diff)` record.
-fn read_rows<K, V, T, R>(
-    batches: &[RefBatch<K, V, T, R>],
-    filter: Option<&[u64]>,
-    keys: &mut Vec<u64>,
-    vals: &mut Vec<u64>,
-    times: &mut Vec<T>,
-    diffs: &mut Vec<R>,
-    reals: &mut Vec<(K, V)>,
-) where
+/// Parallel proxy and real columns under construction, one entry per record.
+struct Rows<K, V, T, R> {
+    keys: Vec<u64>,
+    vals: Vec<u64>,
+    times: Vec<T>,
+    diffs: Vec<R>,
+    reals: Vec<(K, V)>,
+}
+
+impl<K, V, T, R> Rows<K, V, T, R> {
+    fn new() -> Self {
+        Rows { keys: Vec::new(), vals: Vec::new(), times: Vec::new(), diffs: Vec::new(), reals: Vec::new() }
+    }
+}
+
+impl<K, V, T, R> Rows<K, V, T, R>
+where
     K: Ord + Clone + Hash + 'static,
     V: Ord + Clone + Hash + 'static,
     T: Lattice + Timestamp,
     R: Ord + Semigroup + 'static,
 {
-    for batch in batches {
-        let mut cursor = batch.cursor();
-        while let Some(k) = cursor.get_key(batch) {
-            let kh = stable_hash(k);
-            if filter.is_none_or(|f| f.binary_search(&kh).is_ok()) {
-                while let Some(v) = cursor.get_val(batch) {
-                    let vh = stable_hash(v);
-                    cursor.map_times(batch, |t, d| {
-                        keys.push(kh);
-                        vals.push(vh);
-                        times.push(t.clone());
-                        diffs.push(d.clone());
-                        reals.push((k.clone(), v.clone()));
-                    });
-                    cursor.step_val(batch);
+    /// Append one key's `(val, time, diff)` records read at the cursor's current key.
+    fn read_key(&mut self, cursor: &mut <RefBatch<K, V, T, R> as Navigable>::Cursor, batch: &RefBatch<K, V, T, R>, key: &K, kh: u64) {
+        while let Some(val) = cursor.get_val(batch) {
+            let vh = stable_hash(val);
+            cursor.map_times(batch, |t, d| {
+                self.keys.push(kh);
+                self.vals.push(vh);
+                self.times.push(t.clone());
+                self.diffs.push(d.clone());
+                self.reals.push((key.clone(), val.clone()));
+            });
+            cursor.step_val(batch);
+        }
+    }
+
+    /// Read every record of `batches` (the unfiltered, delta-sized read).
+    fn scan(&mut self, batches: &[RefBatch<K, V, T, R>]) {
+        for batch in batches {
+            let mut cursor = batch.cursor();
+            while let Some(key) = cursor.get_key(batch) {
+                let key = key.clone();
+                self.read_key(&mut cursor, batch, &key, stable_hash(&key));
+                cursor.step_key(batch);
+            }
+        }
+    }
+
+    /// Read exactly the records of `keys` (sorted) from `batches`, by seeking — the
+    /// filtered read costs `O(|keys| · log)` per batch plus the matched records, never
+    /// the batch size.
+    fn seek(&mut self, batches: &[RefBatch<K, V, T, R>], keys: &[K]) {
+        debug_assert!(keys.windows(2).all(|w| w[0] < w[1]));
+        for batch in batches {
+            let mut cursor = batch.cursor();
+            for key in keys {
+                cursor.seek_key(batch, key);
+                if cursor.get_key(batch) == Some(key) {
+                    self.read_key(&mut cursor, batch, key, stable_hash(key));
                 }
             }
-            cursor.step_key(batch);
         }
     }
-}
 
-/// Present a batch list as a sorted, consolidated proxy run plus the aligned real
-/// records (entry `i` is presented record `i`'s real `(key, val)`).
-fn present<K, V, T, R>(batches: &[&[RefBatch<K, V, T, R>]], filter: Option<&[u64]>) -> (ProxyChunk<T, R>, Vec<(K, V)>)
-where
-    K: Ord + Clone + Hash + 'static,
-    V: Ord + Clone + Hash + 'static,
-    T: Lattice + Timestamp,
-    R: Ord + Semigroup + 'static,
-{
-    let (mut ks, mut vs) = (Vec::new(), Vec::new());
-    let (mut ts, mut ds) = (Vec::new(), Vec::new());
-    let mut reals = Vec::new();
-    for list in batches {
-        read_rows(list, filter, &mut ks, &mut vs, &mut ts, &mut ds, &mut reals);
+    /// Sort, consolidate, and align: the proxy run plus the real record per run entry.
+    fn present(self) -> (ProxyChunk<T, R>, Vec<(K, V)>) {
+        let (chunk, reps) = ProxyChunk::from_unsorted(self.keys, self.vals, self.times, self.diffs);
+        let aligned = reps.iter().map(|&i| self.reals[i].clone()).collect();
+        (chunk, aligned)
     }
-    let (chunk, reps) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
-    let aligned = reps.iter().map(|&i| reals[i].clone()).collect();
-    (chunk, aligned)
+}
+
+/// The distinct keys among `reals` whose hash appears in the sorted `filter`, sorted by
+/// the *key* order (ready for seeking).
+fn keys_matching<K: Ord + Clone + Hash, V>(reals: &[(K, V)], filter: &[u64]) -> Vec<K> {
+    let mut keys: Vec<K> = reals
+        .iter()
+        .filter(|(k, _)| filter.binary_search(&stable_hash(k)).is_ok())
+        .map(|(k, _)| k.clone())
+        .collect();
+    keys.sort();
+    keys.dedup();
+    keys
 }
 
 /// The join backend: presents [`VecChunk`] batches by hashing, applies a
 /// `(key, val0, val1) → data` projection to matched index pairs, and emits
 /// `Vec<(data, time, diff)>` containers.
+///
+/// A filtered present resolves the filter's hashes to real keys through the *other*
+/// side's presentation (the fresh side, presented first, unfiltered) and seeks them.
 pub struct VecJoinBackend<K, V0, V1, D, L> {
     logic: L,
     /// Real records aligned with the current first-input presentation.
     left: Vec<(K, V0)>,
-    /// Real values aligned with the current second-input presentation.
-    right: Vec<V1>,
+    /// Real records aligned with the current second-input presentation.
+    right: Vec<(K, V1)>,
     marker: PhantomData<fn() -> D>,
 }
 
@@ -128,15 +165,25 @@ where
     type ROut = RO;
     type Output = Vec<(D, T, RO)>;
 
-    fn present0(&mut self, batches: &[RefBatch<K, V0, T, R0>]) -> ProxyChunk<T, R0> {
-        let (chunk, reals) = present(&[batches], None);
+    fn present0(&mut self, batches: &[RefBatch<K, V0, T, R0>], filter: Option<&[u64]>) -> ProxyChunk<T, R0> {
+        let mut rows = Rows::new();
+        match filter {
+            None => rows.scan(batches),
+            Some(f) => rows.seek(batches, &keys_matching(&self.right, f)),
+        }
+        let (chunk, reals) = rows.present();
         self.left = reals;
         chunk
     }
 
-    fn present1(&mut self, batches: &[RefBatch<K, V1, T, R1>]) -> ProxyChunk<T, R1> {
-        let (chunk, reals) = present(&[batches], None);
-        self.right = reals.into_iter().map(|(_, v)| v).collect();
+    fn present1(&mut self, batches: &[RefBatch<K, V1, T, R1>], filter: Option<&[u64]>) -> ProxyChunk<T, R1> {
+        let mut rows = Rows::new();
+        match filter {
+            None => rows.scan(batches),
+            Some(f) => rows.seek(batches, &keys_matching(&self.left, f)),
+        }
+        let (chunk, reals) = rows.present();
+        self.right = reals;
         chunk
     }
 
@@ -144,7 +191,7 @@ where
         let mut out = Vec::with_capacity(left.len());
         for (((&l, &r), t), d) in left.iter().zip(right).zip(times).zip(diffs) {
             let (k, v0) = &self.left[l];
-            let v1 = &self.right[r];
+            let (_, v1) = &self.right[r];
             out.push(((self.logic)(k, v0, v1), t, d));
         }
         out
@@ -155,13 +202,21 @@ where
 /// user's reduction logic (row-reduce-shaped: `(key, &[(val, diff)], &mut output)`)
 /// per key, mints output ids by hashing produced values, and materializes proxy records
 /// back into [`VecChunk`] output batches.
+///
+/// The changed-key restriction is honored by *seeking*: the accumulated input and output
+/// histories are read only at the changed keys. Every changed hash is resolvable to its
+/// key — this retire's touched keys from the (delta-sized) novel batches, pending keys
+/// from the retire that pended them (the `keys` map persists exactly those entries).
 pub struct VecReduceBackend<K, V, V2, L> {
     logic: L,
-    /// `key_hash → key`, primed by the presentations of the current retire.
+    /// `key_hash → key` for the changed keys: primed from each retire's novel batches,
+    /// pruned to the changed set on entry (so pending keys survive between retires and
+    /// nothing else accumulates).
     keys: HashMap<u64, K>,
     /// Real values aligned with the current input presentation.
     in_vals: Vec<V>,
-    /// `value_id → output value`, primed by the output presentation and by minting.
+    /// `value_id → output value` for the current retire, primed by the output
+    /// presentation and by minting; cleared each retire.
     out_vals: HashMap<u64, V2>,
 }
 
@@ -170,6 +225,16 @@ impl<K, V, V2, L> VecReduceBackend<K, V, V2, L> {
     pub fn new(logic: L) -> Self {
         VecReduceBackend { logic, keys: HashMap::new(), in_vals: Vec::new(), out_vals: HashMap::new() }
     }
+
+    /// The changed keys, in key order, ready for seeking.
+    fn seek_keys(&self) -> Vec<K>
+    where
+        K: Ord + Clone,
+    {
+        let mut keys: Vec<K> = self.keys.values().cloned().collect();
+        keys.sort();
+        keys
+    }
 }
 
 impl<K, V, V2, T, RIn, ROut, L> ProxyReduceBackend<RefBatch<K, V, T, RIn>, RefBatch<K, V2, T, ROut>> for VecReduceBackend<K, V, V2, L>
@@ -200,18 +265,31 @@ where
     }
 
     fn present_input(&mut self, history: &[RefBatch<K, V, T, RIn>], novel: &[RefBatch<K, V, T, RIn>], keys: &[u64]) -> ProxyChunk<T, RIn> {
-        let (chunk, reals) = present(&[history, novel], Some(keys));
-        for (k, _) in &reals {
+        // Prune the hash→key map to the changed set: what survives from earlier retires
+        // is exactly the pending keys, so the map is bounded by the delta.
+        self.keys.retain(|h, _| keys.binary_search(h).is_ok());
+        // The novel batches are delta-sized and their keys are all changed: read them
+        // fully, and prime the map from what was read.
+        let mut rows = Rows::new();
+        rows.scan(novel);
+        for (k, _) in &rows.reals {
             self.keys.entry(stable_hash(k)).or_insert_with(|| k.clone());
         }
+        // The accumulated history is not scanned: seek exactly the changed keys.
+        rows.seek(history, &self.seek_keys());
+        let (chunk, reals) = rows.present();
         self.in_vals = reals.into_iter().map(|(_, v)| v).collect();
         chunk
     }
 
-    fn present_output(&mut self, batches: &[RefBatch<K, V2, T, ROut>], keys: &[u64]) -> ProxyChunk<T, ROut> {
-        let (chunk, reals) = present(&[batches], Some(keys));
-        for (i, (k, v)) in reals.into_iter().enumerate() {
-            self.keys.entry(chunk.key_hashes()[i]).or_insert(k);
+    fn present_output(&mut self, batches: &[RefBatch<K, V2, T, ROut>], _keys: &[u64]) -> ProxyChunk<T, ROut> {
+        // The id → value map is per-retire state; start it afresh.
+        self.out_vals.clear();
+        // Seek the changed keys (the same set `present_input` resolved).
+        let mut rows = Rows::new();
+        rows.seek(batches, &self.seek_keys());
+        let (chunk, reals) = rows.present();
+        for (i, (_, v)) in reals.into_iter().enumerate() {
             self.out_vals.entry(chunk.value_ids()[i]).or_insert(v);
         }
         chunk
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index 025dfefee..d75d916ab 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -339,3 +339,210 @@ fn proxy_reduce_synthesizes_and_pends_product_times() {
     );
     assert!(frontier3.is_empty());
 }
+
+// ---------------------------------------------------------------------------
+// Asymptotics: presented work must track the delta, not the accumulated trace.
+// ---------------------------------------------------------------------------
+//
+// The cursor tactics touch an arrangement only at the keys a fresh batch names
+// (plus, for reduce, pending keys), at logarithmic seek cost. The proxy tactics
+// must not be asymptotically worse: the changed-key filter (reduce) and the
+// fresh-side filter (join) exist precisely so a backend can seek rather than
+// scan. These tests pin that: with `N` arranged keys and rounds touching one
+// key, the number of *presented* records — a deterministic work measure the
+// backend observes directly — must stay far below `N`, where a scanning
+// implementation would present `Ω(rounds · N)`.
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+
+use differential_dataflow::operators::int_proxy::{ProxyChunk, ProxyJoinBackend, ProxyReduceBackend};
+use differential_dataflow::trace::BatchReader;
+
+/// A reduce backend wrapper counting records presented by the inner backend.
+struct CountingReduce<B> {
+    inner: B,
+    presented: Arc<AtomicUsize>,
+}
+
+impl<B1, B2, B> ProxyReduceBackend<B1, B2> for CountingReduce<B>
+where
+    B1: BatchReader,
+    B2: BatchReader<Time = B1::Time>,
+    B: ProxyReduceBackend<B1, B2>,
+{
+    type RIn = B::RIn;
+    type ROut = B::ROut;
+
+    fn key_hashes(&self, batches: &[B1]) -> Vec<u64> {
+        self.inner.key_hashes(batches)
+    }
+    fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, B::RIn> {
+        let chunk = self.inner.present_input(history, novel, keys);
+        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
+        chunk
+    }
+    fn present_output(&mut self, batches: &[B2], keys: &[u64]) -> ProxyChunk<B1::Time, B::ROut> {
+        let chunk = self.inner.present_output(batches, keys);
+        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
+        chunk
+    }
+    fn reduce(&mut self, key_hash: u64, input: &[(usize, B::RIn)]) -> Vec<(u64, B::ROut)> {
+        self.inner.reduce(key_hash, input)
+    }
+    fn materialize(&mut self, records: ProxyChunk<B1::Time, B::ROut>, description: Description<B1::Time>) -> B2 {
+        self.inner.materialize(records, description)
+    }
+}
+
+/// A join backend wrapper counting records presented by the inner backend.
+struct CountingJoin<B> {
+    inner: B,
+    presented: Arc<AtomicUsize>,
+}
+
+impl<B0, B1, B> ProxyJoinBackend<B0, B1> for CountingJoin<B>
+where
+    B0: BatchReader,
+    B1: BatchReader<Time = B0::Time>,
+    B: ProxyJoinBackend<B0, B1>,
+{
+    type R0 = B::R0;
+    type R1 = B::R1;
+    type ROut = B::ROut;
+    type Output = B::Output;
+
+    fn present0(&mut self, batches: &[B0], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, B::R0> {
+        let chunk = self.inner.present0(batches, filter);
+        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
+        chunk
+    }
+    fn present1(&mut self, batches: &[B1], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, B::R1> {
+        let chunk = self.inner.present1(batches, filter);
+        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
+        chunk
+    }
+    fn cross(&mut self, left: &[usize], right: &[usize], times: Vec<B0::Time>, diffs: Vec<B::ROut>) -> B::Output {
+        self.inner.cross(left, right, times, diffs)
+    }
+}
+
+#[test]
+fn proxy_reduce_work_is_delta_proportional() {
+    use timely::dataflow::operators::probe::{Handle, Probe};
+
+    const N: u64 = 20_000;
+    const ROUNDS: u64 = 5;
+    let presented = Arc::new(AtomicUsize::new(0));
+    let counter = Arc::clone(&presented);
+
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, c) = scope.new_collection::<(u64, u64), isize>();
+            let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
+            let backend = CountingReduce {
+                inner: VecReduceBackend::new(|_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
+                    let count: isize = input.iter().map(|(_, d)| *d).sum();
+                    if count > 0 {
+                        output.push((count, 1));
+                    }
+                }),
+                presented: counter,
+            };
+            let reduced = reduce_with_tactic::<_, Spine<u64, isize>, _>(arranged, "ProxyReduce", ProxyReduceTactic::new(backend));
+            reduced.stream.probe_with(&probe);
+            input
+        });
+
+        // Round 0: a large arrangement. This work is inherently O(N); let it drain.
+        for k in 0..N {
+            input.update((k, k % 5), 1);
+        }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) {
+            worker.step();
+        }
+        let after_load = presented.load(AtomicOrdering::SeqCst);
+
+        // Rounds 1..: touch ONE key per round. Presented work must track that key's
+        // history, independent of N; a scanning backend would present ≥ ROUNDS · N.
+        for t in 1..=ROUNDS {
+            input.update((7, 100 + t), 1);
+            input.advance_to(t + 1);
+            input.flush();
+            while probe.less_than(input.time()) {
+                worker.step();
+            }
+        }
+        let total = presented.load(AtomicOrdering::SeqCst);
+        let incremental = total - after_load;
+        assert!(incremental > 0, "the incremental rounds presented nothing");
+        assert!(
+            incremental < (N as usize) / 4,
+            "presented {incremental} records over {ROUNDS} single-key rounds against {N} keys: not delta-proportional"
+        );
+    });
+}
+
+#[test]
+fn proxy_join_work_is_delta_proportional() {
+    use timely::dataflow::operators::probe::{Handle, Probe};
+
+    const N: u64 = 20_000;
+    const ROUNDS: u64 = 5;
+    let presented = Arc::new(AtomicUsize::new(0));
+    let counter = Arc::clone(&presented);
+
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let (mut left, mut right) = worker.dataflow::<u64, _, _>(|scope| {
+            let (left, c0) = scope.new_collection::<(u64, u64), isize>();
+            let (right, c1) = scope.new_collection::<(u64, u64), isize>();
+            let a0 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c0.inner, Pipeline, "Arrange0");
+            let a1 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c1.inner, Pipeline, "Arrange1");
+            let backend = CountingJoin {
+                inner: VecJoinBackend::new(|k: &u64, v0: &u64, v1: &u64| (*k, (*v0, *v1))),
+                presented: counter,
+            };
+            let joined = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<(JoinOut, u64, isize)>>>(a0, a1, ProxyJoinTactic::new(backend));
+            joined.probe_with(&probe);
+            (left, right)
+        });
+
+        // Round 0: a large accumulated right side. Inherently O(N); let it drain.
+        for k in 0..N {
+            right.update((k, k), 1);
+        }
+        left.advance_to(1);
+        right.advance_to(1);
+        left.flush();
+        right.flush();
+        while probe.less_than(left.time()) {
+            worker.step();
+        }
+        let after_load = presented.load(AtomicOrdering::SeqCst);
+
+        // Rounds 1..: one fresh left record per round. The unit joins it against the
+        // accumulated right trace; the fresh-side filter must keep presented work at
+        // the matched key's records, independent of N.
+        for t in 1..=ROUNDS {
+            left.update((7, 100 + t), 1);
+            left.advance_to(t + 1);
+            right.advance_to(t + 1);
+            left.flush();
+            right.flush();
+            while probe.less_than(left.time()) {
+                worker.step();
+            }
+        }
+        let total = presented.load(AtomicOrdering::SeqCst);
+        let incremental = total - after_load;
+        assert!(incremental > 0, "the incremental rounds presented nothing");
+        assert!(
+            incremental < (N as usize) / 4,
+            "presented {incremental} records over {ROUNDS} single-record rounds against {N} keys: not delta-proportional"
+        );
+    });
+}

From 15d7fbc13d1aa5c2fe06715244791d24f4a89995 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 04:37:51 -0400
Subject: [PATCH 04/68] =?UTF-8?q?int=5Fproxy:=20the=20self-contained=20ass?=
 =?UTF-8?q?essment=20=E2=80=94=20identity=20backend,=20grid-oracle=20fuzz?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The minimal harness for the framework, closed over itself: the tactics
demand only BatchReader of the trace, and ProxyChunk is already a
Chunk, so a batch of proxy chunks is the minimal arrangement — the
proxy data IS the data, no separate chunk class needed. The identity
backend makes values u64s with the identity as the id function: no
hashing, no resolution machinery, no collision possibility, and
materialize emits the proxy records verbatim (incidentally exercising
ChunkBatch<ProxyChunk> as a real output batch).

What remains under test is exactly the framework's own contribution —
interesting-time discovery, desired-vs-current deltas, pending, held
routing — fuzzed over Product-time grids: 300 random inputs retired
through random diagonal frontiers (so synthetic joins arise inside and
across intervals and must pend), driven through an emulation of the
reduce driver protocol, and checked against a brute-force oracle at
every grid point: the accumulated output must equal the reduction of
the accumulated input, everywhere, for count/distinct/min-shaped
reducers.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 differential-dataflow/tests/int_proxy.rs | 274 ++++++++++++++++++++++-
 1 file changed, 272 insertions(+), 2 deletions(-)

diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index d75d916ab..f23ae6cac 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -15,6 +15,7 @@ use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::capture::Event;
 use timely::dataflow::operators::Capture;
 use timely::order::Product;
+use timely::PartialOrder;
 use timely::progress::Antichain;
 
 use differential_dataflow::consolidation::consolidate_updates;
@@ -437,7 +438,7 @@ fn proxy_reduce_work_is_delta_proportional() {
     let counter = Arc::clone(&presented);
 
     timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
+        let probe = Handle::new();
         let mut input = worker.dataflow::<u64, _, _>(|scope| {
             let (input, c) = scope.new_collection::<(u64, u64), isize>();
             let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
@@ -496,7 +497,7 @@ fn proxy_join_work_is_delta_proportional() {
     let counter = Arc::clone(&presented);
 
     timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
+        let probe = Handle::new();
         let (mut left, mut right) = worker.dataflow::<u64, _, _>(|scope| {
             let (left, c0) = scope.new_collection::<(u64, u64), isize>();
             let (right, c1) = scope.new_collection::<(u64, u64), isize>();
@@ -546,3 +547,272 @@ fn proxy_join_work_is_delta_proportional() {
         );
     });
 }
+
+// ---------------------------------------------------------------------------
+// The minimal self-contained assessment: the framework closed over itself.
+// ---------------------------------------------------------------------------
+//
+// The tactics are operator-side: they demand only `BatchReader` of the trace, so the
+// minimal arrangement is a batch of `ProxyChunk` itself — the proxy data IS the data.
+// The `IdentityReduce` backend makes the loop close: values are `u64`s and the id
+// function is the identity, so there is no hashing, no resolution machinery, and no
+// collision possibility. What remains under test is exactly the framework's own
+// contribution — the interesting-time logic, desired-vs-current deltas, pending, and
+// held-time routing — which a brute-force oracle checks at EVERY point of a
+// partially-ordered time grid: the accumulated output must equal the reduction of the
+// accumulated input, everywhere, under randomized inputs and randomized retire
+// boundaries (diagonal frontiers, so synthetic joins pend across retires).
+
+mod identity {
+    use std::rc::Rc;
+    use differential_dataflow::operators::int_proxy::{ProxyChunk, ProxyReduceBackend};
+    use differential_dataflow::trace::Description;
+    use differential_dataflow::trace::chunk::ChunkBatch;
+    use differential_dataflow::lattice::Lattice;
+    use timely::progress::Timestamp;
+
+    pub type Batch<T> = Rc<ChunkBatch<ProxyChunk<T, isize>>>;
+
+    /// The identity backend: batches are proxy chunks, values are the ids themselves.
+    pub struct IdentityReduce<T, L> {
+        pub logic: L,
+        /// The live input presentation, for representative-index → id resolution.
+        current: ProxyChunk<T, isize>,
+    }
+
+    impl<T: Timestamp + Lattice, L> IdentityReduce<T, L> {
+        pub fn new(logic: L) -> Self {
+            IdentityReduce { logic, current: ProxyChunk::default() }
+        }
+    }
+
+    fn records<T: Timestamp + Lattice>(batches: &[Batch<T>], keys: Option<&[u64]>) -> (Vec<u64>, Vec<u64>, Vec<T>, Vec<isize>) {
+        let (mut ks, mut vs) = (Vec::new(), Vec::new());
+        let (mut ts, mut ds) = (Vec::new(), Vec::new());
+        for batch in batches {
+            for chunk in &batch.chunks {
+                for i in 0..chunk.len() {
+                    let k = chunk.key_hashes()[i];
+                    if keys.is_none_or(|f| f.binary_search(&k).is_ok()) {
+                        ks.push(k);
+                        vs.push(chunk.value_ids()[i]);
+                        ts.push(chunk.times()[i].clone());
+                        ds.push(chunk.diffs()[i]);
+                    }
+                }
+            }
+        }
+        (ks, vs, ts, ds)
+    }
+
+    impl<T, L> ProxyReduceBackend<Batch<T>, Batch<T>> for IdentityReduce<T, L>
+    where
+        T: Timestamp + Lattice,
+        L: FnMut(&[(u64, isize)]) -> Vec<(u64, isize)>,
+    {
+        type RIn = isize;
+        type ROut = isize;
+
+        fn key_hashes(&self, batches: &[Batch<T>]) -> Vec<u64> {
+            let (mut ks, _, _, _) = records(batches, None);
+            ks.sort_unstable();
+            ks.dedup();
+            ks
+        }
+
+        fn present_input(&mut self, history: &[Batch<T>], novel: &[Batch<T>], keys: &[u64]) -> ProxyChunk<T, isize> {
+            let (mut ks, mut vs, mut ts, mut ds) = records(history, Some(keys));
+            let (k2, v2, t2, d2) = records(novel, Some(keys));
+            ks.extend(k2);
+            vs.extend(v2);
+            ts.extend(t2);
+            ds.extend(d2);
+            let (chunk, _reps) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
+            self.current = chunk.clone();
+            chunk
+        }
+
+        fn present_output(&mut self, batches: &[Batch<T>], keys: &[u64]) -> ProxyChunk<T, isize> {
+            let (ks, vs, ts, ds) = records(batches, Some(keys));
+            ProxyChunk::from_unsorted(ks, vs, ts, ds).0
+        }
+
+        fn reduce(&mut self, _key_hash: u64, input: &[(usize, isize)]) -> Vec<(u64, isize)> {
+            // Resolve representative indices to ids; the ids are the values.
+            let pairs: Vec<(u64, isize)> = input.iter().map(|&(i, d)| (self.current.value_ids()[i], d)).collect();
+            (self.logic)(&pairs)
+        }
+
+        fn materialize(&mut self, chunk: ProxyChunk<T, isize>, description: Description<T>) -> Batch<T> {
+            // The proxy records ARE the output records: the output arrangement is proxy
+            // chunks (incidentally exercising `ChunkBatch<ProxyChunk>` as a real batch).
+            let chunks = if chunk.is_empty() { Vec::new() } else { vec![chunk] };
+            Rc::new(ChunkBatch::new(chunks, description))
+        }
+    }
+}
+
+/// Drive `ProxyReduceTactic` over the identity backend through a sequence of retires,
+/// emulating the driver protocol: `lower` chases `upper`, `held` is the previous
+/// returned frontier joined with the round's input times (the batch capabilities),
+/// and source/output batch lists accumulate.
+fn drive_identity_reduce<L>(
+    rounds: &[(Antichain<PT>, Vec<((u64, u64), PT, isize)>)],
+    logic: L,
+) -> Vec<((u64, u64), PT, isize)>
+where
+    L: FnMut(&[(u64, isize)]) -> Vec<(u64, isize)>,
+{
+    use differential_dataflow::operators::int_proxy::ProxyChunk;
+    use differential_dataflow::trace::chunk::ChunkBatch;
+
+    let mut tactic = ProxyReduceTactic::new(identity::IdentityReduce::new(logic));
+    let mut lower = Antichain::from_elem(pt(0, 0));
+    let mut frontier: Antichain<PT> = Antichain::new();
+    let mut source: Vec<identity::Batch<PT>> = Vec::new();
+    let mut outputs: Vec<identity::Batch<PT>> = Vec::new();
+    let mut produced_records = Vec::new();
+
+    for (upper, updates) in rounds {
+        let input: Vec<identity::Batch<PT>> = if updates.is_empty() {
+            Vec::new()
+        } else {
+            let (ks, vs): (Vec<u64>, Vec<u64>) = updates.iter().map(|((k, v), _, _)| (*k, *v)).unzip();
+            let ts: Vec<PT> = updates.iter().map(|(_, t, _)| t.clone()).collect();
+            let ds: Vec<isize> = updates.iter().map(|(_, _, d)| *d).collect();
+            let (chunk, _) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
+            let desc = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(pt(0, 0)));
+            let chunks = if chunk.is_empty() { Vec::new() } else { vec![chunk] };
+            vec![std::rc::Rc::new(ChunkBatch::new(chunks, desc))]
+        };
+
+        // Held capabilities: what the driver would hold — previously returned frontier
+        // plus the capabilities that arrived with this round's batches.
+        let mut held = frontier.clone();
+        for (_, t, _) in updates {
+            held.insert(t.clone());
+        }
+
+        let (produced, new_frontier) = tactic.retire(source.clone(), outputs.clone(), input.clone(), &lower, upper, &held);
+        for (_, batch) in produced {
+            for chunk in &batch.chunks {
+                for i in 0..chunk.len() {
+                    produced_records.push((
+                        (chunk.key_hashes()[i], chunk.value_ids()[i]),
+                        chunk.times()[i].clone(),
+                        chunk.diffs()[i],
+                    ));
+                }
+            }
+            outputs.push(batch);
+        }
+        source.extend(input);
+        frontier = new_frontier;
+        lower = upper.clone();
+    }
+    assert!(frontier.is_empty(), "everything retired, but times remain pending");
+    produced_records
+}
+
+
+/// Randomized closure test of the reduce tactic alone, over partially ordered times:
+/// random updates on a `Product` grid, retired through random diagonal frontiers (so
+/// synthetic joins arise inside and across intervals and must pend), checked against a
+/// brute-force oracle at EVERY grid point — the accumulated output there must equal the
+/// reduction of the accumulated input.
+#[test]
+fn proxy_reduce_identity_fuzz_matches_grid_oracle() {
+    const T: u64 = 3; // times range over the (T+1)×(T+1) grid
+    let mut seed = 0x853C49E6748FEA9Bu64;
+
+    // Reducers over ids (values are ids; the id order is the value order here).
+    type Logic = fn(&[(u64, isize)]) -> Vec<(u64, isize)>;
+    let reducers: Vec<Logic> = vec![
+        // count: the number of present records, as a value.
+        |acc| {
+            let s: isize = acc.iter().map(|(_, d)| *d).sum();
+            if s > 0 { vec![(s as u64, 1)] } else { Vec::new() }
+        },
+        // distinct: the unit value if anything is present.
+        |acc| {
+            if acc.iter().any(|(_, d)| *d > 0) { vec![(0, 1)] } else { Vec::new() }
+        },
+        // min: the least present id.
+        |acc| {
+            acc.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).min().map(|m| vec![(m, 1)]).unwrap_or_default()
+        },
+    ];
+
+    for iteration in 0..300 {
+        let logic = reducers[iteration % reducers.len()];
+
+        // Random updates over a small key/value space and the time grid.
+        let n = (xorshift(&mut seed) % 12) as usize + 1;
+        let updates: Vec<((u64, u64), PT, isize)> = (0..n)
+            .map(|_| {
+                let k = xorshift(&mut seed) % 2;
+                let v = xorshift(&mut seed) % 3;
+                let t = pt(xorshift(&mut seed) % (T + 1), xorshift(&mut seed) % (T + 1));
+                let d = if xorshift(&mut seed) % 3 == 0 { -1 } else { 1 };
+                ((k, v), t, d)
+            })
+            .collect();
+
+        // Random increasing diagonal frontiers: upper_r = { p : |p| = s_r } for an
+        // increasing random set of diagonals, closed by the empty frontier (retire all).
+        let mut cuts: Vec<u64> = (1..=2 * T).filter(|_| xorshift(&mut seed) % 2 == 0).collect();
+        cuts.dedup();
+        let mut rounds: Vec<(Antichain<PT>, Vec<((u64, u64), PT, isize)>)> = Vec::new();
+        let mut prev = 0u64;
+        for &s in &cuts {
+            let upper = Antichain::from_iter((0..=s).map(|x| pt(x, s - x)));
+            let batch = updates.iter().filter(|(_, t, _)| {
+                let sum = t.outer + t.inner;
+                prev <= sum && sum < s
+            }).cloned().collect();
+            rounds.push((upper, batch));
+            prev = s;
+        }
+        let tail = updates.iter().filter(|(_, t, _)| t.outer + t.inner >= prev).cloned().collect();
+        rounds.push((Antichain::new(), tail));
+
+        let produced = drive_identity_reduce(&rounds, logic);
+
+        // The oracle: at every grid point, per key, the accumulated output equals the
+        // reduction of the accumulated input.
+        for x in 0..=T {
+            for y in 0..=T {
+                let p = pt(x, y);
+                for key in 0..2u64 {
+                    let mut acc: BTreeMap<u64, isize> = BTreeMap::new();
+                    for ((k, v), t, d) in &updates {
+                        if *k == key && t.less_equal(&p) {
+                            *acc.entry(*v).or_insert(0) += d;
+                        }
+                    }
+                    acc.retain(|_, d| *d != 0);
+                    let pairs: Vec<(u64, isize)> = acc.into_iter().collect();
+                    let mut want: BTreeMap<u64, isize> = BTreeMap::new();
+                    if !pairs.is_empty() {
+                        for (v, d) in (logic)(&pairs) {
+                            *want.entry(v).or_insert(0) += d;
+                        }
+                        want.retain(|_, d| *d != 0);
+                    }
+                    let mut got: BTreeMap<u64, isize> = BTreeMap::new();
+                    for ((k, v), t, d) in &produced {
+                        if *k == key && t.less_equal(&p) {
+                            *got.entry(*v).or_insert(0) += d;
+                        }
+                    }
+                    got.retain(|_, d| *d != 0);
+                    assert_eq!(
+                        got, want,
+                        "iteration {iteration}, key {key}, point {p:?}\nupdates: {updates:?}\nrounds: {:?}\nproduced: {produced:?}",
+                        rounds.iter().map(|(u, b)| (u.elements().to_vec(), b.len())).collect::<Vec<_>>()
+                    );
+                }
+            }
+        }
+    }
+}

From 13d0a47f9a87ba41977ab9697e0cae4ab5d74e3f Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 05:18:41 -0400
Subject: [PATCH 05/68] int_proxy: wall-clock bench; fix a capacity leak the
 bench found
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An ignored benchmark (cargo test --release --test int_proxy -- --ignored
--nocapture) compares full stacks — the stock row operators against
chunk arrangements plus the proxy tactics over the reference backend —
for a bulk load and a steady-state incremental phase (warmed past the
post-load merge-amortization transient).

The bench caught what the counting gates could not: the reference
backend's hash→key map was pruned by retain (and the per-retire value
map by clear), both of which keep the backing table — so after a
million-key load, every retire walked a million-bucket table to visit
one entry, ~130µs/round of pure capacity. shrink_to_fit after the
prune and a fresh map per retire fix it.

Steady-state single-key rounds after the fix, proxy vs row: reduce
~1.4x at every scale (flat from 10k to 1M keys — the delta-
proportionality gates hold in wall clock too), join at parity below 1M
(~1.0x). Bulk load carries the presentation layer's constant factor
(per-record hashing, clones, by-hash sort): reduce 3-5x, join ~2x —
the costs a columnar backend's bulk primitives are meant to attack.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/reference.rs      |  11 +-
 differential-dataflow/tests/int_proxy.rs      | 140 ++++++++++++++++++
 2 files changed, 148 insertions(+), 3 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
index 09de067ae..111a13adb 100644
--- a/differential-dataflow/src/operators/int_proxy/reference.rs
+++ b/differential-dataflow/src/operators/int_proxy/reference.rs
@@ -266,8 +266,11 @@ where
 
     fn present_input(&mut self, history: &[RefBatch<K, V, T, RIn>], novel: &[RefBatch<K, V, T, RIn>], keys: &[u64]) -> ProxyChunk<T, RIn> {
         // Prune the hash→key map to the changed set: what survives from earlier retires
-        // is exactly the pending keys, so the map is bounded by the delta.
+        // is exactly the pending keys, so the map is bounded by the delta. Shrink too —
+        // `retain` keeps the backing table, and a table sized by a past big retire would
+        // make every later `values()` walk pay for its capacity, not its contents.
         self.keys.retain(|h, _| keys.binary_search(h).is_ok());
+        self.keys.shrink_to_fit();
         // The novel batches are delta-sized and their keys are all changed: read them
         // fully, and prime the map from what was read.
         let mut rows = Rows::new();
@@ -283,8 +286,10 @@ where
     }
 
     fn present_output(&mut self, batches: &[RefBatch<K, V2, T, ROut>], _keys: &[u64]) -> ProxyChunk<T, ROut> {
-        // The id → value map is per-retire state; start it afresh.
-        self.out_vals.clear();
+        // The id → value map is per-retire state; start it afresh. A fresh map, not
+        // `clear()`: clearing keeps the backing table, whose capacity a past big retire
+        // set, and later walks would pay for it.
+        self.out_vals = HashMap::new();
         // Seek the changed keys (the same set `present_input` resolved).
         let mut rows = Rows::new();
         rows.seek(batches, &self.seek_keys());
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index f23ae6cac..3c4a80181 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -816,3 +816,143 @@ fn proxy_reduce_identity_fuzz_matches_grid_oracle() {
         }
     }
 }
+
+// ---------------------------------------------------------------------------
+// Wall clock: the proxy stack against the stock row stack.
+// ---------------------------------------------------------------------------
+//
+// Not run by default. Run with:
+//   cargo test --release -p differential-dataflow --test int_proxy -- --ignored --nocapture
+//
+// Compares full stacks end to end — the stock row operators (their own arrangements
+// included) against chunk arrangements plus the proxy tactics over the reference
+// backend — for a bulk load of `n` keys and an incremental phase of single-key rounds.
+// The counting tests above pin the asymptotics; this reports the constants.
+
+fn bench_reduce(n: u64, rounds: u64, proxy: bool) -> (std::time::Duration, std::time::Duration) {
+    use std::time::Instant;
+    use timely::dataflow::operators::probe::{Handle, Probe};
+
+    timely::execute_directly(move |worker| {
+        let probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, c) = scope.new_collection::<(u64, u64), isize>();
+            let count = |_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
+                let count: isize = input.iter().map(|(_, d)| *d).sum();
+                if count > 0 {
+                    output.push((count, 1));
+                }
+            };
+            if proxy {
+                let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
+                let reduced = reduce_with_tactic::<_, Spine<u64, isize>, _>(arranged, "ProxyReduce", ProxyReduceTactic::new(VecReduceBackend::new(count)));
+                reduced.stream.probe_with(&probe);
+            } else {
+                c.reduce(count).inner.probe_with(&probe);
+            }
+            input
+        });
+
+        let start = Instant::now();
+        for k in 0..n {
+            input.update((k, k % 5), 1);
+        }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) {
+            worker.step();
+        }
+        let load = start.elapsed();
+
+        // Warm up with unmeasured incremental rounds: the load leaves amortized
+        // trace-maintenance debt (compaction-driven merges) that the first couple
+        // thousand rounds pay down; the measured phase is steady state.
+        let warmup = 5_000;
+        let mut timer = Instant::now();
+        for t in 1..=(warmup + rounds) {
+            if t == warmup + 1 { timer = Instant::now(); }
+            input.update((t % 97, 100 + t), 1);
+            input.advance_to(t + 1);
+            input.flush();
+            while probe.less_than(input.time()) {
+                worker.step();
+            }
+        }
+        (load, timer.elapsed())
+    })
+}
+
+fn bench_join(n: u64, rounds: u64, proxy: bool) -> (std::time::Duration, std::time::Duration) {
+    use std::time::Instant;
+    use timely::dataflow::operators::probe::{Handle, Probe};
+
+    timely::execute_directly(move |worker| {
+        let probe = Handle::new();
+        let (mut left, mut right) = worker.dataflow::<u64, _, _>(|scope| {
+            let (left, c0) = scope.new_collection::<(u64, u64), isize>();
+            let (right, c1) = scope.new_collection::<(u64, u64), isize>();
+            if proxy {
+                let a0 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c0.inner, Pipeline, "Arrange0");
+                let a1 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c1.inner, Pipeline, "Arrange1");
+                let tactic = ProxyJoinTactic::new(VecJoinBackend::new(|k: &u64, v0: &u64, v1: &u64| (*k, (*v0, *v1))));
+                let joined = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<(JoinOut, u64, isize)>>>(a0, a1, tactic);
+                joined.probe_with(&probe);
+            } else {
+                c0.join(c1).inner.probe_with(&probe);
+            }
+            (left, right)
+        });
+
+        let start = Instant::now();
+        for k in 0..n {
+            left.update((k, k), 1);
+            right.update((k, 2 * k), 1);
+        }
+        left.advance_to(1);
+        right.advance_to(1);
+        left.flush();
+        right.flush();
+        while probe.less_than(left.time()) {
+            worker.step();
+        }
+        let load = start.elapsed();
+
+        // Warm up with unmeasured incremental rounds (see bench_reduce).
+        let warmup = 5_000;
+        let mut timer = Instant::now();
+        for t in 1..=(warmup + rounds) {
+            if t == warmup + 1 { timer = Instant::now(); }
+            left.update((t % 97, 100 + t), 1);
+            left.advance_to(t + 1);
+            right.advance_to(t + 1);
+            left.flush();
+            right.flush();
+            while probe.less_than(left.time()) {
+                worker.step();
+            }
+        }
+        (load, timer.elapsed())
+    })
+}
+
+#[test]
+#[ignore = "wall-clock benchmark; run --release with --ignored --nocapture"]
+fn bench_wall_clock_vs_row() {
+    for &n in &[10_000u64, 100_000, 1_000_000] {
+        let rounds = 1_000;
+        let (row_l, row_i) = bench_reduce(n, rounds, false);
+        let (px_l, px_i) = bench_reduce(n, rounds, true);
+        eprintln!(
+            "reduce n={n:>9}: load row {row_l:>10.2?} proxy {px_l:>10.2?} ({:>5.2}x) | {rounds} steady single-key rounds row {row_i:>10.2?} proxy {px_i:>10.2?} ({:>5.2}x)",
+            px_l.as_secs_f64() / row_l.as_secs_f64(),
+            px_i.as_secs_f64() / row_i.as_secs_f64(),
+        );
+        let (row_l, row_i) = bench_join(n, rounds, false);
+        let (px_l, px_i) = bench_join(n, rounds, true);
+        eprintln!(
+            "join   n={n:>9}: load row {row_l:>10.2?} proxy {px_l:>10.2?} ({:>5.2}x) | {rounds} steady single-key rounds row {row_i:>10.2?} proxy {px_i:>10.2?} ({:>5.2}x)",
+            px_l.as_secs_f64() / row_l.as_secs_f64(),
+            px_i.as_secs_f64() / row_i.as_secs_f64(),
+        );
+    }
+}

From 51cead79e0d13c68e75793a0900b861bee02da53 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 05:21:53 -0400
Subject: [PATCH 06/68] int_proxy: batch the reduce value callback per wave
 (reduce_many)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The longer-term goal for the boundary is fewer crossings into the
backend's value logic (interpreted or columnar execution pays per-call
overhead): each crossing should carry a list of keys and a longer
bracketed list of value entries.

ProxyReduceBackend gains reduce_many(keys, ends, input) — group_offsets
-shaped brackets, one per key, each non-empty — returning concatenated
per-key outputs with their own bracket ends. A default implementation
loops the per-key reduce, so simple backends implement only that;
backends with bulk value logic override reduce_many.

The tactic now calls only reduce_many: retire's key-major loop becomes
two passes — derive each changed key's active times, group the work
into waves by time, then play the waves in ascending order (Ord extends
the partial order, so a key's earlier deltas always precede a later
time's reads) with at most one callback per wave, batching every key
active at that time.

The identity backend overrides reduce_many (asserting the bracket
protocol from the backend's seat), so the grid-oracle fuzz exercises
the batched path; the reference backend uses the default, so the
row-comparison tests cover the loop. All gates and benches unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/mod.rs            |   4 +-
 .../src/operators/int_proxy/reduce.rs         | 151 ++++++++++++++----
 differential-dataflow/tests/int_proxy.rs      |  22 +++
 3 files changed, 145 insertions(+), 32 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/mod.rs b/differential-dataflow/src/operators/int_proxy/mod.rs
index 7835b37c0..b98fb4933 100644
--- a/differential-dataflow/src/operators/int_proxy/mod.rs
+++ b/differential-dataflow/src/operators/int_proxy/mod.rs
@@ -12,7 +12,9 @@
 //!   into the presented run*.
 //! * **Write side.** Reduce produces `((key_hash, value_id), time, diff)` deltas. The
 //!   `key_hash` is carried from the input key; output `value_id`s are *minted by hashing
-//!   the produced value* ([`ProxyReduceBackend::reduce`]), and the backend's
+//!   the produced value* ([`ProxyReduceBackend::reduce`] — batched per wave of active
+//!   keys as [`reduce_many`](ProxyReduceBackend::reduce_many), so a backend whose value
+//!   logic is interpreted or columnar pays one crossing per wave, not per key), and the backend's
 //!   [`materialize`](ProxyReduceBackend::materialize) seals the proxy records into a real
 //!   output batch — a real arrangement, fit to be a downstream operator's input, where
 //!   the same value presents with the same id because the id *is* its content hash.
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index 1b7c4ee0b..ffbd3f0e3 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -15,10 +15,11 @@ use crate::operators::reduce::ReduceTactic;
 /// The reduce backend: value semantics for a proxy-space reduction.
 ///
 /// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `key_hashes` (over the
-/// new input batches), one `present_input`, one `present_output`, any number of `reduce`
-/// calls whose indices refer to the input presentation, then one `materialize` per output
-/// batch. Within one retire the backend must be able to resolve every presented
-/// `key_hash` to its key and every presented or minted `value_id` to its value.
+/// new input batches), one `present_input`, one `present_output`, one `reduce_many` call
+/// per distinct interesting time — batching every key active at that time, with indices
+/// referring to the input presentation — then one `materialize` per output batch. Within
+/// one retire the backend must be able to resolve every presented `key_hash` to its key
+/// and every presented or minted `value_id` to its value.
 pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
     /// Diff type presented for the input.
     type RIn: Semigroup;
@@ -47,6 +48,28 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// [`present_output`](Self::present_output) on equal values within this retire — and
     /// recording `id → value` for `materialize`.
     fn reduce(&mut self, key_hash: u64, input: &[(usize, Self::RIn)]) -> Vec<(u64, Self::ROut)>;
+    /// (value callback, batched) As [`reduce`](Self::reduce), for a run of keys in one
+    /// call: `keys[i]`'s accumulated input is `input[ends[i-1]..ends[i]]` (with
+    /// `ends[-1] = 0`), every bracket non-empty. Returns the concatenated per-key outputs
+    /// together with their own bracket ends, aligned with `keys`.
+    ///
+    /// This is the boundary's bulk crossing: the tactic calls only this method, batching
+    /// all keys that share an interesting time, so a backend whose value logic crosses
+    /// into interpreted or columnar execution (where per-call overhead dominates) can do
+    /// a whole wave's work per crossing. The default implementation loops
+    /// [`reduce`](Self::reduce); backends with cheap native per-key logic need not
+    /// override it.
+    fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, Self::RIn)]) -> (Vec<(u64, Self::ROut)>, Vec<usize>) {
+        let mut outs = Vec::new();
+        let mut out_ends = Vec::with_capacity(keys.len());
+        let mut start = 0;
+        for (i, &key) in keys.iter().enumerate() {
+            outs.extend(self.reduce(key, &input[start..ends[i]]));
+            out_ends.push(outs.len());
+            start = ends[i];
+        }
+        (outs, out_ends)
+    }
     /// (egress) Seal proxy-space output records into a real output batch: resolve each
     /// record's `key_hash` and `value_id` to real data, order by the backend's own record
     /// order, and build the batch with the given description. `records` may be empty (the
@@ -59,11 +82,14 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
 ///
 /// Per changed key (keys touched by new input, plus keys carrying pending times) it
 /// derives the active times in `[lower, upper)` — joins of input times, seeded by the
-/// novel times — and at each, consolidates the input by `value_id` (presence), asks the
-/// backend for the desired output, subtracts the current output (committed history plus
-/// deltas emitted this pass), and emits the difference into the held-time bucket. Times
-/// at or beyond `upper` are pended, keyed by the stable `key_hash`, so they survive
-/// retires without any reference to backend state.
+/// novel times — and groups the work into *waves*: at each distinct time, every active
+/// key's input is consolidated by `value_id` (presence) and the whole wave is handed to
+/// the backend in one batched value callback ([`ProxyReduceBackend::reduce_many`]) — one
+/// crossing into the backend's value logic per wave. Each key's desired output is then
+/// diffed against its current output (committed history plus deltas emitted this pass)
+/// and the difference emitted into the held-time bucket. Times at or beyond `upper` are
+/// pended, keyed by the stable `key_hash`, so they survive retires without any reference
+/// to backend state.
 pub struct ProxyReduceTactic<T, Bk> {
     backend: Bk,
     /// Outstanding interesting `(key, time)` moments at or beyond the last interval,
@@ -150,8 +176,20 @@ where
 
         let mut new_pending: BTreeMap<u64, Vec<B1::Time>> = BTreeMap::new();
 
-        // March through the changed keys; both presentations hold only changed keys, in
-        // hash order, so the ranges advance monotonically.
+        // Pass 1: march through the changed keys — both presentations hold only changed
+        // keys, in hash order, so the ranges advance monotonically — derive each key's
+        // active times, and group the work into WAVES: all keys active at a time are
+        // handled by one batched value callback, so a whole wave costs one crossing into
+        // the backend's value logic.
+        struct Plan {
+            key: u64,
+            i0: usize,
+            i1: usize,
+            o0: usize,
+            o1: usize,
+        }
+        let mut plans: Vec<Plan> = Vec::new();
+        let mut waves: BTreeMap<B1::Time, Vec<usize>> = BTreeMap::new();
         let (mut is, mut os) = (0usize, 0usize);
         for &key in &changed {
             while is < p_in.len() && p_in.key_hashes()[is] < key { is += 1; }
@@ -190,19 +228,40 @@ where
             if active.is_empty() {
                 continue;
             }
-
-            // Deltas emitted for this key earlier in this pass; part of "current output".
-            let mut emitted: Vec<(u64, B1::Time, Bk::ROut)> = Vec::new();
+            let index = plans.len();
+            plans.push(Plan { key, i0, i1, o0, o1 });
             for t in active {
-                // Input accumulation at `t`, consolidated by value id: the key's records
-                // are sorted by (value_id, time), so each id is one contiguous run.
+                waves.entry(t).or_default().push(index);
+            }
+        }
+
+        // Deltas emitted per key earlier in this pass; part of "current output".
+        let mut emitted: Vec<Vec<(u64, B1::Time, Bk::ROut)>> = (0..plans.len()).map(|_| Vec::new()).collect();
+
+        // Pass 2: play the waves in ascending time order — `Ord` extends the partial
+        // order, so a key's earlier deltas are always emitted before a later time
+        // consults them. Each wave makes at most one (batched) value callback.
+        for (t, members) in waves {
+            // Assemble the batch: per member, the input accumulation at `t` consolidated
+            // by value id (each key's records are sorted by (value_id, time), so each id
+            // is one contiguous run) and the current output at `t` (committed history
+            // plus this pass's deltas). Members with empty accumulation skip the callback
+            // — the row reduce contract consults logic only for non-empty input — and go
+            // straight to retracting `cur`.
+            let mut keys_v: Vec<u64> = Vec::new();
+            let mut ends: Vec<usize> = Vec::new();
+            let mut entries: Vec<(usize, Bk::RIn)> = Vec::new();
+            let mut batched: Vec<(usize, BTreeMap<u64, Bk::ROut>)> = Vec::new();
+            let mut retract_only: Vec<(usize, BTreeMap<u64, Bk::ROut>)> = Vec::new();
+            for &pi in &members {
+                let plan = &plans[pi];
                 let mut acc: Vec<(usize, Bk::RIn)> = Vec::new();
-                let mut a = i0;
-                while a < i1 {
+                let mut a = plan.i0;
+                while a < plan.i1 {
                     let vid = p_in.value_ids()[a];
                     let rep = a;
                     let mut net: Option<Bk::RIn> = None;
-                    while a < i1 && p_in.value_ids()[a] == vid {
+                    while a < plan.i1 && p_in.value_ids()[a] == vid {
                         if p_in.times()[a].less_equal(&t) {
                             match net.as_mut() {
                                 Some(n) => n.plus_equals(&p_in.diffs()[a]),
@@ -218,9 +277,8 @@ where
                     }
                 }
 
-                // Current output at `t`: committed history plus this pass's deltas.
                 let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
-                for o in o0..o1 {
+                for o in plan.o0..plan.o1 {
                     if p_out.times()[o].less_equal(&t) {
                         match cur.entry(p_out.value_ids()[o]) {
                             std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&p_out.diffs()[o]),
@@ -228,7 +286,7 @@ where
                         }
                     }
                 }
-                for (vid, et, d) in emitted.iter() {
+                for (vid, et, d) in emitted[pi].iter() {
                     if et.less_equal(&t) {
                         match cur.entry(*vid) {
                             std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
@@ -241,31 +299,62 @@ where
                 if acc.is_empty() && cur.is_empty() {
                     continue;
                 }
-                // The desired output; the value callback is only consulted for non-empty
-                // input (matching the row reduce contract) — an empty accumulation's
-                // desired output is empty, and the delta below retracts `cur`.
-                let desired = if acc.is_empty() { Vec::new() } else { self.backend.reduce(key, &acc) };
+                if acc.is_empty() {
+                    retract_only.push((pi, cur));
+                } else {
+                    keys_v.push(plan.key);
+                    entries.extend(acc);
+                    ends.push(entries.len());
+                    batched.push((pi, cur));
+                }
+            }
+
+            // One crossing for the whole wave.
+            let (outs, out_ends) = if keys_v.is_empty() {
+                (Vec::new(), Vec::new())
+            } else {
+                self.backend.reduce_many(&keys_v, &ends, &entries)
+            };
 
-                // delta = desired − current, in proxy space.
+            // delta = desired − current, in proxy space, routed to the held-time bucket.
+            let mut start = 0;
+            let desired_of = |lo: usize, hi: usize| outs[lo..hi].iter().cloned();
+            for (m, (pi, cur)) in batched.into_iter().enumerate() {
+                let end = out_ends[m];
                 let mut delta: BTreeMap<u64, Bk::ROut> = cur;
                 for d in delta.values_mut() {
                     d.negate();
                 }
-                for (vid, d) in desired {
+                for (vid, d) in desired_of(start, end) {
                     match delta.entry(vid) {
                         std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
                         std::collections::btree_map::Entry::Vacant(e) => { e.insert(d); }
                     }
                 }
+                start = end;
+                delta.retain(|_, d| !d.is_zero());
+                if delta.is_empty() {
+                    continue;
+                }
+                let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
+                for (vid, d) in delta {
+                    emitted[pi].push((vid, t.clone(), d.clone()));
+                    buckets[idx].push(((plans[pi].key, vid), t.clone(), d));
+                }
+            }
+            for (pi, cur) in retract_only {
+                let mut delta = cur;
+                for d in delta.values_mut() {
+                    d.negate();
+                }
                 delta.retain(|_, d| !d.is_zero());
                 if delta.is_empty() {
                     continue;
                 }
-
                 let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
                 for (vid, d) in delta {
-                    emitted.push((vid, t.clone(), d.clone()));
-                    buckets[idx].push(((key, vid), t.clone(), d));
+                    emitted[pi].push((vid, t.clone(), d.clone()));
+                    buckets[idx].push(((plans[pi].key, vid), t.clone(), d));
                 }
             }
         }
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index 3c4a80181..a89060530 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -391,6 +391,9 @@ where
     fn reduce(&mut self, key_hash: u64, input: &[(usize, B::RIn)]) -> Vec<(u64, B::ROut)> {
         self.inner.reduce(key_hash, input)
     }
+    fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, B::RIn)]) -> (Vec<(u64, B::ROut)>, Vec<usize>) {
+        self.inner.reduce_many(keys, ends, input)
+    }
     fn materialize(&mut self, records: ProxyChunk<B1::Time, B::ROut>, description: Description<B1::Time>) -> B2 {
         self.inner.materialize(records, description)
     }
@@ -643,6 +646,25 @@ mod identity {
             (self.logic)(&pairs)
         }
 
+        // Override the batched form (a stand-in for one bulk crossing into columnar
+        // logic), asserting the bracket protocol from the backend's seat, so the fuzz
+        // exercises the wave-batched path rather than the per-key default.
+        fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, isize)]) -> (Vec<(u64, isize)>, Vec<usize>) {
+            assert_eq!(keys.len(), ends.len(), "one bracket end per key");
+            assert!(ends.windows(2).all(|w| w[0] < w[1]), "brackets non-empty and increasing");
+            assert_eq!(ends.last().copied().unwrap_or(0), input.len(), "brackets cover the input");
+            let mut outs = Vec::new();
+            let mut out_ends = Vec::with_capacity(keys.len());
+            let mut start = 0;
+            for &end in ends {
+                let pairs: Vec<(u64, isize)> = input[start..end].iter().map(|&(i, d)| (self.current.value_ids()[i], d)).collect();
+                outs.extend((self.logic)(&pairs));
+                out_ends.push(outs.len());
+                start = end;
+            }
+            (outs, out_ends)
+        }
+
         fn materialize(&mut self, chunk: ProxyChunk<T, isize>, description: Description<T>) -> Batch<T> {
             // The proxy records ARE the output records: the output arrangement is proxy
             // chunks (incidentally exercising `ChunkBatch<ProxyChunk>` as a real batch).

From 592b3339f6b1cb84214f7aaca7e45723b1e1a252 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 05:27:56 -0400
Subject: [PATCH 07/68] int_proxy: one value-callback crossing per retire, not
 per wave
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The desired output at a (key, time) moment is a function of the key's
input accumulation at that time alone — no output-side state — so no
time ordering constrains the batch: every moment of the retire can
share one reduce_many call, a key contributing one bracket per active
time. The order-sensitive part (subtracting the current output, which
includes deltas emitted at earlier moments) is pure proxy-space
arithmetic and moves to a separate pass that plays the moments in
ascending time order.

The bracket, not the key, is reduce_many's unit: keys may repeat.
Contract docs updated accordingly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/mod.rs            |   7 +-
 .../src/operators/int_proxy/reduce.rs         | 206 +++++++++---------
 2 files changed, 102 insertions(+), 111 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/mod.rs b/differential-dataflow/src/operators/int_proxy/mod.rs
index b98fb4933..bffc1e1aa 100644
--- a/differential-dataflow/src/operators/int_proxy/mod.rs
+++ b/differential-dataflow/src/operators/int_proxy/mod.rs
@@ -12,9 +12,10 @@
 //!   into the presented run*.
 //! * **Write side.** Reduce produces `((key_hash, value_id), time, diff)` deltas. The
 //!   `key_hash` is carried from the input key; output `value_id`s are *minted by hashing
-//!   the produced value* ([`ProxyReduceBackend::reduce`] — batched per wave of active
-//!   keys as [`reduce_many`](ProxyReduceBackend::reduce_many), so a backend whose value
-//!   logic is interpreted or columnar pays one crossing per wave, not per key), and the backend's
+//!   the produced value* ([`ProxyReduceBackend::reduce`] — batched across every
+//!   `(key, time)` moment as [`reduce_many`](ProxyReduceBackend::reduce_many), so a
+//!   backend whose value logic is interpreted or columnar pays one crossing per
+//!   *retire*, not per key), and the backend's
 //!   [`materialize`](ProxyReduceBackend::materialize) seals the proxy records into a real
 //!   output batch — a real arrangement, fit to be a downstream operator's input, where
 //!   the same value presents with the same id because the id *is* its content hash.
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index ffbd3f0e3..4679f5233 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -48,17 +48,20 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// [`present_output`](Self::present_output) on equal values within this retire — and
     /// recording `id → value` for `materialize`.
     fn reduce(&mut self, key_hash: u64, input: &[(usize, Self::RIn)]) -> Vec<(u64, Self::ROut)>;
-    /// (value callback, batched) As [`reduce`](Self::reduce), for a run of keys in one
-    /// call: `keys[i]`'s accumulated input is `input[ends[i-1]..ends[i]]` (with
-    /// `ends[-1] = 0`), every bracket non-empty. Returns the concatenated per-key outputs
-    /// together with their own bracket ends, aligned with `keys`.
+    /// (value callback, batched) As [`reduce`](Self::reduce), for a run of brackets in
+    /// one call: bracket `i` is the accumulated input `input[ends[i-1]..ends[i]]` (with
+    /// `ends[-1] = 0`, every bracket non-empty) for `keys[i]` — and a key may appear
+    /// several times, once per moment the tactic evaluates it at (the bracket is the
+    /// unit, not the key). Returns the concatenated per-bracket outputs together with
+    /// their own bracket ends, aligned with `keys`.
     ///
-    /// This is the boundary's bulk crossing: the tactic calls only this method, batching
-    /// all keys that share an interesting time, so a backend whose value logic crosses
-    /// into interpreted or columnar execution (where per-call overhead dominates) can do
-    /// a whole wave's work per crossing. The default implementation loops
-    /// [`reduce`](Self::reduce); backends with cheap native per-key logic need not
-    /// override it.
+    /// This is the boundary's bulk crossing: the tactic calls this method once per
+    /// retire, with every `(key, interesting time)` moment as a bracket — desired
+    /// outputs depend only on input accumulations, so no time ordering constrains the
+    /// batch — and a backend whose value logic crosses into interpreted or columnar
+    /// execution (where per-call overhead dominates) does the whole retire's value work
+    /// in one crossing. The default implementation loops [`reduce`](Self::reduce);
+    /// backends with cheap native per-key logic need not override it.
     fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, Self::RIn)]) -> (Vec<(u64, Self::ROut)>, Vec<usize>) {
         let mut outs = Vec::new();
         let mut out_ends = Vec::with_capacity(keys.len());
@@ -82,14 +85,15 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
 ///
 /// Per changed key (keys touched by new input, plus keys carrying pending times) it
 /// derives the active times in `[lower, upper)` — joins of input times, seeded by the
-/// novel times — and groups the work into *waves*: at each distinct time, every active
-/// key's input is consolidated by `value_id` (presence) and the whole wave is handed to
-/// the backend in one batched value callback ([`ProxyReduceBackend::reduce_many`]) — one
-/// crossing into the backend's value logic per wave. Each key's desired output is then
-/// diffed against its current output (committed history plus deltas emitted this pass)
-/// and the difference emitted into the held-time bucket. Times at or beyond `upper` are
-/// pended, keyed by the stable `key_hash`, so they survive retires without any reference
-/// to backend state.
+/// novel times — consolidates each `(key, active time)` moment's input by `value_id`
+/// (presence), and hands ALL moments to the backend in one batched value callback per
+/// retire ([`ProxyReduceBackend::reduce_many`]): desired outputs depend only on input
+/// accumulations, so the batch needs no time ordering. Each moment's desired output is
+/// then diffed against its current output (committed history plus deltas emitted at
+/// earlier moments — the order-sensitive part, kept in proxy space) and the difference
+/// emitted into the held-time bucket. Times at or beyond `upper` are pended, keyed by
+/// the stable `key_hash`, so they survive retires without any reference to backend
+/// state.
 pub struct ProxyReduceTactic<T, Bk> {
     backend: Bk,
     /// Outstanding interesting `(key, time)` moments at or beyond the last interval,
@@ -178,9 +182,8 @@ where
 
         // Pass 1: march through the changed keys — both presentations hold only changed
         // keys, in hash order, so the ranges advance monotonically — derive each key's
-        // active times, and group the work into WAVES: all keys active at a time are
-        // handled by one batched value callback, so a whole wave costs one crossing into
-        // the backend's value logic.
+        // active times, and collect the `(key, time)` moments (grouped by time, so the
+        // later passes run in ascending time order).
         struct Plan {
             key: u64,
             i0: usize,
@@ -235,27 +238,28 @@ where
             }
         }
 
-        // Deltas emitted per key earlier in this pass; part of "current output".
-        let mut emitted: Vec<Vec<(u64, B1::Time, Bk::ROut)>> = (0..plans.len()).map(|_| Vec::new()).collect();
-
-        // Pass 2: play the waves in ascending time order — `Ord` extends the partial
-        // order, so a key's earlier deltas are always emitted before a later time
-        // consults them. Each wave makes at most one (batched) value callback.
+        // Pass 2a: assemble ONE batched value callback for the whole retire. The desired
+        // output at a `(key, time)` moment is a function of the key's input accumulation
+        // at that time alone — no output-side state — so every moment can share one
+        // crossing into the backend's value logic; a key contributes one bracket per
+        // active time. The time-sensitive bookkeeping (subtracting the current output,
+        // which includes deltas emitted at earlier times) is pure proxy-space arithmetic
+        // and stays in pass 2b.
+        let mut keys_v: Vec<u64> = Vec::new();
+        let mut ends: Vec<usize> = Vec::new();
+        let mut entries: Vec<(usize, Bk::RIn)> = Vec::new();
+        // Every `(key, active time)` moment, in ascending time order, with its bracket
+        // index (`None` when the accumulation is empty: the callback is only consulted
+        // for non-empty input, matching the row reduce contract; the moment may still
+        // need to retract current output).
+        let mut moments: Vec<(usize, B1::Time, Option<usize>)> = Vec::new();
         for (t, members) in waves {
-            // Assemble the batch: per member, the input accumulation at `t` consolidated
-            // by value id (each key's records are sorted by (value_id, time), so each id
-            // is one contiguous run) and the current output at `t` (committed history
-            // plus this pass's deltas). Members with empty accumulation skip the callback
-            // — the row reduce contract consults logic only for non-empty input — and go
-            // straight to retracting `cur`.
-            let mut keys_v: Vec<u64> = Vec::new();
-            let mut ends: Vec<usize> = Vec::new();
-            let mut entries: Vec<(usize, Bk::RIn)> = Vec::new();
-            let mut batched: Vec<(usize, BTreeMap<u64, Bk::ROut>)> = Vec::new();
-            let mut retract_only: Vec<(usize, BTreeMap<u64, Bk::ROut>)> = Vec::new();
-            for &pi in &members {
+            for pi in members {
                 let plan = &plans[pi];
-                let mut acc: Vec<(usize, Bk::RIn)> = Vec::new();
+                // Input accumulation at `t`, consolidated by value id: the key's records
+                // are sorted by (value_id, time), so each id is one contiguous run.
+                let mut bracket = None;
+                let mut len = 0;
                 let mut a = plan.i0;
                 while a < plan.i1 {
                     let vid = p_in.value_ids()[a];
@@ -272,90 +276,76 @@ where
                     }
                     if let Some(n) = net {
                         if !n.is_zero() {
-                            acc.push((rep, n));
-                        }
-                    }
-                }
-
-                let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
-                for o in plan.o0..plan.o1 {
-                    if p_out.times()[o].less_equal(&t) {
-                        match cur.entry(p_out.value_ids()[o]) {
-                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&p_out.diffs()[o]),
-                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(p_out.diffs()[o].clone()); }
-                        }
-                    }
-                }
-                for (vid, et, d) in emitted[pi].iter() {
-                    if et.less_equal(&t) {
-                        match cur.entry(*vid) {
-                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
-                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(d.clone()); }
+                            entries.push((rep, n));
+                            len += 1;
                         }
                     }
                 }
-                cur.retain(|_, d| !d.is_zero());
-
-                if acc.is_empty() && cur.is_empty() {
-                    continue;
-                }
-                if acc.is_empty() {
-                    retract_only.push((pi, cur));
-                } else {
+                if len > 0 {
                     keys_v.push(plan.key);
-                    entries.extend(acc);
                     ends.push(entries.len());
-                    batched.push((pi, cur));
+                    bracket = Some(keys_v.len() - 1);
                 }
+                moments.push((pi, t.clone(), bracket));
             }
+        }
 
-            // One crossing for the whole wave.
-            let (outs, out_ends) = if keys_v.is_empty() {
-                (Vec::new(), Vec::new())
-            } else {
-                self.backend.reduce_many(&keys_v, &ends, &entries)
-            };
+        // The one crossing for this retire.
+        let (outs, out_ends) = if keys_v.is_empty() {
+            (Vec::new(), Vec::new())
+        } else {
+            self.backend.reduce_many(&keys_v, &ends, &entries)
+        };
 
-            // delta = desired − current, in proxy space, routed to the held-time bucket.
-            let mut start = 0;
-            let desired_of = |lo: usize, hi: usize| outs[lo..hi].iter().cloned();
-            for (m, (pi, cur)) in batched.into_iter().enumerate() {
-                let end = out_ends[m];
-                let mut delta: BTreeMap<u64, Bk::ROut> = cur;
-                for d in delta.values_mut() {
-                    d.negate();
+        // Pass 2b: play the moments in ascending time order — `Ord` extends the partial
+        // order, so a key's earlier deltas are always emitted before a later time reads
+        // them — computing delta = desired − current in proxy space and routing it to
+        // the held-time bucket.
+        let mut emitted: Vec<Vec<(u64, B1::Time, Bk::ROut)>> = (0..plans.len()).map(|_| Vec::new()).collect();
+        for (pi, t, bracket) in moments {
+            let plan = &plans[pi];
+            // Current output at `t`: committed history plus this pass's deltas.
+            let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
+            for o in plan.o0..plan.o1 {
+                if p_out.times()[o].less_equal(&t) {
+                    match cur.entry(p_out.value_ids()[o]) {
+                        std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&p_out.diffs()[o]),
+                        std::collections::btree_map::Entry::Vacant(e) => { e.insert(p_out.diffs()[o].clone()); }
+                    }
                 }
-                for (vid, d) in desired_of(start, end) {
+            }
+            for (vid, et, d) in emitted[pi].iter() {
+                if et.less_equal(&t) {
+                    match cur.entry(*vid) {
+                        std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
+                        std::collections::btree_map::Entry::Vacant(e) => { e.insert(d.clone()); }
+                    }
+                }
+            }
+            cur.retain(|_, d| !d.is_zero());
+
+            let mut delta: BTreeMap<u64, Bk::ROut> = cur;
+            for d in delta.values_mut() {
+                d.negate();
+            }
+            if let Some(b) = bracket {
+                let lo = if b == 0 { 0 } else { out_ends[b - 1] };
+                for (vid, d) in outs[lo..out_ends[b]].iter().cloned() {
                     match delta.entry(vid) {
                         std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
                         std::collections::btree_map::Entry::Vacant(e) => { e.insert(d); }
                     }
                 }
-                start = end;
-                delta.retain(|_, d| !d.is_zero());
-                if delta.is_empty() {
-                    continue;
-                }
-                let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
-                for (vid, d) in delta {
-                    emitted[pi].push((vid, t.clone(), d.clone()));
-                    buckets[idx].push(((plans[pi].key, vid), t.clone(), d));
-                }
             }
-            for (pi, cur) in retract_only {
-                let mut delta = cur;
-                for d in delta.values_mut() {
-                    d.negate();
-                }
-                delta.retain(|_, d| !d.is_zero());
-                if delta.is_empty() {
-                    continue;
-                }
-                let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
-                for (vid, d) in delta {
-                    emitted[pi].push((vid, t.clone(), d.clone()));
-                    buckets[idx].push(((plans[pi].key, vid), t.clone(), d));
-                }
+            delta.retain(|_, d| !d.is_zero());
+            if delta.is_empty() {
+                continue;
+            }
+
+            let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
+            for (vid, d) in delta {
+                emitted[pi].push((vid, t.clone(), d.clone()));
+                buckets[idx].push(((plan.key, vid), t.clone(), d));
             }
         }
 

From 59111c27c4178d386990a5de51a23dd363dfcec9 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 05:53:14 -0400
Subject: [PATCH 08/68] =?UTF-8?q?int=5Fproxy:=20port=20the=20history-repla?=
 =?UTF-8?q?y=20machinery=20=E2=80=94=20the=20scaling=20shapes=20go=20linea?=
 =?UTF-8?q?r?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The row suite's reduce_scaling/join_scaling shapes (one key, many
distinct times, one batch) exposed quadratic behavior in both proxy
tactics: reduce rescanned a key's full presented range per interesting
time (and its interesting-time closure joined all pairs), and join
cross-produced full matched histories pairwise. Measured: reduce 6.4s
at scale 10k, 4.7x per doubling; join 9.8s at 10k, >90s at 20k.

The robust versions are the cursor variants with integers in place of
keys and values, as intended:

- history.rs: IdHistory, the id-space ValueHistory — (value_id, time,
  diff) edits replayed in ascending time order into a buffer repeatedly
  advanced by the meet of the times still to come and consolidated.
  The advancement is the collapse that keeps a key with many distinct
  times linear: accumulations read the small buffer, never the raw
  history. The presentations serve as the fused per-key load.
- reduce: discover_and_accumulate ports history_replay::compute —
  lazy interesting-time discovery (novel and pending seed; synthetics
  from joins with the advanced batch buffer and times_current) replaces
  the eager join-closure, and per-moment accumulation reads the
  advanced buffers. Phase B replays the output side per key over the
  discovered moments with the same machinery (suffix meets; emitted
  deltas advanced and consolidated). Still one batched reduce_many
  crossing per retire.
- join: join_key ports JoinThinker::think — each side's edits replayed
  against the other side's advanced buffer (identical emitted times:
  t0 ∨ (t1 ∨ meet) = t0 ∨ t1), with the dead-simple cross product kept
  for small histories.

proxy_reduce_scaling / proxy_join_scaling (scale 100k, the row tests'
shapes) now pin this; scale 10k dropped from seconds to milliseconds
and growth is ~4x per 4x scale. The grid-oracle fuzz over partially
ordered times, the scripted pending test, the row comparisons, the
delta-proportionality gates, and the steady-state bench all pass
unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/history.rs        |  99 ++++
 .../src/operators/int_proxy/join.rs           | 122 ++++-
 .../src/operators/int_proxy/mod.rs            |   2 +
 .../src/operators/int_proxy/reduce.rs         | 432 +++++++++++-------
 differential-dataflow/tests/int_proxy.rs      |  69 +++
 5 files changed, 558 insertions(+), 166 deletions(-)
 create mode 100644 differential-dataflow/src/operators/int_proxy/history.rs

diff --git a/differential-dataflow/src/operators/int_proxy/history.rs b/differential-dataflow/src/operators/int_proxy/history.rs
new file mode 100644
index 000000000..2636d3371
--- /dev/null
+++ b/differential-dataflow/src/operators/int_proxy/history.rs
@@ -0,0 +1,99 @@
+//! Time-ordered replay of proxy update histories, with meet-advancement.
+//!
+//! The id-space port of the cursor tactics' [`ValueHistory`] machinery: a run of
+//! `(value_id, time, diff)` edits is replayed in ascending time order, stepping edits
+//! into a working buffer that is repeatedly *advanced* — times joined with the meet of
+//! the times still to be considered — and consolidated. Advancement is what keeps the
+//! buffer collapsed (for totally ordered times, a whole prefix folds to a single time
+//! per value id), which is what keeps a key with many distinct times linear instead of
+//! quadratic: accumulations read the small buffer, never the raw history.
+//!
+//! [`ValueHistory`]: crate::operators::ValueHistory (private; see `operators/mod.rs`)
+
+use crate::difference::Semigroup;
+use crate::lattice::Lattice;
+
+/// A replayable history of `(value_id, time, diff)` edits.
+pub(crate) struct IdHistory<T, R> {
+    /// Un-replayed edits as `(time, meet, value_id, diff)`, sorted descending by
+    /// `(time, value_id)` so popping replays ascending; `meet` is the meet of this
+    /// edit's time with all times later in the replay (i.e. of the remaining suffix).
+    history: Vec<(T, T, u64, R)>,
+    /// Stepped-in edits, advanced and consolidated: `((value_id, time), diff)`, sorted.
+    buffer: Vec<((u64, T), R)>,
+}
+
+impl<T: Lattice + Clone + Ord, R: Semigroup + Clone> IdHistory<T, R> {
+    pub fn new() -> Self {
+        IdHistory { history: Vec::new(), buffer: Vec::new() }
+    }
+
+    /// Load `edits`, advancing each time by `advance_by` if supplied, and organize the
+    /// replay (sort + suffix meets).
+    pub fn load(&mut self, edits: impl Iterator<Item = (u64, T, R)>, advance_by: Option<&T>) {
+        self.history.clear();
+        self.buffer.clear();
+        for (vid, mut time, diff) in edits {
+            if let Some(m) = advance_by {
+                time = time.join(m);
+            }
+            self.history.push((time.clone(), time, vid, diff));
+        }
+        self.history.sort_by(|x, y| (&y.0, y.2).cmp(&(&x.0, x.2)));
+        self.history.iter_mut().reduce(|prev, cur| {
+            cur.1.meet_assign(&prev.1);
+            cur
+        });
+    }
+
+    /// The next (least) un-replayed time.
+    pub fn time(&self) -> Option<&T> {
+        self.history.last().map(|x| &x.0)
+    }
+    /// The meet of all un-replayed times.
+    pub fn meet(&self) -> Option<&T> {
+        self.history.last().map(|x| &x.1)
+    }
+    /// The next un-replayed edit, as `(value_id, time, diff)`.
+    pub fn edit(&self) -> Option<(u64, &T, &R)> {
+        self.history.last().map(|(t, _, v, d)| (*v, t, d))
+    }
+
+    /// Move the next edit into the buffer.
+    pub fn step(&mut self) {
+        let (time, _, vid, diff) = self.history.pop().unwrap();
+        self.buffer.push(((vid, time), diff));
+    }
+    /// Step edits while the next time equals `time`; true iff any did.
+    pub fn step_while_time_is(&mut self, time: &T) -> bool {
+        let mut found = false;
+        while self.time() == Some(time) {
+            found = true;
+            self.step();
+        }
+        found
+    }
+    /// Step edits while the next time is at most `time` in the *total* order (a
+    /// superset of the partially-ordered downset; readers filter the buffer by
+    /// `less_equal` themselves).
+    pub fn step_through(&mut self, time: &T) {
+        while self.time().is_some_and(|t| t <= time) {
+            self.step();
+        }
+    }
+
+    /// Advance buffered times by `meet` and consolidate — the collapse that keeps
+    /// replay linear.
+    pub fn advance_buffer_by(&mut self, meet: &T) {
+        for ((_, time), _) in self.buffer.iter_mut() {
+            *time = time.join(meet);
+        }
+        crate::consolidation::consolidate(&mut self.buffer);
+    }
+
+    /// The buffered (stepped-in, advanced, consolidated) edits.
+    pub fn buffer(&self) -> &[((u64, T), R)] {
+        &self.buffer
+    }
+
+}
diff --git a/differential-dataflow/src/operators/int_proxy/join.rs b/differential-dataflow/src/operators/int_proxy/join.rs
index 18e31ff9d..6d26ebb9d 100644
--- a/differential-dataflow/src/operators/int_proxy/join.rs
+++ b/differential-dataflow/src/operators/int_proxy/join.rs
@@ -6,12 +6,16 @@ use timely::ContainerBuilder;
 use timely::dataflow::operators::Capability;
 use timely::dataflow::operators::generic::OutputBuilderSession;
 
+use timely::progress::Timestamp;
+
 use crate::difference::{Multiply, Semigroup};
 use crate::lattice::Lattice;
 use crate::trace::BatchReader;
 use crate::trace::chunk::int_proxy::ProxyChunk;
 use crate::operators::join::{EffortBuilder, Fresh, JoinTactic};
 
+use super::history::IdHistory;
+
 /// The join backend: value semantics for a proxy-space equijoin.
 ///
 /// Protocol (per deferred work unit, driven by [`ProxyJoinTactic`]): one `present0`, one
@@ -145,14 +149,7 @@ where
             while e0 < k0.len() && k0[e0] == key { e0 += 1; }
             let mut e1 = j;
             while e1 < k1.len() && k1[e1] == key { e1 += 1; }
-            for a in i..e0 {
-                for b in j..e1 {
-                    li.push(a);
-                    ri.push(b);
-                    ot.push(p0.times()[a].join(&p1.times()[b]));
-                    od.push(p0.diffs()[a].clone().multiply(&p1.diffs()[b]));
-                }
-            }
+            join_key(&p0, i..e0, &p1, j..e1, &mut li, &mut ri, &mut ot, &mut od);
             i = e0;
             j = e1;
         }
@@ -161,3 +158,112 @@ where
     let mut container = backend.cross(&li, &ri, ot, od);
     output.session_with_builder(&unit.capability).give_container(&mut container);
 }
+
+/// Match one key's records across the two presented runs.
+///
+/// For reasonably sized histories, the dead-simple cross product. For larger ones, the
+/// [`JoinThinker`]'s replay (ported to proxy space): both sides' edits are replayed in
+/// ascending time order, each edit joined against the *other* side's accumulated buffer,
+/// which is repeatedly advanced by the meet of the times still to come and consolidated —
+/// so a key whose two histories carry many distinct times costs the histories' sum times
+/// the buffer width, not their product. Emitted times are identical either way
+/// (`t0 ∨ (t1 ∨ meet) = t0 ∨ t1` since `meet ≤ t0`), and consolidation only pre-sums
+/// diffs whose product terms would have consolidated downstream.
+///
+/// Matched records reach the backend as representative indices per `value_id` (equal ids
+/// denote equal values, so any representative serves the projection).
+///
+/// [`JoinThinker`]: crate::operators::join (private; see the cursor tactic)
+#[allow(clippy::too_many_arguments)]
+fn join_key<T, R0, R1, RO>(
+    p0: &ProxyChunk<T, R0>,
+    r0: std::ops::Range<usize>,
+    p1: &ProxyChunk<T, R1>,
+    r1: std::ops::Range<usize>,
+    li: &mut Vec<usize>,
+    ri: &mut Vec<usize>,
+    ot: &mut Vec<T>,
+    od: &mut Vec<RO>,
+) where
+    T: Lattice + Timestamp,
+    R0: Semigroup + Multiply<R1, Output = RO> + Clone,
+    R1: Semigroup + Clone,
+{
+    if r0.len() < 16 || r1.len() < 16 {
+        for a in r0 {
+            for b in r1.clone() {
+                li.push(a);
+                ri.push(b);
+                ot.push(p0.times()[a].join(&p1.times()[b]));
+                od.push(p0.diffs()[a].clone().multiply(&p1.diffs()[b]));
+            }
+        }
+        return;
+    }
+
+    // value_id → representative record index, per side (each side's records are sorted
+    // by (value_id, time) within the key).
+    let rep = |p_vids: &[u64], range: std::ops::Range<usize>| {
+        let mut rep: Vec<(u64, usize)> = Vec::new();
+        for i in range {
+            if rep.last().is_none_or(|(v, _)| *v != p_vids[i]) {
+                rep.push((p_vids[i], i));
+            }
+        }
+        rep
+    };
+    let rep0 = rep(p0.value_ids(), r0.clone());
+    let rep1 = rep(p1.value_ids(), r1.clone());
+    let find = |rep: &[(u64, usize)], vid: u64| rep[rep.binary_search_by_key(&vid, |x| x.0).expect("vid presented")].1;
+
+    let mut h0: IdHistory<T, R0> = IdHistory::new();
+    h0.load(r0.map(|i| (p0.value_ids()[i], p0.times()[i].clone(), p0.diffs()[i].clone())), None);
+    let mut h1: IdHistory<T, R1> = IdHistory::new();
+    h1.load(r1.map(|i| (p1.value_ids()[i], p1.times()[i].clone(), p1.diffs()[i].clone())), None);
+
+    while h0.time().is_some() && h1.time().is_some() {
+        if h0.time().unwrap() < h1.time().unwrap() {
+            h1.advance_buffer_by(h0.meet().unwrap());
+            let (v0, t0, d0) = h0.edit().unwrap();
+            for ((v1, t1), d1) in h1.buffer() {
+                li.push(find(&rep0, v0));
+                ri.push(find(&rep1, *v1));
+                ot.push(t0.join(t1));
+                od.push(d0.clone().multiply(d1));
+            }
+            h0.step();
+        } else {
+            h0.advance_buffer_by(h1.meet().unwrap());
+            let (v1, t1, d1) = h1.edit().unwrap();
+            for ((v0, t0), d0) in h0.buffer() {
+                li.push(find(&rep0, *v0));
+                ri.push(find(&rep1, v1));
+                ot.push(t0.join(t1));
+                od.push(d0.clone().multiply(d1));
+            }
+            h1.step();
+        }
+    }
+    while h0.time().is_some() {
+        h1.advance_buffer_by(h0.meet().unwrap());
+        let (v0, t0, d0) = h0.edit().unwrap();
+        for ((v1, t1), d1) in h1.buffer() {
+            li.push(find(&rep0, v0));
+            ri.push(find(&rep1, *v1));
+            ot.push(t0.join(t1));
+            od.push(d0.clone().multiply(d1));
+        }
+        h0.step();
+    }
+    while h1.time().is_some() {
+        h0.advance_buffer_by(h1.meet().unwrap());
+        let (v1, t1, d1) = h1.edit().unwrap();
+        for ((v0, t0), d0) in h0.buffer() {
+            li.push(find(&rep0, *v0));
+            ri.push(find(&rep1, v1));
+            ot.push(t0.join(t1));
+            od.push(d0.clone().multiply(d1));
+        }
+        h1.step();
+    }
+}
diff --git a/differential-dataflow/src/operators/int_proxy/mod.rs b/differential-dataflow/src/operators/int_proxy/mod.rs
index bffc1e1aa..75cca2988 100644
--- a/differential-dataflow/src/operators/int_proxy/mod.rs
+++ b/differential-dataflow/src/operators/int_proxy/mod.rs
@@ -102,6 +102,8 @@
 //! hashing, the value function, and building real columns from ids. The backend never
 //! sees a timestamp except as an opaque payload.
 
+mod history;
+
 pub mod join;
 pub mod reduce;
 pub mod reference;
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index 4679f5233..cd98ca344 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -4,7 +4,6 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use timely::PartialOrder;
 use timely::progress::{Antichain, Timestamp};
-use timely::progress::frontier::AntichainRef;
 
 use crate::difference::{Abelian, IsZero, Semigroup};
 use crate::lattice::Lattice;
@@ -12,12 +11,15 @@ use crate::trace::{BatchReader, Description};
 use crate::trace::chunk::int_proxy::ProxyChunk;
 use crate::operators::reduce::ReduceTactic;
 
+use super::history::IdHistory;
+
 /// The reduce backend: value semantics for a proxy-space reduction.
 ///
 /// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `key_hashes` (over the
-/// new input batches), one `present_input`, one `present_output`, one `reduce_many` call
-/// per distinct interesting time — batching every key active at that time, with indices
-/// referring to the input presentation — then one `materialize` per output batch. Within
+/// new input batches), one `present_input`, one `present_output`, ONE batched
+/// `reduce_many` call carrying every `(key, interesting time)` moment of the retire —
+/// with indices referring to the input presentation — then one `materialize` per output
+/// batch. Within
 /// one retire the backend must be able to resolve every presented `key_hash` to its key
 /// and every presented or minted `value_id` to its value.
 pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
@@ -108,32 +110,6 @@ impl<T, Bk> ProxyReduceTactic<T, Bk> {
     }
 }
 
-/// The active times for an interval `[lower, upper)`: joins of input times (`novel` +
-/// `prior`) reachable from the `novel` seeds that are not at or beyond `upper`; those at
-/// or beyond are `pended` for a future interval. Over-derivation is sound (a non-changing
-/// time yields a zero delta).
-fn active_times<T: Lattice + Ord + Clone>(
-    upper: AntichainRef<T>,
-    prior: &[T],
-    novel: &[T],
-    active: &mut BTreeSet<T>,
-    pended: &mut BTreeSet<T>,
-) {
-    let mut todo: BTreeSet<T> = novel.iter().cloned().collect();
-    while let Some(next) = todo.pop_first() {
-        if upper.less_equal(&next) {
-            pended.insert(next);
-        } else if active.insert(next.clone()) {
-            for t in novel.iter().chain(prior.iter()) {
-                let join = next.join(t);
-                if !active.contains(&join) {
-                    todo.insert(join);
-                }
-            }
-        }
-    }
-}
-
 impl<B1, B2, Bk> ReduceTactic<B1, B2> for ProxyReduceTactic<B1::Time, Bk>
 where
     B1: BatchReader,
@@ -180,19 +156,27 @@ where
 
         let mut new_pending: BTreeMap<u64, Vec<B1::Time>> = BTreeMap::new();
 
-        // Pass 1: march through the changed keys — both presentations hold only changed
-        // keys, in hash order, so the ranges advance monotonically — derive each key's
-        // active times, and collect the `(key, time)` moments (grouped by time, so the
-        // later passes run in ascending time order).
-        struct Plan {
+        // Per changed key, phase A: the time-replay loop of the cursor tactic
+        // (`history_replay::compute`), ported to proxy space with the value callback
+        // deferred — it discovers the interesting times in `[lower, upper)`, assembles
+        // each one's consolidated input accumulation as a bracket, and pends times at or
+        // beyond `upper`. Both presentations hold only changed keys, in hash order, so
+        // the ranges advance monotonically. Keys are independent: their brackets share
+        // the retire's single batched callback, and phase B below replays each key's
+        // output side over its own (ascending) moments.
+        let mut keys_v: Vec<u64> = Vec::new();
+        let mut ends: Vec<usize> = Vec::new();
+        let mut entries: Vec<(usize, Bk::RIn)> = Vec::new();
+        struct KeyWork<T> {
             key: u64,
-            i0: usize,
-            i1: usize,
             o0: usize,
             o1: usize,
+            /// The key's interesting in-interval moments, ascending, each with its
+            /// bracket index (`None`: empty accumulation — the callback is only
+            /// consulted for non-empty input, but current output may need retracting).
+            moments: Vec<(T, Option<usize>)>,
         }
-        let mut plans: Vec<Plan> = Vec::new();
-        let mut waves: BTreeMap<B1::Time, Vec<usize>> = BTreeMap::new();
+        let mut work: Vec<KeyWork<B1::Time>> = Vec::new();
         let (mut is, mut os) = (0usize, 0usize);
         for &key in &changed {
             while is < p_in.len() && p_in.key_hashes()[is] < key { is += 1; }
@@ -204,90 +188,41 @@ where
             while os < p_out.len() && p_out.key_hashes()[os] == key { os += 1; }
             let o1 = os;
 
-            // Seeds: input times in [lower, upper) plus carried pending times; join
-            // partners: input times before `lower`.
-            let mut novel: Vec<B1::Time> = p_in.times()[i0..i1]
-                .iter()
-                .filter(|t| lower.less_equal(t) && !upper.less_equal(t))
-                .cloned()
-                .collect();
-            if let Some(p) = self.pending.get(&key) {
-                novel.extend(p.iter().cloned());
+            // value_id → representative record index (the first of the vid's run; the
+            // key's records are sorted by (value_id, time)).
+            let mut rep: Vec<(u64, usize)> = Vec::new();
+            for i in i0..i1 {
+                if rep.last().is_none_or(|(v, _)| *v != p_in.value_ids()[i]) {
+                    rep.push((p_in.value_ids()[i], i));
+                }
             }
-            novel.sort();
-            novel.dedup();
-            let prior: Vec<B1::Time> = p_in.times()[i0..i1]
-                .iter()
-                .filter(|t| !lower.less_equal(t))
-                .cloned()
-                .collect();
+            let pending = self.pending.get(&key).map(|p| &p[..]).unwrap_or(&[]);
 
-            let mut active = BTreeSet::new();
-            let mut pended = BTreeSet::new();
-            active_times(upper.borrow(), &prior, &novel, &mut active, &mut pended);
+            let mut raw_moments: Vec<(B1::Time, (usize, usize))> = Vec::new();
+            let mut pended: Vec<B1::Time> = Vec::new();
+            discover_and_accumulate(
+                &p_in, i0, i1, &rep, pending, lower, upper,
+                &mut raw_moments, &mut entries, &mut pended,
+            );
             if !pended.is_empty() {
-                new_pending.entry(key).or_default().extend(pended);
+                new_pending.insert(key, pended);
             }
-            if active.is_empty() {
+            if raw_moments.is_empty() {
                 continue;
             }
-            let index = plans.len();
-            plans.push(Plan { key, i0, i1, o0, o1 });
-            for t in active {
-                waves.entry(t).or_default().push(index);
-            }
-        }
-
-        // Pass 2a: assemble ONE batched value callback for the whole retire. The desired
-        // output at a `(key, time)` moment is a function of the key's input accumulation
-        // at that time alone — no output-side state — so every moment can share one
-        // crossing into the backend's value logic; a key contributes one bracket per
-        // active time. The time-sensitive bookkeeping (subtracting the current output,
-        // which includes deltas emitted at earlier times) is pure proxy-space arithmetic
-        // and stays in pass 2b.
-        let mut keys_v: Vec<u64> = Vec::new();
-        let mut ends: Vec<usize> = Vec::new();
-        let mut entries: Vec<(usize, Bk::RIn)> = Vec::new();
-        // Every `(key, active time)` moment, in ascending time order, with its bracket
-        // index (`None` when the accumulation is empty: the callback is only consulted
-        // for non-empty input, matching the row reduce contract; the moment may still
-        // need to retract current output).
-        let mut moments: Vec<(usize, B1::Time, Option<usize>)> = Vec::new();
-        for (t, members) in waves {
-            for pi in members {
-                let plan = &plans[pi];
-                // Input accumulation at `t`, consolidated by value id: the key's records
-                // are sorted by (value_id, time), so each id is one contiguous run.
-                let mut bracket = None;
-                let mut len = 0;
-                let mut a = plan.i0;
-                while a < plan.i1 {
-                    let vid = p_in.value_ids()[a];
-                    let rep = a;
-                    let mut net: Option<Bk::RIn> = None;
-                    while a < plan.i1 && p_in.value_ids()[a] == vid {
-                        if p_in.times()[a].less_equal(&t) {
-                            match net.as_mut() {
-                                Some(n) => n.plus_equals(&p_in.diffs()[a]),
-                                None => net = Some(p_in.diffs()[a].clone()),
-                            }
-                        }
-                        a += 1;
-                    }
-                    if let Some(n) = net {
-                        if !n.is_zero() {
-                            entries.push((rep, n));
-                            len += 1;
-                        }
+            let moments = raw_moments
+                .into_iter()
+                .map(|(t, (lo, hi))| {
+                    if lo < hi {
+                        keys_v.push(key);
+                        ends.push(hi);
+                        (t, Some(keys_v.len() - 1))
+                    } else {
+                        (t, None)
                     }
-                }
-                if len > 0 {
-                    keys_v.push(plan.key);
-                    ends.push(entries.len());
-                    bracket = Some(keys_v.len() - 1);
-                }
-                moments.push((pi, t.clone(), bracket));
-            }
+                })
+                .collect();
+            work.push(KeyWork { key, o0, o1, moments });
         }
 
         // The one crossing for this retire.
@@ -297,55 +232,67 @@ where
             self.backend.reduce_many(&keys_v, &ends, &entries)
         };
 
-        // Pass 2b: play the moments in ascending time order — `Ord` extends the partial
-        // order, so a key's earlier deltas are always emitted before a later time reads
-        // them — computing delta = desired − current in proxy space and routing it to
-        // the held-time bucket.
-        let mut emitted: Vec<Vec<(u64, B1::Time, Bk::ROut)>> = (0..plans.len()).map(|_| Vec::new()).collect();
-        for (pi, t, bracket) in moments {
-            let plan = &plans[pi];
-            // Current output at `t`: committed history plus this pass's deltas.
-            let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
-            for o in plan.o0..plan.o1 {
-                if p_out.times()[o].less_equal(&t) {
-                    match cur.entry(p_out.value_ids()[o]) {
-                        std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&p_out.diffs()[o]),
-                        std::collections::btree_map::Entry::Vacant(e) => { e.insert(p_out.diffs()[o].clone()); }
-                    }
-                }
+        // Phase B, per key: replay the output side over the key's moments in ascending
+        // time order — `Ord` extends the partial order, so earlier deltas are always
+        // emitted before a later moment reads them — with the same meet-advancement
+        // keeping the output buffer and this pass's deltas consolidated.
+        for w in work {
+            let mut meets: Vec<B1::Time> = w.moments.iter().map(|(t, _)| t.clone()).collect();
+            for i in (1..meets.len()).rev() {
+                let m = meets[i].clone();
+                meets[i - 1].meet_assign(&m);
             }
-            for (vid, et, d) in emitted[pi].iter() {
-                if et.less_equal(&t) {
-                    match cur.entry(*vid) {
-                        std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
-                        std::collections::btree_map::Entry::Vacant(e) => { e.insert(d.clone()); }
+            let mut out_replay = IdHistory::new();
+            out_replay.load(
+                (w.o0..w.o1).map(|o| (p_out.value_ids()[o], p_out.times()[o].clone(), p_out.diffs()[o].clone())),
+                meets.first(),
+            );
+            // Deltas emitted for this key earlier in this pass; part of "current output".
+            let mut emitted: Vec<((u64, B1::Time), Bk::ROut)> = Vec::new();
+            for (j, (t, bracket)) in w.moments.iter().enumerate() {
+                out_replay.step_through(t);
+                out_replay.advance_buffer_by(&meets[j]);
+                for ((_, et), _) in emitted.iter_mut() {
+                    *et = et.join(&meets[j]);
+                }
+                crate::consolidation::consolidate(&mut emitted);
+
+                // Current output at `t`: committed history plus this pass's deltas.
+                let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
+                for ((vid, et), d) in out_replay.buffer().iter().chain(emitted.iter()) {
+                    if et.less_equal(t) {
+                        match cur.entry(*vid) {
+                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
+                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(d.clone()); }
+                        }
                     }
                 }
-            }
-            cur.retain(|_, d| !d.is_zero());
+                cur.retain(|_, d| !d.is_zero());
 
-            let mut delta: BTreeMap<u64, Bk::ROut> = cur;
-            for d in delta.values_mut() {
-                d.negate();
-            }
-            if let Some(b) = bracket {
-                let lo = if b == 0 { 0 } else { out_ends[b - 1] };
-                for (vid, d) in outs[lo..out_ends[b]].iter().cloned() {
-                    match delta.entry(vid) {
-                        std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
-                        std::collections::btree_map::Entry::Vacant(e) => { e.insert(d); }
+                // delta = desired − current, in proxy space.
+                let mut delta: BTreeMap<u64, Bk::ROut> = cur;
+                for d in delta.values_mut() {
+                    d.negate();
+                }
+                if let Some(b) = *bracket {
+                    let lo = if b == 0 { 0 } else { out_ends[b - 1] };
+                    for (vid, d) in outs[lo..out_ends[b]].iter().cloned() {
+                        match delta.entry(vid) {
+                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
+                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(d); }
+                        }
                     }
                 }
-            }
-            delta.retain(|_, d| !d.is_zero());
-            if delta.is_empty() {
-                continue;
-            }
+                delta.retain(|_, d| !d.is_zero());
+                if delta.is_empty() {
+                    continue;
+                }
 
-            let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
-            for (vid, d) in delta {
-                emitted[pi].push((vid, t.clone(), d.clone()));
-                buckets[idx].push(((plan.key, vid), t.clone(), d));
+                let idx = held_elems.iter().rposition(|h| h.less_equal(t)).expect("no held capability <= active time");
+                for (vid, d) in delta {
+                    emitted.push(((vid, t.clone()), d.clone()));
+                    buckets[idx].push(((w.key, vid), t.clone(), d));
+                }
             }
         }
 
@@ -387,3 +334,172 @@ where
         (produced, frontier)
     }
 }
+
+/// Phase A of one key's retire: the time-replay loop of the cursor tactic
+/// (`history_replay::compute`), ported to proxy space with the value callback deferred.
+///
+/// It replays the key's input records — split into `prior` (before `lower`, the
+/// accumulated history) and the novel interval — together with the carried `pending`
+/// times, in ascending time order, discovering the interesting times: those carrying
+/// novel or pending updates, and joins thereof (synthesized as replay proceeds). At each
+/// interesting time within `[lower, upper)` it assembles the consolidated input
+/// accumulation as a bracket appended to `entries` (recorded in `moments` with its entry
+/// range; an empty range marks a moment whose accumulation vanished but whose current
+/// output may need retracting). Times at or beyond `upper` are `pended`.
+///
+/// The replay buffers are repeatedly advanced by the meet of the times still to come and
+/// consolidated — the collapse that keeps a key with many distinct times linear rather
+/// than quadratic, exactly as in the cursor tactic.
+#[allow(clippy::too_many_arguments)]
+fn discover_and_accumulate<T, RIn>(
+    p_in: &ProxyChunk<T, RIn>,
+    i0: usize,
+    i1: usize,
+    rep: &[(u64, usize)],
+    pending: &[T],
+    lower: &Antichain<T>,
+    upper: &Antichain<T>,
+    moments: &mut Vec<(T, (usize, usize))>,
+    entries: &mut Vec<(usize, RIn)>,
+    pended: &mut Vec<T>,
+) where
+    T: Timestamp + Lattice,
+    RIn: Semigroup + Clone,
+{
+    // The novel interval's records seed interestingness; prior records are join partners.
+    let mut batch_replay = IdHistory::new();
+    batch_replay.load(
+        (i0..i1)
+            .filter(|&i| lower.less_equal(&p_in.times()[i]))
+            .map(|i| (p_in.value_ids()[i], p_in.times()[i].clone(), p_in.diffs()[i].clone())),
+        None,
+    );
+
+    // Suffix meets of the carried pending times (ascending, so meets accumulate from the end).
+    let mut meets: Vec<T> = pending.to_vec();
+    for i in (1..meets.len()).rev() {
+        let m = meets[i].clone();
+        meets[i - 1].meet_assign(&m);
+    }
+
+    let mut meet: Option<T> = None;
+    update_meet(&mut meet, meets.first());
+    update_meet(&mut meet, batch_replay.meet());
+
+    let mut input_replay = IdHistory::new();
+    input_replay.load(
+        (i0..i1)
+            .filter(|&i| !lower.less_equal(&p_in.times()[i]))
+            .map(|i| (p_in.value_ids()[i], p_in.times()[i].clone(), p_in.diffs()[i].clone())),
+        meet.as_ref(),
+    );
+
+    let mut synth: Vec<T> = Vec::new(); // sorted descending: pop ascending
+    let mut times_current: Vec<T> = Vec::new();
+    let mut temporary: Vec<T> = Vec::new();
+    let mut times_slice = pending;
+    let mut meets_slice = &meets[..];
+
+    while let Some(next_time) = [batch_replay.time(), times_slice.first(), input_replay.time(), synth.last()]
+        .into_iter()
+        .flatten()
+        .min()
+        .cloned()
+    {
+        input_replay.step_while_time_is(&next_time);
+        let mut interesting = batch_replay.step_while_time_is(&next_time);
+        if interesting {
+            if let Some(m) = meet.as_ref() {
+                batch_replay.advance_buffer_by(m);
+            }
+        }
+        while synth.last() == Some(&next_time) {
+            times_current.push(synth.pop().expect("nonempty"));
+            interesting = true;
+        }
+        while times_slice.first() == Some(&next_time) {
+            times_current.push(times_slice[0].clone());
+            times_slice = &times_slice[1..];
+            meets_slice = &meets_slice[1..];
+            interesting = true;
+        }
+        interesting = interesting || batch_replay.buffer().iter().any(|((_, t), _)| t.less_equal(&next_time));
+        interesting = interesting || times_current.iter().any(|t| t.less_equal(&next_time));
+
+        if !upper.less_equal(&next_time) {
+            if interesting {
+                if let Some(m) = meet.as_ref() {
+                    input_replay.advance_buffer_by(m);
+                }
+                // Assemble the accumulation at `next_time` from both buffers; buffered
+                // times beyond it contribute synthetic joins.
+                let mut acc: Vec<(u64, RIn)> = Vec::new();
+                for ((vid, t), d) in input_replay.buffer().iter().chain(batch_replay.buffer().iter()) {
+                    if t.less_equal(&next_time) {
+                        acc.push((*vid, d.clone()));
+                    } else {
+                        temporary.push(next_time.join(t));
+                    }
+                }
+                crate::consolidation::consolidate(&mut acc);
+                let lo = entries.len();
+                for (vid, d) in acc {
+                    let r = rep[rep.binary_search_by_key(&vid, |x| x.0).expect("vid presented")].1;
+                    entries.push((r, d));
+                }
+                moments.push((next_time.clone(), (lo, entries.len())));
+            }
+            // Synthetic interesting times: joins with the remaining batch times and the
+            // times seen so far.
+            temporary.extend(batch_replay.buffer().iter().map(|((_, t), _)| t).filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
+            temporary.extend(times_current.iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
+            sort_dedup(&mut temporary);
+            let synth_len = synth.len();
+            for time in temporary.drain(..) {
+                if upper.less_equal(&time) {
+                    pended.push(time);
+                } else {
+                    synth.push(time);
+                }
+            }
+            if synth.len() > synth_len {
+                synth.sort_by(|x, y| y.cmp(x));
+                synth.dedup();
+            }
+        } else if interesting {
+            pended.push(next_time.clone());
+        }
+
+        // Track the meet of every remaining source of times, and keep `times_current`
+        // advanced by it (the same collapse as the buffers).
+        meet = None;
+        update_meet(&mut meet, batch_replay.meet());
+        update_meet(&mut meet, input_replay.meet());
+        for t in synth.iter() {
+            update_meet(&mut meet, Some(t));
+        }
+        update_meet(&mut meet, meets_slice.first());
+        if let Some(m) = meet.as_ref() {
+            for t in times_current.iter_mut() {
+                *t = t.join(m);
+            }
+        }
+        sort_dedup(&mut times_current);
+    }
+    sort_dedup(pended);
+}
+
+fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
+    list.sort();
+    list.dedup();
+}
+
+/// Updates an optional meet by an optional time.
+fn update_meet<T: Lattice + Clone>(meet: &mut Option<T>, other: Option<&T>) {
+    if let Some(time) = other {
+        match meet.as_mut() {
+            Some(m) => m.meet_assign(time),
+            None => *meet = Some(time.clone()),
+        }
+    }
+}
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index a89060530..b02054be6 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -978,3 +978,72 @@ fn bench_wall_clock_vs_row() {
         );
     }
 }
+
+// ---------------------------------------------------------------------------
+// Scaling: one key, many distinct times, in a single batch (the shapes of the
+// row suite's `reduce_scaling` / `join_scaling` tests). These are linear-ish
+// only if the tactics replay histories with meet-advancement; a per-moment
+// rescan or a naive per-key cross product is quadratic and would hang here.
+// ---------------------------------------------------------------------------
+
+#[test]
+fn proxy_reduce_scaling() {
+    use timely::dataflow::operators::ToStream;
+    use timely::dataflow::operators::capture::Extract;
+    use timely::dataflow::operators::vec::Map;
+    use differential_dataflow::AsCollection;
+
+    let scale = 100_000u64;
+    let data = timely::example(move |scope| {
+        let arranged = arrange_core::<_, _, Chunker<(), ()>, Batcher<(), ()>, Bldr<(), ()>, Spine<(), ()>>(
+            (0..1)
+                .to_stream(scope)
+                .flat_map(move |_| (0..scale).map(|i| ((((), ())), i, 1)))
+                .as_collection()
+                .inner,
+            Pipeline,
+            "Arrange",
+        );
+        let count = |_k: &(), input: &[(&(), isize)], output: &mut Vec<(isize, isize)>| {
+            let c: isize = input.iter().map(|(_, d)| *d).sum();
+            if c > 0 {
+                output.push((c, 1));
+            }
+        };
+        let tactic = ProxyReduceTactic::new(VecReduceBackend::new(count));
+        let reduced = reduce_with_tactic::<_, Spine<(), isize>, _>(arranged, "ProxyReduce", tactic);
+        reduced.as_collection(|_k, v| *v).inner.capture()
+    });
+    let extracted: Vec<_> = data.extract();
+    assert_eq!(extracted.len(), 1);
+}
+
+#[test]
+fn proxy_join_scaling() {
+    use timely::dataflow::operators::ToStream;
+    use timely::dataflow::operators::capture::Extract;
+    use timely::dataflow::operators::vec::Map;
+    use differential_dataflow::AsCollection;
+
+    let scale = 100_000u64;
+    let data = timely::example(move |scope| {
+        let counts = (0..1)
+            .to_stream(scope)
+            .flat_map(move |_| (0..scale).map(|i| ((), i, 1)))
+            .as_collection()
+            .count();
+        let odds = counts.clone().filter(|x| x.1 % 2 == 1).inner;
+        let evens = counts.filter(|x| x.1 % 2 == 0).inner;
+        let a0 = arrange_core::<_, _, Chunker<(), isize>, Batcher<(), isize>, Bldr<(), isize>, Spine<(), isize>>(odds, Pipeline, "Odds");
+        let a1 = arrange_core::<_, _, Chunker<(), isize>, Batcher<(), isize>, Bldr<(), isize>, Spine<(), isize>>(evens, Pipeline, "Evens");
+        let tactic = ProxyJoinTactic::new(VecJoinBackend::new(|_k: &(), v0: &isize, v1: &isize| (*v0, *v1)));
+        join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<((isize, isize), u64, isize)>>>(a0, a1, tactic).capture()
+    });
+    // Odd and even counts are never simultaneously present: the join is empty.
+    let total: isize = data
+        .extract()
+        .iter()
+        .flat_map(|(_, v)| v.iter().map(|(_, _, d)| *d))
+        .sum();
+    assert_eq!(total, 0);
+}

From 80b6725a6fdc80240e6c995374131ccab058dc67 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 06:08:16 -0400
Subject: [PATCH 09/68] =?UTF-8?q?int=5Fproxy:=20materialize=20in=20TARGET-?=
 =?UTF-8?q?sized=20chunks=20=E2=80=94=20the=20last=20scaling=20term?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The row-vs-proxy comparison on the scaling shapes showed proxy reduce
still superlinear (9x per 4x scale; timeout at 4M where row takes
0.5s). Profiling pinned it outside the tactic: the reference backend's
materialize built ONE giant VecChunk and let the builder settle it,
and settle's split path peels TARGET-sized pieces off the front with
split_off, copying the remaining tail each iteration — O(m²/TARGET)
in the batch size. Feeding the builder TARGET-sized chunks directly
fixes it: 4M drops from >120s to 3.2s.

With that, both operators are in the row implementations' complexity
class on the scaling shapes (growth ~5x per 4x scale ≈ n·log n; the
hot frames are the presentation sort and fnv hashing — constants, not
structure): at scale 4M, join row 0.96s / proxy 3.6s, reduce row 0.48s
/ proxy 3.2s.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/reference.rs       | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
index 111a13adb..8fd31d329 100644
--- a/differential-dataflow/src/operators/int_proxy/reference.rs
+++ b/differential-dataflow/src/operators/int_proxy/reference.rs
@@ -329,13 +329,19 @@ where
             })
             .collect();
         crate::consolidation::consolidate_updates(&mut rows);
-        let mut chunk = VecChunk::default();
-        for row in rows {
-            use timely::container::PushInto;
-            chunk.push_into(row);
-        }
+        // Feed the builder TARGET-sized chunks: handing it one giant chunk would make its
+        // settle peel TARGET-sized pieces off the front, copying the remaining tail each
+        // time — quadratic in the batch size.
         let mut builder = ChunkBuilder::<VecChunk<K, V2, T, ROut>>::with_capacity(0, 0, 0);
-        builder.push(&mut chunk);
+        let mut rows = rows.into_iter().peekable();
+        while rows.peek().is_some() {
+            let mut chunk = VecChunk::default();
+            for row in rows.by_ref().take(<VecChunk<K, V2, T, ROut> as crate::trace::chunk::Chunk>::TARGET) {
+                use timely::container::PushInto;
+                chunk.push_into(row);
+            }
+            builder.push(&mut chunk);
+        }
         builder.done(description)
     }
 }

From 7445d2e19aa2b447ee746b6ce529499ed5665662 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 19:43:37 -0400
Subject: [PATCH 10/68] interactive: CorgiChunk arrangement backend
 (cursor-less Route B on the #778 Chunk split)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A columnar differential-dataflow backend for DDIR whose native representation
is corgi Value columns and whose scalar logic is corgi `eval_graph`, parallel
to `backend::vec`.

Arrangement:
  - CorgiChunk : Chunk (NOT NavigableChunk) — corgi columns + Vec time/diff,
    ordered (key,val) by corgi structural order then time. merge/extract/advance/
    settle ported from the VecChunk reference; drives corgi's discrimination sort
    (sort_perm) + batched compare_idx, never per-pair. Rides #778's cursor-less
    Chunk path, so it gets the fueled/graded ChunkBatchMerger for free.
  - Tactics (Route B): cursor-less reduce (incremental key selection over the
    input delta); join via corgi `find` (find_ranges → equal-range merge-join,
    multi-record). as_collection reads columns directly.

differential-dataflow proper: widen the JoinTactic/ReduceTactic/Fresh/
join_with_tactic/reduce_with_tactic seam from pub(crate) to pub, so an
out-of-crate tactic can be implemented at all. (Candidate for upstreaming as
the public extension point the #773 tactics were designed to be.)

State: all 6 canonical programs match `vec`; 33 lib tests pass. reach ~1.9×
slower than vec, compute-bound linear ~3× FASTER (columnar eval avoids the
row backend's ~22% Value::cmp pointer-chasing). The remaining reach gap is
entirely the reduce, still row-wise — the only operator not yet columnar.

Notes / follow-ups: corgi_arrange.rs (old CorgiBatch impl) is superseded by
corgi_chunk.rs and retained only as reference; scratch examples alongside the
corgi_perf/corgi_progs/corgi_prof harnesses. Depends on frankmcsherry/wip
corgi branch dd-arrange-api.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 SPIKE.md                                      | 578 ++++++++++++++++
 interactive/Cargo.toml                        |   1 +
 interactive/examples/corgi_arrange_smoke.rs   |  69 ++
 interactive/examples/corgi_backend_linear.rs  | 142 ++++
 interactive/examples/corgi_bench.rs           | 227 ++++++
 interactive/examples/corgi_chain.rs           | 113 +++
 interactive/examples/corgi_fold.rs            |  73 ++
 interactive/examples/corgi_join_dataflow.rs   | 131 ++++
 interactive/examples/corgi_join_mechanism.rs  | 133 ++++
 interactive/examples/corgi_linear_dataflow.rs | 151 ++++
 interactive/examples/corgi_perf.rs            | 150 ++++
 interactive/examples/corgi_prof.rs            |  54 ++
 interactive/examples/corgi_program.rs         |  53 ++
 interactive/examples/corgi_progs.rs           |  77 +++
 interactive/examples/corgi_reach.rs           |  69 ++
 interactive/examples/corgi_reduce.rs          |  79 +++
 interactive/examples/corgi_reduce_dataflow.rs | 221 ++++++
 interactive/examples/corgi_reduce_trace.rs    | 103 +++
 interactive/examples/corgi_smoke.rs           |  23 +
 interactive/src/backend/corgi.rs              | 401 +++++++++++
 interactive/src/backend/mod.rs                |   1 +
 interactive/src/corgi_arrange.rs              | 465 +++++++++++++
 interactive/src/corgi_backend.rs              | 149 ++++
 interactive/src/corgi_chunk.rs                | 654 ++++++++++++++++++
 interactive/src/corgi_join.rs                 | 134 ++++
 interactive/src/corgi_logic.rs                | 481 +++++++++++++
 interactive/src/corgi_reduce.rs               | 285 ++++++++
 interactive/src/lib.rs                        |   6 +
 28 files changed, 5023 insertions(+)
 create mode 100644 SPIKE.md
 create mode 100644 interactive/examples/corgi_arrange_smoke.rs
 create mode 100644 interactive/examples/corgi_backend_linear.rs
 create mode 100644 interactive/examples/corgi_bench.rs
 create mode 100644 interactive/examples/corgi_chain.rs
 create mode 100644 interactive/examples/corgi_fold.rs
 create mode 100644 interactive/examples/corgi_join_dataflow.rs
 create mode 100644 interactive/examples/corgi_join_mechanism.rs
 create mode 100644 interactive/examples/corgi_linear_dataflow.rs
 create mode 100644 interactive/examples/corgi_perf.rs
 create mode 100644 interactive/examples/corgi_prof.rs
 create mode 100644 interactive/examples/corgi_program.rs
 create mode 100644 interactive/examples/corgi_progs.rs
 create mode 100644 interactive/examples/corgi_reach.rs
 create mode 100644 interactive/examples/corgi_reduce.rs
 create mode 100644 interactive/examples/corgi_reduce_dataflow.rs
 create mode 100644 interactive/examples/corgi_reduce_trace.rs
 create mode 100644 interactive/examples/corgi_smoke.rs
 create mode 100644 interactive/src/backend/corgi.rs
 create mode 100644 interactive/src/corgi_arrange.rs
 create mode 100644 interactive/src/corgi_backend.rs
 create mode 100644 interactive/src/corgi_chunk.rs
 create mode 100644 interactive/src/corgi_join.rs
 create mode 100644 interactive/src/corgi_logic.rs
 create mode 100644 interactive/src/corgi_reduce.rs

diff --git a/SPIKE.md b/SPIKE.md
new file mode 100644
index 000000000..6e9d5de99
--- /dev/null
+++ b/SPIKE.md
@@ -0,0 +1,578 @@
+# Spike: corgi as columnar scalar logic inside differential-dataflow
+
+**Goal.** Run corgi (`frankmcsherry/wip:corgi`) — or a light fork — as the scalar logic DD's
+join/reduce/linear operators invoke *where they would normally call a closure*, applied to **many
+rows at once** (columnar). Host = the DDIR crate (`interactive/`). Drive to a **measured viability
+conclusion**: does corgi-over-columns beat DDIR's per-row `ir::eval` interpreter, and from what
+column width? How much existing structure can we reuse; do we need a corgi-data CHUNK variant?
+
+This file is the durable log across loop iterations. **Read it first each iteration.**
+
+---
+
+## PHASE 2 (2026-06-29): BUILD THE CORGI BACKEND (no transcode, corgi-native)
+
+Goal: corgi's columnar `Value` is DDIR's native row representation end-to-end; operators run
+`eval_graph`; conversion only at I/O boundaries. Frank: consult `chunk/vec.rs` + the `columnar/`
+stack as templates (don't copy literally). Phase-1 verdict (above) stands; this builds the real thing.
+
+### Design surface — much smaller than feared (verified this iteration)
+- `timely::Container` = just `Accountable + Default + 'static` (blanket impl, timely lib.rs:104). So
+  a custom container needs only `record_count` + `Default` + `'static`.
+- Backend container bound (`backend/mod.rs:39-42`) = `Container + Clone + ResultsIn<Summary> +
+  Enter<Time,Time,Inner=Self> + Leave<Time,Time,Outer=Self>`. **Enter/Leave are SAME-time =
+  IDENTITY** for DDIR's dynamic-timestamp model (comment `backend/mod.rs:38`). No `ContainerBytes`
+  in the bound → **not needed for single-worker** (`evaluate` uses `execute_directly`).
+- Container trait defs: `Negate::negate(self)->Self`; `Enter<T1,T2>{type InnerContainer; enter}`;
+  `Leave<T1,T2>{type OuterContainer; leave}`; `ResultsIn<TS>::results_in(self,&TS)->Self`
+  (`collection.rs:1314-1339`; `Vec<(D,T,R)>` reference impls at :1350-1376 — the template).
+- NOTE: `backend::col` is **commented out in this branch** (`backend/mod.rs:14`, "deferred on the
+  Value-model port") — so this is a fresh backend, not a col revival. `col.rs` readable for ideas.
+
+### The container (M1 foundation)
+`CorgiContainer<T, R>` = `{ keys: corgi::Value, vals: corgi::Value, times: Vec<T>, diffs: Vec<R> }`.
+**Payload (key/val) corgi-columnar; time/diff plain Rust Vecs** — corgi never touches time/lattice.
+Trait impls (all easy, time/diff in Rust, payload columns pass through or gather):
+- `Accountable::record_count` = `times.len()`. `Default`/`Clone`.
+- `Negate` = negate `diffs`. `Enter<T1,T2>`/`Leave<T1,T2>` = map times (identity for T1=T2=Time).
+- `ResultsIn` = map each time via `step.results_in`; on `None`, drop that row → `gather` the corgi
+  key/val columns by surviving indices (corgi `engine::gather`). Keep all four columns aligned.
+
+### Staged milestones
+- **M1 — container + corgi-native Linear, in a real dataflow (NO arrangement).** Linear is a
+  container-level unary: input `CorgiContainer` block → `eval_graph` on keys/vals → output block.
+  Ingest transcodes rows→block ONCE (boundary); egress block→rows ONCE. Between ops: zero
+  transcode. Example mirrors `corgi_linear_dataflow`/`corgi_chain` but with the native container →
+  should hit the eval-only ceiling. **This is the headline "no transcode" proof; do first.**
+- **M2 — corgi arrangement (for join/reduce).** Route A: a `Chunk` impl over corgi columns
+  (`chunk/vec.rs` template) → free `ChunkBatcher/Builder/Spine`; needs a cursor (navigates KEYS)
+  + merge/extract/advance/settle (corgi sort/merge). The scalar logic (join projection / reducer)
+  runs `eval_graph` over each key's VALUE-column slice (cursor gives the key run; corgi bulk-processes
+  its values). Pragmatic start: hybrid (existing `ValSpine` storage + corgi logic over per-key
+  slices) to prove reduce/join correctness, then move storage to corgi columns to kill transcode.
+- **M3 — wire `impl Backend for CorgiBackend`** (linear/arrange/join/reduce/as_collection/inspect/
+  leave_dynamic) + `render_tree::<CorgiBackend>`; run a real DDIR program end-to-end vs `evaluate`.
+
+### Boundary transcode is expected & fine (the only conversions):
+ingest (input rows→corgi block), egress (→rows), and any not-yet-ported op (interpreter fallback).
+Operator-to-operator flow is transcode-free. Reuse `corgi_logic::{transcode,untranscode,compile*}`.
+
+---
+
+## ★ VERDICT (2026-06-28): VIABLE — strong win, recommended. ★
+
+corgi as DDIR's columnar scalar logic works, integrates soundly with differential-dataflow, and
+is a large measured win. Every question posed is answered:
+
+- **corgi as scalar logic over many rows** — YES. Compiles DDIR `Term` → corgi `Graph<NumOp>`,
+  runs columnar. Measured **50–135×** vs the per-row `ir::eval` interpreter on the map/filter/arith
+  core (eval-only), **5.4×** on list/fold aggregation. Crossover at **~10 rows** (below that,
+  `eval_graph` per-call setup loses). Examples: `corgi_bench`, `corgi_fold`.
+- **Inside a real DD dataflow** — YES, SOUND. `corgi_linear_dataflow` runs corgi as a DDIR Linear
+  map in a real differential computation; output matches the interpreter exactly incl. net-zero
+  retractions vanishing. corgi never touches time; the operator keeps (time,diff)/lattice in Rust.
+- **The cost lever** — the AoS↔SoA **transcode dominates** the per-call model (~85–95% at scale).
+  Storing data corgi-columnar amortizes it: a K-op chain stays ~flat (`corgi_chain`), so the win
+  GROWS with program depth (9×→22.5× over interp as K=1→16; 2–3.6× over per-op transcode).
+- **Reuse / CHUNK variant** — to START, nothing new is needed: the scalar-logic path runs over any
+  existing arrangement via per-call transcode. The corgi-columnar **CHUNK is the optimization**
+  that removes the transcode, and pays more the deeper the program. Two routes (see "ARCHITECTURE
+  FINDING"): via the `Chunk` trait (requires writing a cursor — it mandates `Navigable`), or
+  cursor-less via a corgi container + custom `Merger` + tactic (the true use of the #771–773 seam).
+- **Dynamic typing** — SOLVED. `infer_shape` forms the corgi `Shape` by observing the data; the
+  `Term` drives ops, the inferred shape drives layout. For sum types, scan the column for all arms
+  (the one genuinely data-dependent case; not yet built).
+- **corgi modifications needed** — NONE so far. Map/filter/arith/list/fold all hit existing ops.
+
+**Coverage:** DONE + measured — Var/Bound/Int/Tuple/Proj/Binary(arith,cmp,logical)/If/List/Fold.
+MAPPED but not built — Variant/Inject/Case (→ MapSum/Unwrap/CapSum; needs column-scan Sum shape
+inference + lane partition), Hash (compose or a light corgi op), signed/i64 (corgi `enc_i64`/
+`ToSigned`). None are blockers; all have a clear path.
+
+**Recommendation:** pursue it. Order: (1) land the `Term→Graph` compiler + transcoder as a real
+DDIR module [DONE here as `corgi_logic.rs`]; (2) wire corgi into the Linear operator behind a
+Backend flag [prototyped]; (3) corgi reduce tactic (closure already gets a per-key column slice);
+(4) corgi-columnar CHUNK to kill the transcode — biggest payoff, do once 1–3 prove out; (5) extend
+coverage to Variant/Case for the eqsat/datalog corpus.
+
+Artifacts (all GREEN, `~/.cargo/bin/cargo run --release -p interactive --example <name>`):
+`corgi_smoke`, `corgi_bench`, `corgi_linear_dataflow`, `corgi_chain`, `corgi_fold`;
+library module `interactive/src/corgi_logic.rs`.
+
+---
+
+## Environment (durable)
+
+- Worktree: `/Users/mcsherry/Projects/dd-corgi-spike`, branch `corgi-scalar-spike`, base
+  `4eff165a` (= join-tactics: master-next `#772` + navigation-free join/reduce tactic drivers).
+- corgi clone (read-only study, light mods allowed): `/Users/mcsherry/Projects/wip/corgi`
+  (separate `wip` repo, `corgi/` dir, no-deps, ~2.1k LoC). Wired as path dep in
+  `interactive/Cargo.toml`: `corgi = { path = "../../wip/corgi" }`.
+- cargo NOT on PATH → use `~/.cargo/bin/cargo`. Build cmd: `cd <worktree> && ~/.cargo/bin/cargo build -p interactive`.
+  Cold build measured **~10s** (fast iteration available). Run long builds in background.
+
+## The plan: corgi = the scalar closure, NOT the tactic
+
+DD `master-next` made navigation optional and join/reduce drive over a pluggable **tactic**
+(`operators/join.rs:56 JoinTactic`, `operators/reduce.rs:28 ReduceTactic`; minimal batch =
+`BatchReader{len,description}` only, `trace/mod.rs:215`; `Navigable` opt-in `cursor/mod.rs:25`).
+corgi does NOT implement the tactic/merge engine — the tactic keeps navigation + all `(time,diff)`
+lattice algebra in Rust. corgi replaces the **scalar closure**: DDIR's `Term` programs
+(`interactive/src/parse/mod.rs:28`; `Projection`=`:86`, `Reducer`=`:89`, `LinearOp`=`ir.rs:37`)
+compile to a corgi `Graph<NumOp>`, run by one compiled `eval_graph` over columns. "No lattice in
+corgi" is therefore fine — corgi never sees time.
+
+**Why columns matter:** corgi only beats the inline interpreter when handed *wide* columns
+(`eval_graph` has per-call setup, `graph.rs:72`). Per-row corgi loses. The whole experiment is
+"how wide before corgi wins."
+
+**KEY INSIGHT (rung 0, verified):** corgi ops are *inherently columnar* — a `Prim` column IS the
+batch of rows, and each op is the SIMD/vectorized map. So a per-row scalar `Term` compiles to a
+**flat** corgi graph over the column (`Input` = the column); there is NO top-level `map` wrapper.
+`MapList`/`Fold` appear only when the `Term` itself maps/folds over an *inner* `List` (DDIR `Fold`,
+`FlatMap`). This makes the `Term → Graph` compile more direct than expected: binders are columns,
+`Field` projects a Prod-column's component (itself a column), arithmetic/compare ops are columnar.
+Pitfall found: `parse_ml("input map (x -> x add 100)")` panics ("MapList: expected a list") on a
+`Prim` — use `input add_u64 100`.
+
+### Staging ladder
+- **Rung 0 (DONE):** env up, corgi builds inside DDIR, API mapped, smoke test.
+- **Rung 1:** `Term → Graph<NumOp>` compiler (the load-bearing artifact) + `&[ir::Value] →
+  corgi::Value` columnar transcoder, both **shape-directed**. Standalone bench: corgi vs per-row
+  `ir::eval` on a map/filter `Term`, sweep column width → find crossover. (Lives as a module +
+  example *inside* `interactive/`, reusing real `Term`/`Value`/`ir::eval`.)
+- **Rung 2:** wire into DDIR's **Linear** operator (pure row-wise map/filter; no tactic needed —
+  `backend/mod.rs:46`, `vec.rs:114`) so it runs inside a real DD dataflow.
+- **Rung 3:** **Reduce** — its closure already gets a per-key `&[(val,diff)]` slice
+  (`reduce.rs:651`), a natural column; corgi reducer (Min/Distinct/Count/Collect →
+  Min/DedupList/Len/SortList+group). Big-group win first; key-batching for small groups later.
+- **Rung 4 (stretch):** corgi-columnar **CHUNK** batch (`Chunk` impl à la `trace/chunk/vec.rs`)
+  storing values as corgi columns so the column handed to corgi is a slice/Gather, not a
+  per-call transcode. This is where the "batch without cursor" feature earns its keep.
+- **Join** last (closure is per-`(val0,val1)` pair, `join.rs:99` → needs match-buffering).
+
+## Dynamic-typing approach (Frank's key concern)
+
+DDIR `Value = Int|Tuple|Variant|List` (`ir.rs:18`) is dynamically typed; corgi columns need a
+fixed `Shape` (`shape.rs`, `Prim(w)|Prod|Sum|List`). Resolution: **infer the corgi `Shape` by
+observing the data** (corgi `shape_of_value`) — i.e. the row type is formed from what actually
+flows. The `Term` drives the ops; the input `Shape` drives shape-dependent choices (e.g. `Proj` →
+`Field` on a Prod vs `Get`/`Gather` on a List, `Inject` arity). Output shape = `shape_of(graph,
+input_shape)`. Compiler signature: `compile(term: &Term, input_shape: &Shape) -> Graph<NumOp>`.
+
+## corgi API (locked, for the compiler)
+
+- Build: `corgi::Builder::<NumOp>::default()` → `.input()` / `.tuple(Vec<id>)` /
+  `.add(op: impl Into<NumOp>, vec![id]) ` / `.finish(out_id) -> Graph<NumOp>`. (`graph.rs:113`)
+- Run: `corgi::eval_graph(&g, value) -> Value` (CONSUMES arg, moves to last use). `graph.rs:72`.
+- Typecheck: `corgi::shape_of(&g, &input_shape) -> Result<Shape,String>`; `shape_of_value(&v)`.
+- Template for the compiler: corgi's own `frontend/ml.rs:479 lower(e, env, b)` — env maps
+  binders→node ids; near-identical shape to what I need.
+- `Value` ctors: `Value::u64(Vec<u64>)`, `Value::u8`, `Value::List(bounds.into(), Box<Value>)`,
+  `Value::Prod(Vec<Value>)`, sum via `Value::sum`/`sum_from_prim`. Lit broadcasts vs an input node.
+- i64: `corgi::{enc_i64, dec_i64}`; signed order via `ArithOp::ToSigned` ("signed"). Spike v1 can
+  assume small non-negative ints (plain u64) and add enc/dec when needed.
+
+### Term → corgi op map (from `frontend/mod.rs:83 resolve` + `ops/`)
+| DDIR `Term`/op | corgi |
+|---|---|
+| `Var(i)`/`Bound(k)` | env lookup (node id); Var absolute, Bound from innermost |
+| `Int(n)` | `Op::Lit(Value::u64(vec![n as u64]))` (broadcast vs input node) |
+| `Tuple` / `Spread` | `b.tuple(ids)` / splice fields |
+| `Proj(t,i)` | `Op::Field(i)` (Prod) **or** `get`/`Gather` (List) — shape-directed |
+| `Inject(tag,pay)` | `Op::Inject(tag,arity)` — const tag only (data-driven tag = stretch) |
+| `Case{arms,default}` | `Op::MapSum(arms)` + `Op::Unwrap` (cf ml.rs Match); default = stretch |
+| `Fold{list,init,step}` | pair `(init,list)` then `Op::Fold(body)`; mind binder order |
+| `If{c,t,e}` | masks + `Op::Select` (mask,then,else) — evaluates both arms (SIMD predication) |
+| `Unary(Neg)` | `ArithOp::Neg(U,64)`; `Len`→`Op::Len`; `Not`/`IsTag` = compose |
+| `Binary(Add/Sub/Mul)` | `ArithOp::Bin(op,U,64)` |
+| `Binary(Eq/Ne/Lt/Le)` | `CmpOp::Rel(Pred::_)`; `Gt/Ge` = swapped; `And/Or` = compose (mul/max) |
+| `Hash` | NO corgi op → light corgi mod, or compose mul/shr/and (stretch) |
+| `Reducer::{Min,Distinct,Count,Collect}` | `Min` / `DedupList` / `Len` / `SortList`+group |
+
+Most of LinearOp's map/filter core (Proj/Tuple/Int/Binary/If) maps 1:1 → start there.
+
+---
+
+## Decision log
+- 2026-06-28: isolated worktree (not Frank's checkouts); corgi as path dep; spike code hosted in
+  `interactive/` reusing real `Term`/`ir::eval` (no duplication, stays honest, "in DDIR" per ask).
+- 2026-06-28: corgi-as-closure (rungs 1–3) works on existing arrangements via per-call transcode;
+  corgi-columnar CHUNK (rung 4) removes the transcode and is where the cursor-less batch matters.
+
+## Status / next
+- [x] Rung 0: env, build (cold ~10s / incremental ~0.1s), corgi API mapped, op table.
+- [x] Rung 0: smoke test `interactive/examples/corgi_smoke.rs` GREEN.
+- [x] Rung 1: `examples/corgi_bench.rs` — `infer_shape` (data→Shape), `transcode` (AoS→SoA),
+      `compile(Term→Graph<NumOp>)` for the map/filter core (Var/Bound/Int/Tuple/Proj/Binary/If),
+      crossover bench. **GREEN + correctness verified vs `ir::eval`.**
+- [x] Rung 2: `examples/corgi_linear_dataflow.rs` — corgi computes a DDIR Linear map **inside a
+      real DD dataflow** (container-level unary operator: transcode batch→corgi cols, `eval_graph`,
+      transcode back; (time,diff) pass through). Shared compiler/transcoder promoted to lib module
+      `src/corgi_logic.rs`. **VERIFIED == `ir::eval` reference incl. net-zero retractions vanishing.**
+      → Integration is SOUND; corgi composes with DD's incremental/differential semantics.
+      (This operator pays both transcodes = the rung-1 "floor"; the ceiling needs rung 4.)
+- [x] Rung 4 (measurement): `examples/corgi_chain.rs` — K-op chain, interp vs per-op-transcode
+      vs corgi-columnar. **GREEN + correctness.** corgi-columnar storage scales ~flat with depth.
+- [x] Q3 (partial, sufficient for verdict): List + Fold built & validated (`examples/corgi_fold.rs`,
+      5.4× over interp, correctness OK). Variant/Case/Hash mapped but not built (see VERDICT).
+- [x] **Phase-1 VERDICT written (top of file). Measured viability reached.**
+
+### Phase 2 status (build the corgi backend; spec at top under "PHASE 2")
+- [x] Studied references: `Backend` trait, `chunk/vec.rs` (Chunk+Cursor), `RecordedUpdates`
+      (`columnar/collection/container.rs`), container trait surface. Design locked (small surface).
+- [x] M1: `src/corgi_backend.rs` (`CorgiContainer<T,R>` = corgi key/val cols + Rust time/diff;
+      `Accountable/Default/Clone`, `from_updates`/`into_updates` boundary transcode) +
+      `examples/corgi_backend_linear.rs` (a real DD dataflow: ingest→K×corgi-Project→egress).
+      **GREEN, == interpreter.** 8 chained Linear ops, **2 transcodes total (ingest+egress), ZERO
+      between operators** (vs 2K in the per-op model). Container surface confirmed minimal:
+      `CapacityContainerBuilder<C>` needs only `C: Accountable+Default`; give_container ships whole
+      prebuilt blocks through `unary`/`Pipeline`. corgi `Value` self-describes (`shape_of_value`),
+      so the container needn't carry shapes. (Inline the K-chain in the dataflow closure — a generic
+      `fn over Stream<G,_>` trips timely's Stream-lifetime / `Scope` struct-vs-trait.)
+- [x] M2(a): `examples/corgi_reduce.rs` — corgi EXPRESSES reduce (`GroupKey` + per-group fold via
+      `MapList`/`ArithOp::Reduce`) — sum-per-key & min-per-key == reference. GREEN. The per-key
+      reduce logic is validated; M2(b) makes it incremental.
+- [ ] M2(b): incremental corgi arrangement — **DECISION: Route B (cursor-less + tactic)** (Frank,
+      2026-06-29). ← **NEXT**. Sub-plan:
+      - M2b-1: `CorgiBatch` (corgi key/val cols + Rust time/diff, sorted/consolidated, +
+        `Description`) impl `BatchReader` (NO Cursor) + `Batch`/`Merger` (merge two batches & advance
+        times to compaction frontier, fuel-bounded) — the intricate core; test in isolation
+        mirroring `chunk/vec.rs`'s merger tests.
+        - [x] **Corgi light mod DONE** (branch `dd-arrange-api` in `wip/corgi`): exposed
+          `corgi::arrange::{gather, gather_lanes, compare_at}`. `compare_at` = scalar wrapper over
+          `compare_idx` (new, `ops/cmp/order.rs`); `mod order` → `pub(crate)`. **All 45 corgi tests
+          pass; interactive builds against it.** NOTE: `sort_perm`/`concat` are `#[cfg(test)]`-gated
+          → NOT used. Build a sort via Rust `indices.sort_by(|i,j| compare_at(kv,i,kv,j))`; build
+          merge output via `gather_lanes(&[Some(&kv1),Some(&kv2)], tags, off)` (avoids `concat`).
+          corgi structural order = leaf, Prod field-wise, List LENGTH-FIRST, Sum tag-then-payload —
+          a total order; consistent use is all correctness needs (compare as multisets, not vs DDIR Ord).
+        - [x] **`CorgiBatch` + merge DONE & TESTED** (`src/corgi_arrange.rs`): `CorgiBatch<T,R>`
+          (corgi key/val cols + Rust time/diff + `Description`) impl `BatchReader` (no Cursor);
+          `from_unsorted` (sort via `compare_at` + `gather`, consolidate); `merge` (two-pointer over
+          (k,v) groups via `compare_at`, per-group advance-to-frontier + consolidate in Rust, output
+          via `gather_lanes`). **Property test: 300 random merges == reference (union+advance+
+          consolidate); sort/consolidate test passes.** The intricate incremental core works over
+          corgi-native columns. (Eager merge — fuel/grading sophistication deferred; correctness first.)
+- [~] M2b-2: wire `CorgiBatch` into the DD trace machinery.
+      - [x] `Batch` + `Merger` (`CorgiMerger`, eager wrapper over `merge`) DONE & TESTED
+        (`merger_trait_drives` passes). KEY: `Batch`/`BatchReader`/`Builder` are blanket-impl'd for
+        `Rc<B>` (`trace/mod.rs:327` rc_blanket_impls), so `Spine<Rc<CorgiBatch>>` exists for free.
+      - [ ] `Builder` (DD trait) + `Batcher` + `arrange_core` wiring — the fiddliest plumbing
+        (Batcher/Chunker generics; `arrange_core` at `operators/arrange/arrangement.rs:346`).
+- [x] M2b-3 (mechanism, de-risk): `examples/corgi_reduce_trace.rs` — Route-B reduce MECHANISM
+      verified end-to-end over a manual corgi trace. Accumulate `CorgiBatch`es via `merge`
+      (consolidated per (key,val)); corgi **Count** reducer (GroupKey + `fold_add` over the diff
+      column — retractions just subtract; i64-as-u64 add is bit-correct). 4 steps incl. retraction
+      to zero (key vanishes) + multi-val key — **each step == reference. GREEN.** The full Route-B
+      reduce mechanism (trace-maintenance + corgi reduce) works; only the live-operator wiring remains.
+- [ ] M2b-2-finish + live tactics: **DECISION (Frank 2026-06-29): keep looping, do the FULL tactic
+      wiring** (arrange_core + reduce_with_tactic/join_with_tactic — the proper Route-B Backend). ← **NEXT**
+      Sub-plan (test each piece; expect several iterations; all mechanisms already proven):
+      - [x] **`Builder` DONE & TESTED** (`CorgiBatchBuilder`, `builder_builds_corgi_batch` passes):
+        `Input = Vec<((key,val),T,R)>` (rows), `Output = CorgiBatch`; `done`/`seal` transcode the
+        sorted chain → corgi columns via `build_batch` (`infer_shape`+`transcode`+`from_unsorted`).
+        `RcBuilder<CorgiBatchBuilder>` → `Rc<CorgiBatch>` (blanket).
+      - **DESIGN DECISION:** `Ba::Output = Vec<((key,val),T,R)>` (rows) → **reuse the existing
+        `MergeBatcher` + its vec-row `Merger`** (`merge_batcher.rs:283`) as the Batcher (big
+        simplification). Cost: one transcode rows→corgi at the Builder (arrangement-ingest boundary,
+        once per batch) — NOT operator-to-operator. The reduce/join tactics read corgi columns from
+        the stored `CorgiBatch`, so the corgi-native compute property holds. (A corgi batcher-side
+        Merger to drop even the ingest round-trip is a later optimization.)
+      - [x] **Batcher + chunker + `arrange_core` DONE — COMPILES & RUNS**
+        (`examples/corgi_arrange_smoke.rs`). `impl DrainContainer for CorgiContainer` (drain =
+        untranscode to rows) lets the stock `ContainerChunker<Vec<Upd>>` chunk a corgi-container
+        stream; Batcher = `MergeBatcher<VecMerger<(Value,Value),T,R>>` (reused, like ord_neu);
+        Builder = `RcBuilder<CorgiBatchBuilder>`; Trace = `Spine<Rc<CorgiBatch>>`. Full 6-generic
+        `arrange_core` wiring compiles and a 1000-update arrange runs clean. **The arrangement is wired.**
+      - [!] `CorgiReduceTactic::retire` — **WALL HIT (2026-06-29), surfaced to Frank.** DD's
+        incremental reduce core is `HistoryReplayer` (interesting-times algorithm, `reduce.rs:448-758`,
+        ~300 lines of DD's subtlest logic) and it is **cursor-coupled**: `compute` takes
+        `C1/C2/C3: Cursor`, `replay_key` walks cursors, and the default `CursorTactic` even *requires*
+        `B1: Navigable` (`reduce.rs:258`). A cursor-less Route-B reduce ⇒ reimplement that
+        interesting-times machinery over corgi columns — DD's hardest code, very high-risk to get
+        right unattended (partially-ordered iterative times). M2b-3 proved the SINGLE-TIME reduce
+        mechanism; the general multi-time incremental `retire` is the gap. Options for Frank: (a)
+        simplified single-time/totally-ordered CorgiReduceTactic (tractable, covers many DDIR reduces,
+        documents the limit); (b) HYBRID — give CorgiBatch a thin cursor, reuse the proven
+        `HistoryReplayer`/CursorTactic with corgi as the per-key `logic` (correct + general, but
+        reintroduces a cursor + per-key-slice transcode); (c) Frank designs the cursor-less `retire`.
+        NOTE: JOIN is likely more tractable cursor-less (bilinear, no interesting-times).
+        **DECISION (Frank 2026-06-29): option (c) — Frank designs the cursor-less `retire`.** Reduce
+        operator PAUSED pending his design; the M2b-3 mechanism + the arrangement are ready for it.
+      - [x] **JOIN MECHANISM DONE & TESTED** (`examples/corgi_join_mechanism.rs`): cursor-less
+        equijoin compute — merge-join two corgi batches' key columns via `compare_at`, cross-product
+        matched val runs via `gather`, multiply diffs (Rust). 300 randomized cases + a directed case
+        == reference hash-join, incl. retractions (negative product diffs). GREEN.
+      - [~] `CorgiJoinTactic::{defer,work}` + `join_with_tactic` — wrap the mechanism in the tactic:
+        - [x] **Skeleton COMPILES** (`src/corgi_join.rs`): `CorgiJoinTactic<T>` + `CorgiDeferred<T>`
+          + `defer` (queues bilinear units to todo0/todo1 by `Fresh`, sets advance flags) + stub
+          `work`, as a valid `impl JoinTactic<Rc<CorgiBatch>, Rc<CorgiBatch>, CB>`. Bound gotchas
+          resolved: `CB` is the **composite** `timely::ContainerBuilder` (not `timely::container::`),
+          + `CB: PushInto<((Row,Row),T,Diff)>` for `session.give`; structs need `T: Timestamp`
+          (hold `Capability<T>`). The generic-bound wiring is validated.
+        - [x] **`work` DONE + JOIN LIVE IN A REAL DATAFLOW** (`examples/corgi_join_dataflow.rs`):
+          `work` merges each side's batch list (`merge_one`), merge-joins by key (`compare_at`),
+          cross-products matched val runs (`gather`) with `t0.join(t1)` + `d0*d1`, runs the projection
+          corgi program (`compile_join_projection`, Var0=key/Var1=val0/Var2=val1), and emits via
+          `session_with_builder(&cap).give(((k,v),t,d))`. Wired with `join_with_tactic` over two
+          `arrange_core` corgi traces. **Output == reference hash-join incl. a retraction** (net-zero
+          `(2,6)` excluded → `{(1,110),(1,120),(2,205),(2,305)}`). **The cursor-less corgi JOIN
+          operator works end-to-end over corgi-native storage + compute via the #771–773 seam.**
+      - [ ] (old) `CorgiJoinTactic::{defer,work}` + `join_with_tactic` — wrap the mechanism in the tactic:
+        `defer` queues bilinear units (Vec<B0>×Vec<B1>, by `Fresh`) + capability + advance flags;
+        `work` drains under fuel, runs the join mechanism per unit, joins times via the lattice +
+        multiplies diffs, emits via the `OutputBuilderSession`/`JoinSession` (capability). Bilinear:
+        accumulate each side's batch list (merge to one run first). Test join in a real dataflow vs
+        reference. The output-session/capability + batch-list mgmt is fiddly timely plumbing —
+        surface if too subtle. ← **NEXT**
+      - M2b-2: `Batcher`/`Builder` + a `Spine<Rc<CorgiBatch>>`; `arrange` a collection.
+      - M2b-3: `CorgiReduceTactic::retire` runs the M2(a) reduce program in bulk over batches;
+        `reduce_with_tactic`; test incremental reduce (with retractions) vs reference.
+      - M2b-4: `CorgiJoinTactic` (defer/work); `join_with_tactic`; test vs reference.
+- [ ] M3: `impl Backend for CorgiBackend` + `render_tree` a real program vs `evaluate`.
+  - PARTIAL BACKEND (Frank's post-join step): Linear (M1) + arrange (M2b-2) + join (M2b-4) all work
+    live; reduce = Frank's design. A `Backend` impl with `reduce` stubbed (`todo!()`) + `render_tree`
+    on a reduce-free DDIR program (map/filter/join) would show corgi composing through the real DDIR
+    backend path. Full M3 (with reduce) awaits Frank's `retire`.
+    - [x] **Container bounds DONE** (`src/corgi_backend.rs`): `Negate` (negate diffs), `Enter<T,T>`/
+      `Leave<T,T>` (identity — DDIR same-Time dynamic model), `ResultsIn<T::Summary>` (map times via
+      `step.results_in`, drop `None` rows via `gather` of the corgi cols) — all generic, time/diff in
+      Rust. `CorgiContainer` now satisfies the `Backend::Container` bound. COMPILES.
+    - [x] **`Backend` impl SHAPE COMPILES** (`src/backend/corgi.rs`, `pub mod corgi` in backend/mod.rs):
+      `enum CorgiBackend` with `Container = CorgiContainer<Time,Diff>`, `Arr = Arranged<TraceAgent<
+      Spine<Rc<CorgiBatch<Time,Diff>>>>>`. `arrange` real (the arrange_core stack); linear/join/
+      as_collection/reduce/inspect/leave_dynamic = `todo!()`. A `render_tree::<CorgiBackend>` wrapper
+      compiles → **the full Backend wiring + render_tree bounds are validated.** Note: `leave_dynamic`
+      is Vec-specific in DD (`dynamic/mod.rs:40`, truncates per-record times) → corgi needs a custom
+      unary over `CorgiContainer.times`.
+    - [x] **`linear` + `join` bodies DONE (compile).** `linear` = container-level fold of LinearOps
+      (`apply_ops`: Project=corgi `eval_graph`, Filter=corgi mask+`gather`, Negate=Rust;
+      EnterAt/LiftIter/FlatMap=todo!). `join` = `join_with_tactic`+`CorgiJoinTactic` → Vec-rows →
+      ToCorgi unary → `Collection<Time,CorgiContainer>`. **CorgiBackend now implements ALL
+      non-reduce operators (linear/arrange/join real); reduce/as_collection/inspect/leave_dynamic =
+      todo!.** Compiles.
+    - [ ] REMAINING for an end-to-end `render_tree::<CorgiBackend>` run (pre-reduce PLUMBING):
+      `leave_dynamic` (custom unary truncating `CorgiContainer.times`), a corgi `evaluate` harness
+      (mirror `vec.rs:182` — ingest/iterative/render_tree/leave/capture/convert), `as_collection`
+      (cursor-less, if exports hit it), + a test program. NOTE: this harness will integrate with
+      Frank's reduce design, so best coordinated with it.
+
+## ★ PERF (2026-07-01): END-TO-END corgi vs vec — nuanced; compute wins, arrange loses ★
+`examples/corgi_perf.rs` — `corgi::evaluate` vs `vec::evaluate`, median wall-clock, single worker,
+release. (Phase-1's 50–135× was EVAL-ONLY microbench; end-to-end the scalar eval is a small slice.)
+```
+scenario              n         vec        corgi      verdict
+linear-compute-8x     100k     157.6ms     48.6ms     corgi 3.2x FASTER   (8 wide maps, NO arrange)
+linear-compute-8x      20k      31.0ms      8.7ms     corgi 3.6x FASTER
+linear-heavy          100k     113.4ms    136.0ms     corgi 1.2x slower   (3 maps+filter+ARRANGE)
+linear-heavy           20k      21.4ms     23.3ms     corgi 1.1x slower
+reach                 4000      13.9ms     43.6ms     corgi 3.1x slower   (recursion: join+distinct)
+reach                 1000       3.6ms     11.6ms     corgi 3.2x slower
+reach                  200       0.86ms     2.0ms     corgi 2.4x slower
+```
+**Read:** (1) corgi's columnar scalar logic is a REAL end-to-end win (~3.2–3.6×) when scalar compute
+dominates and data stays columnar between ops (deep linear chain, no arrange) — even paying transcode
+in/out. (2) But the ARRANGEMENT machinery dominates real programs: add ONE arrange to the linear chain
+and the 3× win collapses to ~parity (the arrange is the swing factor — same chain, ±arrange). (3)
+Recursive/join-heavy programs are 2–3× SLOWER. WHY corgi loses on arrange-heavy/recursive:
+- **corgi's arrange is correctness-first, unoptimized:** `CorgiMerger` does the whole merge on the first
+  `work` call (no fuel/batching), the sort is a discrimination sort over corgi columns, and every merge
+  re-materializes columns via `gather_lanes`. DD's `ValSpine` (vec backend) is a mature fueled spine.
+- **join/reduce run ROW-WISE anyway:** the join tactic emits via `session.give` per row; reduce runs
+  the DDIR reducer in Rust over per-key slices + `active_times` OVER-derives interesting times. So corgi
+  pays transcode/untranscode at these boundaries with NO columnar compute win to offset it.
+- **eval isn't the bottleneck** in these programs (narrow rows, few arith ops/key), so accelerating it
+  (corgi's strength) barely moves end-to-end wall-clock, while the transcode tax is pure overhead.
+**Takeaway:** the corgi-as-scalar-logic thesis is validated where it should hold (compute-bound wide
+linear work: 3×+), but a corgi backend only beats vec end-to-end if the arrangement layer is also made
+competitive (fueled merge, keep join/reduce columnar) — otherwise arrange/transcode overhead dominates.
+Next perf levers, in impact order: fueled/batched `CorgiMerger`; columnar join emit (build corgi cols
+directly, skip `session.give` row round-trip); columnar reduce (avoid untranscode per key). ----
+
+## ★★★★ M5 DONE (2026-06-30): ALL 6 CANONICAL PROGRAMS RUN == vec (Sum rung landed) ★★★★
+binders now passes — columnar Variant (the Sum rung) is implemented. The corgi backend renders every
+canonical `.ddp` (`reach, scc, stable, unnest, adt, binders`) identically to vec. 32 interactive tests
+(+4 Sum round-trip), all 5 corgi dataflow examples, 27 corgi tests — all green.
+
+**The Sum rung (DDIR `Variant` ↔ corgi `Value::Sum`), all in `corgi_logic.rs`:**
+- `infer_shape_cols(rows)` — NEW all-rows column scan (vs `infer_shape`'s single sample): a `Variant`
+  column's `Shape::Sum` is the union of every arm that appears (a sample shows only one tag), so it
+  scans, building one lane per `0..=max_tag` (absent tag → `None` = ⊥). `from_updates` now uses it.
+- `transcode` `Sum` arm: per-row tag column + one packed lane per committed variant (its rows in row
+  order); `Value::sum_opt(tags, lanes)` derives each row's within-lane offset; absent arms stay ⊥.
+- `untranscode` `Sum` arm: untranscode each committed lane, then per row pull its payload from its lane
+  at the recorded OFFSET (robust to gather/merge reordering — not a sequential cursor). Uses the public
+  `Value::into_sum`/`sum_opt` — NO corgi mod needed (engine already had Sum gather/compare/merge).
+- transcode/untranscode are now TOTAL over `Shape` (Prim/Unit/Prod/List/Sum) — dead catch-alls removed.
+In binders the Sum column is created by the row-wise `key` Project (`Node(list ...)`) and consumed one
+op later by the row-wise `map`'s `case` (into_updates→ir::eval), so its full lifecycle is transcode+
+untranscode; merge/gather over Sum columns aren't exercised by these programs (corgi engine supports
+them, but that path is unverified here). `LiftIter` is implemented but untested (no program uses it).
+**No remaining backend todo!s; Variant no longer a gap.** ---- previous milestones below ----
+
+## ★★★ M4 (2026-06-30): REAL CANONICAL PROGRAMS RUN — 5/6 == vec backend ★★★
+All backend `todo!`s cleared; the corgi backend now runs real `.ddp` programs (incl. RECURSIVE ones)
+end-to-end and matches vec. `examples/corgi_progs.rs` (PROG=<name> or all) + `examples/corgi_reach.rs`:
+```
+reach   OK   (recursion: feedback var + join + distinct + concat + leave_dynamic)
+scc     OK   (recursion + enter_at + min + nested scopes + negate)
+stable  OK   (recursion + min + arrange)
+unnest  OK   (flatmap + collect: List round-trip through the relational layer)
+adt     OK   (con/case/Inject — variant is transient, eliminated within one ir::eval)
+binders FAIL (persists a Variant IN a collection → needs columnar Sum; the known "later rung")
+```
+**Backend todo!s cleared this milestone:**
+1. **`leave_dynamic`** — custom `OperatorBuilder` unary mirroring DD's `dynamic/mod.rs:40`: strips all
+   but `level-1` PointStamp coords from the capability AND each `CorgiContainer.times` entry; sets the
+   input connection summary `retain: Some(level-1)` so progress tracking stays correct. UNLOCKS all
+   recursive programs.
+2. **`EnterAt`/`LiftIter`/`FlatMap`** — correctness-first ROW-WISE path in `apply_ops` (untranscode →
+   vec-style transform → `from_updates`), parity with `backend::vec::render_linear`; `level` threaded
+   in. (Columnar fast-path is future; these are corner ops.)
+3. **Row-wise Project/Filter fallback** — `corgi_logic::compilable(term)` gates: terms the corgi
+   compiler can't lower (List, Case/Inject, Unary, Hash) fall back to `ir::eval` (parity with vec),
+   keeping the columnar fast-path for the common case. UNLOCKS unnest's `list(...)` projection + adt's
+   `case`. `untranscode` gained a `List` arm (inverse of transcode: ends + flat → per-row Lists).
+4. **Collect / as_collection / inspect** — already worked.
+
+**THE BIG BUG fixed en route (affected ALL unit-valued data):** the compiler emitted an empty tuple
+`Term::Tuple([])` (DDIR unit) as corgi `Prod([])` — an empty product with NO row-count witness — so
+any unit key/val silently produced ZERO rows downstream (`key($0[0];)`, `key(;)`, distinct/count
+outputs, concat of unit collections). Fix: `compile` emits `Op::Unit` over the anchor (a length-
+carrying `Unit` column) for an empty field list. This is why `reach`/`distinct` initially returned
+empty. NOTE: ill-typed CONCAT of heterogeneous val shapes (e.g. `Prod[Prim]` + `Unit`) still can't be
+columnar (vec tolerates it via dynamic typing); real programs keep concat operands shape-uniform.
+
+REMAINING (the Sum rung, clearly scoped, NOT a backend todo!): columnar Variant — `Shape::Sum` in
+`infer_shape`(needs to SCAN all rows for arms, not just sample row[0])/`transcode`/`untranscode`. corgi's
+engine already has Sum `gather`/`compare`/merge arms; only the DDIR transcode layer lacks them. Only
+`binders` needs it (persists a variant in a collection). `LiftIter` is implemented but untested (no
+canonical program uses it). ---- previous milestones below ----
+
+## ★★ M3 DONE (2026-06-30): END-TO-END render_tree::<CorgiBackend> == vec backend ★★
+A whole flat DDIR program runs through the corgi backend and matches the vec backend exactly:
+```
+let a = input 0 | key($0[0] ; $0[1]);
+let b = input 1 | key($0[0] ; $0[1]);
+let j = a | join(b, ($0 ; tuple($1, $2)));
+export "join" = j;  export "count" = j | count;  export "filtered" = j | filter($0 != 2);
+```
+`examples/corgi_program.rs`: `corgi::evaluate(&prog,&inputs) == vec::evaluate(&prog,&inputs)` for all
+three exports (join 3 rows, count 2 rows, filtered 3 rows). Exercises Linear (key/filter), join, AND
+reduce(count) composed via the real DDIR `render_tree` path. All 5 corgi examples + 28 interactive +
+27 corgi tests pass.
+
+**Three issues found & fixed making the end-to-end work (all in `corgi_logic.rs`/`corgi_arrange.rs`):**
+1. **`Spread` in projections** — DDIR's parser makes EVERY projection key/val a `Term::Tuple`, and a
+   bare `$n` field becomes `Term::Spread(Var n)` (flat-row splice). The map/filter-core compiler didn't
+   handle `Spread`. Fix: shape-directed compile — `compile`/`compile_projection`/`compile_predicate`/
+   `compile_join_projection` now take `env_shapes: &[Shape]`; the `Tuple` arm splices a `Spread`'s
+   `Prod` fields via `shape_of_place`. Tactics/`apply_ops` pass shapes from `shape_of_value` of the
+   actual columns (so the join tactic now holds key/val `Term`s and compiles per work-unit).
+2. **Empty-batch shape mismatch in `merge`** — `Batch::empty` carries a `Unit(0)` placeholder shape;
+   the spine merges empties with real batches → `gather_lanes`' cross-source shape check panicked. Fix:
+   substitute the non-empty side's `kv` for any empty source (never indexed, since no tag points to it).
+3. **Cross-shape `Eq`/`Ne`** — `filter($0 != 2)` compares the 1-tuple key (`Prod[Prim]`) to `Int 2`
+   (`Prim`); vec does structural `Value` compare (always-unequal), but corgi's `CmpOp::Rel` needs equal
+   shapes. Fix: `infer_term_shape` + fold cross-shape `Eq`→0 / `Ne`→1 to a constant column.
+
+NOTE: keys/vals are ALWAYS tuples (`Prod`) in real DDIR programs (parser wraps every projection field
+list in `Term::Tuple`). The earlier hand-built examples used scalar keys; the backend handles both.
+Remaining backend `todo!`: `leave_dynamic` (only needed for SUB-SCOPE/iterative programs — flat
+programs never reach it), and `EnterAt`/`LiftIter`/`FlatMap` linear ops + `Collect` reducer + Variant.
+
+## ★ PHASE 2 STATUS (2026-06-29): corgi backend — operators LIVE except reduce ★
+Built & tested, all over corgi-native storage + `eval_graph` compute, cursor-less (Route B):
+- **Linear** — corgi-native container + map/filter in a real dataflow, no inter-op transcode (M1).
+- **arrange** — `arrange_core` → `Spine<Rc<CorgiBatch>>` (CorgiBatch: BatchReader/Batch/Merger/Builder;
+  merge 300-case property test; reused `MergeBatcher`; one rows→corgi transcode at ingest-boundary).
+- **join** — `CorgiJoinTactic` + `join_with_tactic`, LIVE in a real dataflow == reference (incl.
+  retraction); merge-join + cross-product + projection all over corgi columns via the #771–773 seam.
+- **reduce** — ✅ **DONE (cursor-less, live)** via Frank's `active_times`: `CorgiReduceTactic`
+  (`src/corgi_reduce.rs`) + `reduce_with_tactic`, wired in `Backend::reduce`. retire = per changed
+  key → `active_times` (over-deriving join-closure) → at each active time accumulate input-as-of-t,
+  run the reducer (Rust DDIR reducers, matching vec), diff vs (output + emitted-so-far), route to
+  held buckets; pended→held frontier. Test `examples/corgi_reduce_dataflow.rs`: directed Count
+  (retraction-to-zero) + **120 randomized Count == reference** + Min/Distinct (min changes under
+  retraction). Needed a 1-line corgi mod: `Unit` arm in `compare_idx` (Distinct's unit payload).
+- corgi light mod: `corgi::arrange::{gather, gather_lanes, compare_at}` (branch `dd-arrange-api`; 45 tests pass).
+Verdict: Route B (cursor-less corgi batch + custom tactics) is VALIDATED for **all four operators —
+Linear, arrange, join, AND reduce** — each live in a real dataflow over corgi-native storage via the
+#771–773 seam, tested vs reference. `Backend for CorgiBackend` implements linear/arrange/join/reduce
+(as_collection/inspect/leave_dynamic still todo!, only needed for an end-to-end render_tree harness).
+Files: `interactive/src/corgi_{logic,backend,arrange,join,reduce}.rs` + `backend/corgi.rs`; corgi
+mods on branch `dd-arrange-api` (`arrange` facade + `compare_idx` Unit arm).
+
+### M2(b) FORK — the incremental arrangement (the big build); routes:
+- **Route A (Chunk trait, à la `chunk/vec.rs`):** impl `Chunk` over corgi columns → free
+  Batcher/Builder/Spine + reuses DD's fueled merge/advance/settle harness. BUT requires a `Cursor`
+  (Navigable), and `Cursor`'s assoc types are `BatchContainer`/`Layout`-bound (`chunk/vec.rs` leans
+  entirely on `Vector<((K,V),T,R)>`). corgi columns are NOT `BatchContainer`s → heavy glue
+  (impl BatchContainer for corgi leaves, or store a parallel DD-container copy for navigation).
+- **Route B (cursor-less, the #771–773 seam):** corgi batch = `BatchReader` only (len/description,
+  NO Cursor) + a custom `ReduceTactic`/`JoinTactic` that reads corgi columns in BULK (eval_graph,
+  GroupKey) + `Batch`/`Merger` over corgi columns (merge/advance via corgi sort). Avoids the
+  BatchContainer glue entirely (plays to corgi's bulk nature) BUT reimplements the incremental
+  merge/advance + the tactic defer/work/retire protocols.
+- Both are large + intricate (fueled merge, frontier/capability mgmt) — the high-risk core where
+  Frank's review matters. Recommendation: **Route B** (genuine use of the cursor-less tactic seam;
+  corgi is bulk-columnar, not step-navigated; sidesteps the Cursor↔BatchContainer impedance).
+  Trade: reimplement incremental merge vs fight the container glue. Awaiting Frank's routing.
+
+### RUNG 4 RESULTS (chain of K Linear `x->x+c` ops, n=100k, ns/row over whole chain)
+| K | interp | per-op xcode | columnar | col vs interp | col vs per-op |
+|---|---|---|---|---|---|
+| 1 | 25.7 | 5.8 | 2.9 | 9.0× | 2.0× |
+| 4 | 75.0 | 14.2 | 5.0 | 15.1× | 2.9× |
+| 16 | 282.9 | 44.8 | 12.6 | 22.5× | 3.6× |
+
+**Conclusion:** columnar ≈ `2·xcode + K·eval` (flat-ish); per-op ≈ `K·(2·xcode + eval)`; interp
+steepest. So the **deeper the program, the bigger the corgi win**, and storing data corgi-columnar
+(amortizing transcode across ops) beats per-op transcode 2–3.6× and widening. Strong case for a
+corgi-data CHUNK/container once the scalar-logic path exists.
+
+### ARCHITECTURE FINDING — where corgi-columnar data should live
+- The `Chunk` trait (arrangement storage, #744) **requires `Navigable<Cursor: Cursor>`**
+  (`trace/chunk/mod.rs:73`). So a corgi-columnar *arrangement via `Chunk`* must still implement a
+  cursor — it is NOT the "cursor-less batch." Route A (via `Chunk`): write a corgi cursor + the 5
+  chunk ops (merge/extract/advance/settle/bounds), get Batcher/Builder/Spine free; add a bulk
+  columnar accessor for the corgi fast path. Most reuse; you write a cursor.
+- The genuinely **cursor-less** path is the operator layer (#771–773): `join_with_tactic`/
+  `reduce_with_tactic` need only `BatchReader` (`len`/`description`), not `Navigable`. Route B: a
+  corgi container holding columns + `Batch`/`Merger` over corgi's own sort/merge + a custom tactic
+  that bulk-applies corgi. Maximal "no cursor"; you reimplement merge/advance + the tactic.
+- For Frank's stated goal (corgi = the *scalar logic*, not the navigator), neither is needed to
+  START: rungs 1–3 run over ANY existing arrangement via per-call transcode. corgi-columnar storage
+  (A or B) is the *optimization* that removes the transcode the rung-4 bench shows dominates.
+- Rung 3 (reduce) DEPRIORITIZED: the reduce closure already receives a per-key column slice
+  `&[(val,diff)]` (`reduce.rs:651`), so corgi-as-reducer is the *same* mechanism proven in rungs
+  1–2; building it adds marginal evidence vs the CHUNK question Frank explicitly asked.
+
+### RUNG 1 RESULTS (release, non-negative ints, rows = Tuple([a,b]))
+| metric | map (a+b, a*3) | filter (a<b) |
+|---|---|---|
+| crossover (corgi eval beats interp) | ~10 rows | ~10 rows |
+| corgi eval-only peak speedup | **79× @10k** | **135× @100k** |
+| corgi eval ns/row (≥1k) | 0.8–1.6 | 0.3–0.6 |
+| interp ns/row | 61–73 | 37–40 |
+| **with per-call transcode** | 6–11× | 4–7× |
+| transcode share of corgi-total @1M | ~85% (1.6 vs 12 ns/row) | ~95% (0.6 vs 10.6) |
+
+**Conclusions (measured):**
+1. corgi-as-columnar-scalar-logic is a **large win** — 50–135× on eval past the ~10-row crossover.
+   Any real batch (100s–1000s of rows) is far past crossover. Below ~10 rows corgi loses to
+   `eval_graph` per-call setup (n=1: 0.23–0.27×).
+2. **The transcode (`&[ir::Value]`→corgi columns) dominates** the corgi-as-closure model — ~10
+   ns/row, ~85–95% of total at scale. So in the naive per-call-transcode form the win is capped at
+   ~4–11×. **To unlock the full 50–135×, data must already be corgi-columnar → motivates the
+   corgi-data CHUNK (rung 4); the per-call transcode is exactly what storing columns removes.**
+3. Compile is direct: the map/filter core is ~1:1 onto corgi ops; `infer_shape` handles the
+   dynamic typing (Shape from data). No corgi modification needed for this subset.
+
+### Open questions
+1. ~~Crossover width~~ → ~10 rows. (ANSWERED)
+2. ~~Transcode cost~~ → dominates (~85–95% at scale). (ANSWERED — drives rung-4 case)
+3. How rich a `Term` subset for real programs (datalog/eqsat need Variant/List/Fold/Hash)? (OPEN)
+4. Does it run inside a real DD dataflow, and does corgi-columnar storage actually remove the
+   transcode in that setting? (rung 2 → rung 4)
diff --git a/interactive/Cargo.toml b/interactive/Cargo.toml
index 8ada1d0aa..1403deb9c 100644
--- a/interactive/Cargo.toml
+++ b/interactive/Cargo.toml
@@ -13,6 +13,7 @@ workspace = true
 
 [dependencies]
 columnar = { workspace = true }
+corgi = { path = "../../wip/corgi" }
 differential-dataflow = { workspace = true }
 mimalloc = "0.1.48"
 serde = { version = "1.0", features = ["derive"] }
diff --git a/interactive/examples/corgi_arrange_smoke.rs b/interactive/examples/corgi_arrange_smoke.rs
new file mode 100644
index 000000000..f7e6264f4
--- /dev/null
+++ b/interactive/examples/corgi_arrange_smoke.rs
@@ -0,0 +1,69 @@
+//! M2(b) arrange wiring: arrange a corgi-container collection into a `Spine<Rc<CorgiBatch>>` via
+//! `arrange_core`, reusing DD's `MergeBatcher`+`VecMerger` (Batcher) and `ContainerChunker` (the
+//! container drains corgi→rows), with `CorgiBatchBuilder` transcoding the sorted chain → corgi
+//! columns at build. Milestone: it COMPILES and RUNS (content correctness comes with reduce).
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_arrange_smoke
+
+use std::rc::Rc;
+
+use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::*;
+
+use differential_dataflow::input::Input;
+use differential_dataflow::operators::arrange::arrangement::arrange_core;
+use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::trace::implementations::spine_fueled::Spine;
+use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
+
+use interactive::corgi_arrange::{CorgiBatch, CorgiBatchBuilder};
+use interactive::corgi_backend::CorgiContainer;
+use interactive::ir::{Diff, Value as DValue};
+
+type Row = DValue;
+type Upd = ((Row, Row), u64, Diff);
+type CC = CorgiContainer<u64, Diff>;
+type Trace = Spine<Rc<CorgiBatch<u64, Diff>>>;
+
+fn main() {
+    // Unique (key,val) so nothing consolidates away; all at time 0.
+    let data: Vec<(Row, Row)> = (0..1000).map(|i| (DValue::Int(i), DValue::Int(i * 2))).collect();
+    let n = data.len();
+
+    timely::execute_directly(move |worker| {
+        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
+            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
+
+            // ingest: rows -> CorgiContainer
+            let corgi_stream = coll.inner.unary(Pipeline, "ToCorgi", |_, _| {
+                |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
+                        output.session(&cap).give_container(&mut c);
+                    });
+                }
+            });
+
+            // arrange the corgi-container stream into a corgi-columnar trace.
+            let _arranged = arrange_core::<
+                _,
+                CC,
+                ContainerChunker<Vec<Upd>>,
+                MergeBatcher<VecMerger<(Row, Row), u64, Diff>>,
+                RcBuilder<CorgiBatchBuilder<u64, Diff>>,
+                Trace,
+            >(corgi_stream, Pipeline, "CorgiArrange");
+
+            handle
+        });
+        for r in data {
+            handle.update(r, 1);
+        }
+    });
+
+    println!("M2(b) arrange: arrange_core over corgi containers COMPILED and RAN.");
+    println!("  fed {n} unique (key,val) updates → Spine<Rc<CorgiBatch>> (corgi-columnar trace).");
+    println!("  Batcher = reused MergeBatcher<VecMerger>; Builder transcodes rows→corgi at ingest.");
+}
diff --git a/interactive/examples/corgi_backend_linear.rs b/interactive/examples/corgi_backend_linear.rs
new file mode 100644
index 000000000..b9eefa0f2
--- /dev/null
+++ b/interactive/examples/corgi_backend_linear.rs
@@ -0,0 +1,142 @@
+//! M1: corgi as DDIR's NATIVE representation inside a real dataflow. Rows enter, are transcoded
+//! to a `CorgiContainer` ONCE (ingest boundary), flow through K corgi-native Linear (Project)
+//! operators — each `eval_graph` over the corgi columns, ZERO inter-operator transcode — and are
+//! read back ONCE (egress boundary). Verified vs the per-row `ir::eval` interpreter; timed.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_backend_linear
+
+use std::collections::BTreeMap;
+use std::time::Instant;
+
+use timely::dataflow::operators::*;
+use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::capture::{Capture, Event};
+
+use interactive::corgi_backend::CorgiContainer;
+use interactive::corgi_logic::{compile_projection, infer_shape};
+use interactive::ir::{self, Diff, Value as DValue};
+use interactive::parse::{BinOp, Term};
+
+use corgi::Value as CValue;
+
+type Row = DValue;
+type CC = CorgiContainer<u64, Diff>;
+
+fn main() {
+    // Project: key'=key (Var0 passthrough), val'=(a+b, a*3) over val=(a,b) (Var1). Shape-stable
+    // (val stays a 2-tuple of ints), so it chains K times.
+    let a = || Box::new(Term::Proj(Box::new(Term::Var(1)), 0));
+    let b = || Box::new(Term::Proj(Box::new(Term::Var(1)), 1));
+    let key_term = Term::Var(0);
+    let val_term = Term::Tuple(vec![
+        Term::Binary(BinOp::Add, a(), b()),
+        Term::Binary(BinOp::Mul, a(), Box::new(Term::Int(3))),
+    ]);
+
+    let k = 8usize;
+    let n = 100_000usize;
+    let data: Vec<(Row, Row)> = (0..n)
+        .map(|i| {
+            (
+                DValue::Int((i % 10) as i64),
+                DValue::Tuple(vec![DValue::Int((i % 100) as i64), DValue::Int(((i * 7) % 97) as i64)]),
+            )
+        })
+        .collect();
+
+    // ---- run the corgi-native dataflow ----
+    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
+    let data_in = data.clone();
+    let (kt, vt) = (key_term.clone(), val_term.clone());
+    let t0 = Instant::now();
+    timely::execute_directly(move |worker| {
+        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
+            use differential_dataflow::input::Input;
+            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
+
+            // ingest boundary: rows -> CorgiContainer (transcode once)
+            let mut corgi_stream = coll.inner.unary(Pipeline, "ToCorgi", |_, _| {
+                |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
+                        output.session(&cap).give_container(&mut c);
+                    });
+                }
+            });
+            // K corgi-native Linear ops — eval_graph over corgi columns, no transcode between them
+            // Shapes are stable across the K iterations (key=Prim, val=Prod[Prim,Prim]).
+            let (kshape, vshape) = (infer_shape(&data_in[0].0), infer_shape(&data_in[0].1));
+            for _ in 0..k {
+                let graph = compile_projection(&kt, &vt, &kshape, &vshape);
+                corgi_stream = corgi_stream.unary(Pipeline, "CorgiProject", move |_, _| {
+                    move |input, output| {
+                        input.for_each(|cap, data| {
+                            let c: CC = std::mem::take(data);
+                            let mut out = if c.times.is_empty() {
+                                c
+                            } else {
+                                let inp = CValue::Prod(vec![c.keys, c.vals]);
+                                let mut cols = corgi::eval_graph(&graph, inp).into_prod("project");
+                                let nv = cols.pop().unwrap();
+                                let nk = cols.pop().unwrap();
+                                CorgiContainer { keys: nk, vals: nv, times: c.times, diffs: c.diffs }
+                            };
+                            output.session(&cap).give_container(&mut out);
+                        });
+                    }
+                });
+            }
+            // egress boundary: CorgiContainer -> rows (transcode once)
+            corgi_stream
+                .unary(Pipeline, "FromCorgi", |_, _| {
+                    |input, output| {
+                        input.for_each(|cap, data| {
+                            let mut updates = std::mem::take(data).into_updates();
+                            output.session(&cap).give_container(&mut updates);
+                        });
+                    }
+                })
+                .capture_into(tx);
+            handle
+        });
+        for r in data_in {
+            handle.update(r, 1);
+        }
+    });
+    let elapsed = t0.elapsed();
+
+    let mut got: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for event in rx {
+        if let Event::Messages(_, d) = event {
+            for ((k, v), _, df) in d {
+                *got.entry((k, v)).or_insert(0) += df;
+            }
+        }
+    }
+    got.retain(|_, d| *d != 0);
+
+    // ---- reference: interpreter, K-chain per row ----
+    let mut want: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for (k0, v0) in &data {
+        let (mut ck, mut cv) = (k0.clone(), v0.clone());
+        for _ in 0..k {
+            let mut env = vec![ck.clone(), cv.clone()];
+            let nk = ir::eval(&key_term, &mut env);
+            let nv = ir::eval(&val_term, &mut env);
+            ck = nk;
+            cv = nv;
+        }
+        *want.entry((ck, cv)).or_insert(0) += 1;
+    }
+    want.retain(|_, d| *d != 0);
+
+    assert_eq!(got, want, "corgi-native dataflow output != interpreter reference");
+
+    println!("M1: corgi-native Linear chain inside a real DD dataflow");
+    println!("  K (chained Project ops): {k}");
+    println!("  input rows:              {n}");
+    println!("  output rows:             {}", got.len());
+    println!("  matches interpreter:     YES");
+    println!("  transcodes:              2 (ingest + egress) — ZERO between the {k} operators");
+    println!("  wall-clock:              {elapsed:?}");
+}
diff --git a/interactive/examples/corgi_bench.rs b/interactive/examples/corgi_bench.rs
new file mode 100644
index 000000000..86b8e7adf
--- /dev/null
+++ b/interactive/examples/corgi_bench.rs
@@ -0,0 +1,227 @@
+//! Rung 1: compile a DDIR scalar `Term` to a corgi `Graph<NumOp>`, run it columnar, and
+//! measure it against DDIR's per-row `ir::eval` interpreter — sweeping column width to find
+//! the crossover. Also measures the AoS->SoA transcode tax (open question: does it dominate?).
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_bench
+//!
+//! Subset supported in this rung: the map/filter core over non-negative ints —
+//! Var/Proj/Int/Tuple/Binary(arith,cmp,logical)/If. Variant/List/Fold/Hash are later rungs.
+
+use std::time::Instant;
+
+use interactive::ir::{self, Value as DValue};
+use interactive::parse::{BinOp, Term};
+
+use corgi::{ArithOp, BinOp as CBinOp, Builder, CmpOp, Kind, NumOp, Op, Pred, Shape, Value as CValue};
+
+// ---------- shape inference (the dynamic-typing primitive: observe data -> Shape) ----------
+
+fn infer_shape(sample: &DValue) -> Shape {
+    match sample {
+        DValue::Int(_) => Shape::Prim(64),
+        DValue::Tuple(xs) => Shape::Prod(xs.iter().map(infer_shape).collect()),
+        DValue::List(xs) => Shape::List(Box::new(infer_shape(xs.first().expect("nonempty list")))),
+        DValue::Variant(..) => panic!("variant shape inference is a later rung"),
+    }
+}
+
+// ---------- AoS rows -> SoA corgi columns, directed by the inferred shape ----------
+
+fn transcode(rows: &[DValue], shape: &Shape) -> CValue {
+    match shape {
+        Shape::Prim(_) => CValue::u64(rows.iter().map(|r| r.as_int() as u64).collect()),
+        Shape::Prod(field_shapes) => {
+            let cols = field_shapes
+                .iter()
+                .enumerate()
+                .map(|(i, fs)| {
+                    let sub: Vec<DValue> = rows
+                        .iter()
+                        .map(|r| match r {
+                            DValue::Tuple(xs) => xs[i].clone(),
+                            other => panic!("transcode: expected Tuple, got {other:?}"),
+                        })
+                        .collect();
+                    transcode(&sub, fs)
+                })
+                .collect();
+            CValue::Prod(cols)
+        }
+        other => panic!("transcode: shape not supported in this rung: {other:?}"),
+    }
+}
+
+// ---------- the compiler: Term -> corgi node (flat, columnar) ----------
+// `env[i]` is the node for `Var(i)`; binders (none yet in this subset) would push on top.
+// `anchor` is any node used to broadcast `Lit` to the column length.
+
+fn compile(term: &Term, b: &mut Builder<NumOp>, env: &[usize], anchor: usize) -> usize {
+    match term {
+        Term::Var(i) => env[*i],
+        Term::Bound(k) => env[env.len() - 1 - *k],
+        Term::Int(n) => b.add(Op::Lit(CValue::u64(vec![*n as u64])), vec![anchor]),
+        Term::Tuple(fields) => {
+            let ids: Vec<usize> = fields.iter().map(|f| compile(f, b, env, anchor)).collect();
+            b.tuple(ids)
+        }
+        Term::Proj(t, i) => {
+            let id = compile(t, b, env, anchor);
+            b.add(Op::Field(*i), vec![id])
+        }
+        Term::Binary(op, l, r) => {
+            let lid = compile(l, b, env, anchor);
+            let rid = compile(r, b, env, anchor);
+            let pair = |b: &mut Builder<NumOp>, x, y| b.tuple(vec![x, y]);
+            match op {
+                BinOp::Add => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Add, Kind::U, 64), vec![p]) }
+                BinOp::Sub => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Sub, Kind::U, 64), vec![p]) }
+                BinOp::Mul => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Mul, Kind::U, 64), vec![p]) }
+                BinOp::Eq => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Eq), vec![p]) }
+                BinOp::Ne => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Ne), vec![p]) }
+                BinOp::Lt => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Lt), vec![p]) }
+                BinOp::Le => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Le), vec![p]) }
+                BinOp::Gt => { let p = pair(b, rid, lid); b.add(CmpOp::Rel(Pred::Lt), vec![p]) } // a>b == b<a
+                BinOp::Ge => { let p = pair(b, rid, lid); b.add(CmpOp::Rel(Pred::Le), vec![p]) } // a>=b == b<=a
+                BinOp::And => { let p = pair(b, lid, rid); b.add(CmpOp::Min, vec![p]) } // 0/1 masks
+                BinOp::Or => { let p = pair(b, lid, rid); b.add(CmpOp::Max, vec![p]) }
+            }
+        }
+        Term::If { cond, then, els } => {
+            let c = compile(cond, b, env, anchor);
+            let t = compile(then, b, env, anchor);
+            let e = compile(els, b, env, anchor);
+            let sel = b.tuple(vec![c, t, e]);
+            b.add(Op::Select, vec![sel])
+        }
+        other => panic!("compile: unsupported Term in this rung: {other:?}"),
+    }
+}
+
+/// Build the full graph for `term`. `Var(0)` = the whole input row. The graph is
+/// shape-independent in this subset (corgi resolves layout at eval); shape drives transcode.
+fn build_graph(term: &Term) -> corgi::Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input();
+    let env = vec![input]; // Var(0) is the input column
+    let out = compile(term, &mut b, &env, input);
+    b.finish(out)
+}
+
+// ---------- timing ----------
+
+fn bench<F: FnMut()>(n: usize, mut f: F) -> f64 {
+    let reps = (4_000_000 / n.max(1)).max(5);
+    f(); // warmup
+    let t = Instant::now();
+    for _ in 0..reps {
+        f();
+    }
+    t.elapsed().as_secs_f64() / reps as f64 // seconds per call
+}
+
+fn per_row_ns(secs_per_call: f64, n: usize) -> f64 {
+    secs_per_call * 1e9 / n as f64
+}
+
+fn main() {
+    // Two representative scalar programs over rows of shape Tuple([a, b]) (Var(0) = the row):
+    let a = || Box::new(Term::Proj(Box::new(Term::Var(0)), 0));
+    let bb = || Box::new(Term::Proj(Box::new(Term::Var(0)), 1));
+
+    // MAP:    (a + b, a * 3)
+    let term_map = Term::Tuple(vec![
+        Term::Binary(BinOp::Add, a(), bb()),
+        Term::Binary(BinOp::Mul, a(), Box::new(Term::Int(3))),
+    ]);
+    // FILTER: a < b   (produces the 0/1 keep-mask)
+    let term_filter = Term::Binary(BinOp::Lt, a(), bb());
+
+    for (name, term) in [("map (a+b, a*3)", &term_map), ("filter a<b", &term_filter)] {
+        println!("\n=== {name} ===");
+        println!(
+            "{:>10} {:>12} {:>12} {:>12} {:>10} {:>10}",
+            "rows", "interp ns/r", "corgi ns/r", "+xcode ns/r", "speedup", "w/xcode"
+        );
+        let g = build_graph(term);
+
+        for &n in &[1usize, 10, 100, 1_000, 10_000, 100_000, 1_000_000] {
+            let rows: Vec<DValue> = (0..n)
+                .map(|i| DValue::Tuple(vec![DValue::Int((i % 1000) as i64), DValue::Int(((i * 7) % 997) as i64)]))
+                .collect();
+            let shape = infer_shape(&rows[0]); // dynamic typing: form the corgi Shape from the data
+
+            // baseline: per-row interpreter
+            let interp = bench(n, || {
+                let mut out = Vec::with_capacity(n);
+                for r in &rows {
+                    let mut env = vec![r.clone()];
+                    out.push(ir::eval(term, &mut env));
+                }
+                std::hint::black_box(&out);
+            });
+
+            // corgi eval only (input pre-transcoded; clone = cheap Arc bumps)
+            let input = transcode(&rows, &shape);
+            let corgi_eval = bench(n, || {
+                let out = corgi::eval_graph(&g, input.clone());
+                std::hint::black_box(&out);
+            });
+
+            // corgi total: transcode each call + eval (the rung-1 tax)
+            let corgi_total = bench(n, || {
+                let inp = transcode(&rows, &shape);
+                let out = corgi::eval_graph(&g, inp);
+                std::hint::black_box(&out);
+            });
+
+            println!(
+                "{:>10} {:>12.1} {:>12.1} {:>12.1} {:>9.2}x {:>9.2}x",
+                n,
+                per_row_ns(interp, n),
+                per_row_ns(corgi_eval, n),
+                per_row_ns(corgi_total, n),
+                interp / corgi_eval,
+                interp / corgi_total,
+            );
+        }
+    }
+
+    // correctness: corgi == interpreter on a mid-size column
+    check_correctness(&term_map, true);
+    check_correctness(&term_filter, false);
+    println!("\ncorrectness: OK");
+}
+
+fn check_correctness(term: &Term, is_map: bool) {
+    let n = 1000;
+    let rows: Vec<DValue> = (0..n)
+        .map(|i| DValue::Tuple(vec![DValue::Int((i % 1000) as i64), DValue::Int(((i * 7) % 997) as i64)]))
+        .collect();
+    let shape = infer_shape(&rows[0]);
+    let g = build_graph(term);
+    let out = corgi::eval_graph(&g, transcode(&rows, &shape));
+
+    let base: Vec<DValue> = rows
+        .iter()
+        .map(|r| {
+            let mut env = vec![r.clone()];
+            ir::eval(term, &mut env)
+        })
+        .collect();
+
+    if is_map {
+        let cols = out.into_prod("map result");
+        let c0 = cols[0].clone().into_u64("col0");
+        let c1 = cols[1].clone().into_u64("col1");
+        for (i, bv) in base.iter().enumerate() {
+            let DValue::Tuple(xs) = bv else { panic!("expected tuple") };
+            assert_eq!(c0[i], xs[0].as_int() as u64, "map col0 row {i}");
+            assert_eq!(c1[i], xs[1].as_int() as u64, "map col1 row {i}");
+        }
+    } else {
+        let mask = out.into_u64("filter mask");
+        for (i, bv) in base.iter().enumerate() {
+            assert_eq!(mask[i], bv.as_int() as u64, "filter row {i}");
+        }
+    }
+}
diff --git a/interactive/examples/corgi_chain.rs b/interactive/examples/corgi_chain.rs
new file mode 100644
index 000000000..01ffb8862
--- /dev/null
+++ b/interactive/examples/corgi_chain.rs
@@ -0,0 +1,113 @@
+//! Rung 4 (measurement): how corgi-columnar *storage* amortizes the dominant transcode.
+//! A chain of K Linear map ops, three ways:
+//!   - interp:   per-row `ir::eval`, K ops per row.
+//!   - per-op:   corgi, but transcode rows<->corgi at every op boundary (the rung-2 "floor":
+//!               what you pay if each operator hands off row-major data).
+//!   - columnar: corgi, transcode IN once, eval x K staying in corgi columns, transcode OUT once
+//!               (the rung-4 model: data lives corgi-columnar between ops).
+//! Shows per-op cost ~ K*(2*xcode + eval) vs columnar ~ 2*xcode + K*eval → columnar approaches
+//! the eval-only ceiling as K grows. Quantifies the payoff of a corgi-data CHUNK/container.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_chain
+
+use std::time::Instant;
+
+use interactive::corgi_logic::{compile_term_single, infer_shape, transcode, untranscode};
+use interactive::ir::{self, Value as DValue};
+use interactive::parse::{BinOp, Term};
+
+fn op_term(c: i64) -> Term {
+    Term::Binary(BinOp::Add, Box::new(Term::Var(0)), Box::new(Term::Int(c)))
+}
+
+fn bench<F: FnMut()>(n: usize, mut f: F) -> f64 {
+    let reps = (2_000_000 / n.max(1)).max(5);
+    f();
+    let t = Instant::now();
+    for _ in 0..reps {
+        f();
+    }
+    t.elapsed().as_secs_f64() / reps as f64
+}
+
+fn main() {
+    let n = 100_000usize;
+    let consts: Vec<i64> = (1..=16).map(|i| i * 3).collect();
+
+    println!("chain of K Linear ops (x -> x+c), n = {n} rows; ns/row totals over the whole chain");
+    println!("{:>4} {:>12} {:>12} {:>12} {:>12} {:>12}", "K", "interp", "per-op", "columnar", "col vs interp", "col vs perop");
+
+    for &k in &[1usize, 2, 4, 8, 16] {
+        let terms: Vec<Term> = consts[..k].iter().map(|&c| op_term(c)).collect();
+        let graphs: Vec<_> = terms.iter().map(compile_term_single).collect();
+
+        let rows: Vec<DValue> = (0..n).map(|i| DValue::Int((i % 1000) as i64)).collect();
+        let shape = infer_shape(&rows[0]);
+
+        // interp: per-row, K ops.
+        let interp = bench(n, || {
+            let mut out = Vec::with_capacity(n);
+            for r in &rows {
+                let mut v = r.clone();
+                for t in &terms {
+                    let mut env = vec![v];
+                    v = ir::eval(t, &mut env);
+                }
+                out.push(v);
+            }
+            std::hint::black_box(&out);
+        });
+
+        // per-op: transcode round-trip at every op boundary.
+        let per_op = bench(n, || {
+            let mut cur = rows.clone();
+            for g in &graphs {
+                let col = transcode(&cur, &shape);
+                let out = corgi::eval_graph(g, col);
+                cur = untranscode(out, &shape);
+            }
+            std::hint::black_box(&cur);
+        });
+
+        // columnar: transcode once, stay in corgi columns across all K ops, transcode out once.
+        let columnar = bench(n, || {
+            let mut col = transcode(&rows, &shape);
+            for g in &graphs {
+                col = corgi::eval_graph(g, col);
+            }
+            let out = untranscode(col, &shape);
+            std::hint::black_box(&out);
+        });
+
+        let nsr = |s: f64| s * 1e9 / n as f64;
+        println!(
+            "{:>4} {:>12.1} {:>12.1} {:>12.1} {:>11.1}x {:>11.1}x",
+            k,
+            nsr(interp),
+            nsr(per_op),
+            nsr(columnar),
+            interp / columnar,
+            per_op / columnar,
+        );
+    }
+
+    // correctness: all three agree at K=8.
+    {
+        let k = 8;
+        let terms: Vec<Term> = consts[..k].iter().map(|&c| op_term(c)).collect();
+        let graphs: Vec<_> = terms.iter().map(compile_term_single).collect();
+        let rows: Vec<DValue> = (0..1000).map(|i| DValue::Int(i)).collect();
+        let shape = infer_shape(&rows[0]);
+        let bump: i64 = consts[..k].iter().sum();
+
+        let mut col = transcode(&rows, &shape);
+        for g in &graphs {
+            col = corgi::eval_graph(g, col);
+        }
+        let got = untranscode(col, &shape);
+        for (i, v) in got.iter().enumerate() {
+            assert_eq!(v.as_int(), i as i64 + bump, "chain row {i}");
+        }
+        println!("\ncorrectness (K=8 chain): OK");
+    }
+}
diff --git a/interactive/examples/corgi_fold.rs b/interactive/examples/corgi_fold.rs
new file mode 100644
index 000000000..329245515
--- /dev/null
+++ b/interactive/examples/corgi_fold.rs
@@ -0,0 +1,73 @@
+//! Q3: corgi covers beyond map/filter — a List + Fold (per-row aggregation), the construct
+//! datalog/eqsat lean on (Collect/Count/nested data). Rows are List<Int>; the Term folds each
+//! row's list (acc+elem). Validates corgi vs `ir::eval` and measures the columnar speedup.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_fold
+
+use std::time::Instant;
+
+use interactive::corgi_logic::{compile_term_single, infer_shape, transcode, untranscode};
+use interactive::ir::{self, Value as DValue};
+use interactive::parse::{BinOp, Term};
+
+fn bench<F: FnMut()>(n: usize, mut f: F) -> f64 {
+    let reps = (2_000_000 / n.max(1)).max(5);
+    f();
+    let t = Instant::now();
+    for _ in 0..reps {
+        f();
+    }
+    t.elapsed().as_secs_f64() / reps as f64
+}
+
+fn main() {
+    // Fold over Var(0) (the row, a List<Int>): seed 0, step = acc + elem.
+    // DDIR Fold binders: elem=Bound(0), acc=Bound(1).
+    let step = Term::Binary(BinOp::Add, Box::new(Term::Bound(1)), Box::new(Term::Bound(0)));
+    let term = Term::Fold {
+        list: Box::new(Term::Var(0)),
+        init: Box::new(Term::Int(0)),
+        step: Box::new(step),
+    };
+    let g = compile_term_single(&term);
+
+    // Rows: lists of length 1..=20 of small ints.
+    let n = 100_000usize;
+    let rows: Vec<DValue> = (0..n)
+        .map(|i| {
+            let len = 1 + (i % 20);
+            DValue::List((0..len).map(|j| DValue::Int(((i + j) % 50) as i64)).collect())
+        })
+        .collect();
+    let shape = infer_shape(&rows[0]); // List(Prim(64))
+
+    // correctness vs interpreter
+    let input = transcode(&rows, &shape);
+    let out = untranscode(corgi::eval_graph(&g, input), &corgi::Shape::Prim(64));
+    for (i, r) in rows.iter().enumerate() {
+        let mut env = vec![r.clone()];
+        let want = ir::eval(&term, &mut env).as_int();
+        assert_eq!(out[i].as_int(), want, "fold row {i}");
+    }
+    println!("Q3: List + Fold (per-row aggregation)");
+    println!("  correctness vs ir::eval: OK ({n} rows, list len 1..=20)");
+
+    // throughput
+    let interp = bench(n, || {
+        let mut acc = Vec::with_capacity(n);
+        for r in &rows {
+            let mut env = vec![r.clone()];
+            acc.push(ir::eval(&term, &mut env));
+        }
+        std::hint::black_box(&acc);
+    });
+    let pre = transcode(&rows, &shape);
+    let corgi_eval = bench(n, || {
+        std::hint::black_box(corgi::eval_graph(&g, pre.clone()));
+    });
+    let total_elems: usize = rows.iter().map(|r| if let DValue::List(xs) = r { xs.len() } else { 0 }).sum();
+    println!("  total elements folded: {total_elems}");
+    println!("  interp:     {:>7.1} ns/row", interp * 1e9 / n as f64);
+    println!("  corgi eval: {:>7.1} ns/row   ({:.1}x)", corgi_eval * 1e9 / n as f64, interp / corgi_eval);
+    println!("\ncorgi covers List/Fold — the aggregation/nested-data path beyond map/filter.");
+}
diff --git a/interactive/examples/corgi_join_dataflow.rs b/interactive/examples/corgi_join_dataflow.rs
new file mode 100644
index 000000000..65330ad35
--- /dev/null
+++ b/interactive/examples/corgi_join_dataflow.rs
@@ -0,0 +1,131 @@
+//! M2(b)-4 (live): corgi JOIN inside a real DD dataflow via the cursor-less tactic seam. Arrange two
+//! corgi-container collections into `Spine<Rc<CorgiBatch>>` traces, then `join_with_tactic` with
+//! `CorgiJoinTactic` (bulk merge-join over corgi columns + corgi projection). Output == reference
+//! hash-join, incl. retractions. Projection: (key, val0, val1) -> (key, val0+val1).
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_join_dataflow
+
+use std::collections::BTreeMap;
+use std::rc::Rc;
+
+use timely::container::CapacityContainerBuilder;
+use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::capture::{Capture, Event};
+use timely::dataflow::operators::*;
+
+use differential_dataflow::input::Input;
+use differential_dataflow::operators::arrange::arrangement::arrange_core;
+use differential_dataflow::operators::join::join_with_tactic;
+use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::trace::implementations::spine_fueled::Spine;
+use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
+
+use interactive::corgi_arrange::{CorgiBatch, CorgiBatchBuilder};
+use interactive::corgi_backend::CorgiContainer;
+use interactive::corgi_join::CorgiJoinTactic;
+use interactive::ir::{Diff, Value as DValue};
+use interactive::parse::{BinOp, Term};
+
+type Row = DValue;
+type Upd = ((Row, Row), u64, Diff);
+type CC = CorgiContainer<u64, Diff>;
+type Trace = Spine<Rc<CorgiBatch<u64, Diff>>>;
+type OutCB = CapacityContainerBuilder<Vec<Upd>>;
+
+fn reference(lu: &[((u64, u64), Diff)], ru: &[((u64, u64), Diff)]) -> BTreeMap<(u64, u64), Diff> {
+    // join by key, project (key, val0+val1), sum diffs.
+    let mut lmap: BTreeMap<u64, Vec<(u64, Diff)>> = BTreeMap::new();
+    let mut rmap: BTreeMap<u64, Vec<(u64, Diff)>> = BTreeMap::new();
+    for ((k, v), d) in lu {
+        lmap.entry(*k).or_default().push((*v, *d));
+    }
+    for ((k, v), d) in ru {
+        rmap.entry(*k).or_default().push((*v, *d));
+    }
+    let mut out = BTreeMap::new();
+    for (k, lvs) in &lmap {
+        if let Some(rvs) = rmap.get(k) {
+            for (vl, dl) in lvs {
+                for (vr, dr) in rvs {
+                    *out.entry((*k, vl + vr)).or_insert(0) += dl * dr;
+                }
+            }
+        }
+    }
+    out.retain(|_, d| *d != 0);
+    out
+}
+
+fn main() {
+    let lu: Vec<((u64, u64), Diff)> = vec![((1, 10), 1), ((1, 20), 1), ((2, 5), 1), ((2, 6), 1), ((3, 1), 1), ((2, 6), -1)];
+    let ru: Vec<((u64, u64), Diff)> = vec![((1, 100), 1), ((2, 200), 1), ((2, 300), 1), ((4, 9), 1)];
+
+    let l_rows: Vec<(Row, Row)> = lu.iter().map(|((k, v), _)| (DValue::Int(*k as i64), DValue::Int(*v as i64))).collect();
+    let l_diffs: Vec<Diff> = lu.iter().map(|(_, d)| *d).collect();
+    let r_rows: Vec<(Row, Row)> = ru.iter().map(|((k, v), _)| (DValue::Int(*k as i64), DValue::Int(*v as i64))).collect();
+    let r_diffs: Vec<Diff> = ru.iter().map(|(_, d)| *d).collect();
+
+    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<Upd>>>();
+    timely::execute_directly(move |worker| {
+        let (mut h0, mut h1) = worker.dataflow::<u64, _, _>(|scope| {
+            let (h0, c0) = scope.new_collection::<(Row, Row), Diff>();
+            let (h1, c1) = scope.new_collection::<(Row, Row), Diff>();
+
+            let s0 = c0.inner.unary(Pipeline, "ToCorgi0", |_, _| {
+                |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
+                        output.session(&cap).give_container(&mut c);
+                    });
+                }
+            });
+            let s1 = c1.inner.unary(Pipeline, "ToCorgi1", |_, _| {
+                |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
+                        output.session(&cap).give_container(&mut c);
+                    });
+                }
+            });
+
+            let a0 = arrange_core::<_, CC, ContainerChunker<Vec<Upd>>, MergeBatcher<VecMerger<(Row, Row), u64, Diff>>, RcBuilder<CorgiBatchBuilder<u64, Diff>>, Trace>(s0, Pipeline, "CorgiArr0");
+            let a1 = arrange_core::<_, CC, ContainerChunker<Vec<Upd>>, MergeBatcher<VecMerger<(Row, Row), u64, Diff>>, RcBuilder<CorgiBatchBuilder<u64, Diff>>, Trace>(s1, Pipeline, "CorgiArr1");
+
+            // projection: (key, val0, val1) -> (key, val0 + val1); the tactic compiles it per work-unit.
+            let key = Term::Var(0);
+            let val = Term::Binary(BinOp::Add, Box::new(Term::Var(1)), Box::new(Term::Var(2)));
+            let out = join_with_tactic::<_, _, _, OutCB>(a0, a1, CorgiJoinTactic::new(key, val));
+            out.capture_into(tx);
+
+            (h0, h1)
+        });
+        for (r, d) in l_rows.into_iter().zip(l_diffs) {
+            h0.update(r, d);
+        }
+        for (r, d) in r_rows.into_iter().zip(r_diffs) {
+            h1.update(r, d);
+        }
+    });
+
+    let mut got: BTreeMap<(u64, u64), Diff> = BTreeMap::new();
+    for event in rx {
+        if let Event::Messages(_, data) = event {
+            for ((k, v), _, d) in data {
+                if let (DValue::Int(k), DValue::Int(v)) = (k, v) {
+                    *got.entry((k as u64, v as u64)).or_insert(0) += d;
+                }
+            }
+        }
+    }
+    got.retain(|_, d| *d != 0);
+
+    let want = reference(&lu, &ru);
+    assert_eq!(got, want, "corgi join dataflow != reference");
+
+    println!("M2(b)-4 LIVE: corgi JOIN in a real DD dataflow via CorgiJoinTactic");
+    println!("  output rows: {} — matches reference hash-join (incl. retraction)", got.len());
+    println!("  e.g. {:?}", got);
+    println!("\nJoin operator works cursor-less over corgi columns through the #771–773 tactic seam.");
+}
diff --git a/interactive/examples/corgi_join_mechanism.rs b/interactive/examples/corgi_join_mechanism.rs
new file mode 100644
index 000000000..4efb0c785
--- /dev/null
+++ b/interactive/examples/corgi_join_mechanism.rs
@@ -0,0 +1,133 @@
+//! M2(b)-4 (mechanism): the cursor-less JOIN compute over corgi batches — before the
+//! JoinTactic defer/work/capability plumbing. Merge-join two sorted corgi batches by KEY
+//! (`compare_at`), cross-product the matched val runs (`gather`), multiply diffs (Rust). Verified
+//! vs a reference hash-join, with retractions (negative diffs). Single time (the (time) lattice
+//! join lives in the tactic; here we isolate the columnar match+cross-product+diff algebra).
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_join_mechanism
+
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+
+use timely::progress::Antichain;
+use differential_dataflow::trace::{BatchReader, Description};
+
+use interactive::corgi_arrange::CorgiBatch;
+
+use corgi::arrange::{compare_at, gather};
+use corgi::Value as CValue;
+
+fn make_batch(updates: &[((u64, u64), i64)]) -> CorgiBatch<u64, i64> {
+    let keys = CValue::u64(updates.iter().map(|u| u.0 .0).collect());
+    let vals = CValue::u64(updates.iter().map(|u| u.0 .1).collect());
+    let times = vec![0u64; updates.len()];
+    let diffs = updates.iter().map(|u| u.1).collect();
+    let desc = Description::new(Antichain::from_elem(0), Antichain::from_elem(1), Antichain::from_elem(0));
+    CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
+}
+
+/// Cursor-less equijoin compute: matched (key, valL, valR) -> summed diff (diffL*diffR).
+fn corgi_join(l: &CorgiBatch<u64, i64>, r: &CorgiBatch<u64, i64>) -> BTreeMap<(u64, u64, u64), i64> {
+    let (nl, nr) = (l.len(), r.len());
+    let (mut i, mut j) = (0, 0);
+    let (mut li, mut ri, mut ds) = (Vec::new(), Vec::new(), Vec::new());
+    while i < nl && j < nr {
+        match compare_at(&l.keys, i, &r.keys, j) {
+            Ordering::Less => i += 1,
+            Ordering::Greater => j += 1,
+            Ordering::Equal => {
+                // runs of this key on each side (batches sorted by (key,val))
+                let mut i2 = i;
+                while i2 < nl && compare_at(&l.keys, i, &l.keys, i2) == Ordering::Equal {
+                    i2 += 1;
+                }
+                let mut j2 = j;
+                while j2 < nr && compare_at(&r.keys, j, &r.keys, j2) == Ordering::Equal {
+                    j2 += 1;
+                }
+                for a in i..i2 {
+                    for b in j..j2 {
+                        li.push(a);
+                        ri.push(b);
+                        ds.push(l.diffs[a] * r.diffs[b]);
+                    }
+                }
+                i = i2;
+                j = j2;
+            }
+        }
+    }
+    // Materialize matched columns in bulk via gather (corgi-native), then fold to a map.
+    let kc = gather(&l.keys, &li).into_u64("k");
+    let lc = gather(&l.vals, &li).into_u64("vl");
+    let rc = gather(&r.vals, &ri).into_u64("vr");
+    let mut m = BTreeMap::new();
+    for x in 0..ds.len() {
+        *m.entry((kc[x], lc[x], rc[x])).or_insert(0) += ds[x];
+    }
+    m.retain(|_, d| *d != 0);
+    m
+}
+
+/// Reference hash-join over the same updates.
+fn reference(lu: &[((u64, u64), i64)], ru: &[((u64, u64), i64)]) -> BTreeMap<(u64, u64, u64), i64> {
+    let mut lmap: BTreeMap<u64, Vec<(u64, i64)>> = BTreeMap::new();
+    let mut rmap: BTreeMap<u64, Vec<(u64, i64)>> = BTreeMap::new();
+    for ((k, v), d) in lu {
+        lmap.entry(*k).or_default().push((*v, *d));
+    }
+    for ((k, v), d) in ru {
+        rmap.entry(*k).or_default().push((*v, *d));
+    }
+    let mut m = BTreeMap::new();
+    for (k, lvs) in &lmap {
+        if let Some(rvs) = rmap.get(k) {
+            for (vl, dl) in lvs {
+                for (vr, dr) in rvs {
+                    *m.entry((*k, *vl, *vr)).or_insert(0) += dl * dr;
+                }
+            }
+        }
+    }
+    m.retain(|_, d| *d != 0);
+    m
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+fn main() {
+    // Directed example incl. multi-val keys and a retraction.
+    let lu = vec![((1, 10), 1), ((1, 11), 1), ((2, 20), 1), ((3, 30), 1)];
+    let ru = vec![((1, 100), 1), ((2, 200), 1), ((2, 201), 1), ((4, 400), 1)];
+    let got = corgi_join(&make_batch(&lu), &make_batch(&ru));
+    let want = reference(&lu, &ru);
+    assert_eq!(got, want, "directed join mismatch");
+    println!("  directed: {} matched rows  OK (e.g. key 2 → 1×2 = 2 pairs)", got.len());
+
+    // Randomized property test incl. negative diffs (retractions → diffL*diffR can be negative).
+    let mut seed = 0xfeed_face_dead_beefu64;
+    for _ in 0..300 {
+        let gen = |s: &mut u64| -> Vec<((u64, u64), i64)> {
+            let n = (xorshift(s) % 20) as usize + 1;
+            (0..n)
+                .map(|_| {
+                    let k = xorshift(s) % 5;
+                    let v = xorshift(s) % 6;
+                    let d = if xorshift(s) % 4 == 0 { -1 } else { 1 };
+                    ((k, v), d)
+                })
+                .collect()
+        };
+        let lu = gen(&mut seed);
+        let ru = gen(&mut seed);
+        assert_eq!(corgi_join(&make_batch(&lu), &make_batch(&ru)), reference(&lu, &ru), "lu={lu:?} ru={ru:?}");
+    }
+    println!("  randomized: 300 joins == reference (incl. retractions / negative product diffs)");
+    println!("\nM2(b)-4 mechanism: cursor-less corgi equijoin (merge-join via compare_at + gather");
+    println!("  cross-product + diff-multiply) verified. Next: wrap in CorgiJoinTactic defer/work.");
+}
diff --git a/interactive/examples/corgi_linear_dataflow.rs b/interactive/examples/corgi_linear_dataflow.rs
new file mode 100644
index 000000000..e34629c9f
--- /dev/null
+++ b/interactive/examples/corgi_linear_dataflow.rs
@@ -0,0 +1,151 @@
+//! Rung 2: corgi as the scalar logic of a DDIR **Linear** map, running inside a real
+//! differential-dataflow computation. A container-level unary operator transcodes each
+//! update batch to corgi columns, runs the compiled `Graph` over the whole batch at once,
+//! and transcodes back — preserving (time, diff) per row. Verified against the per-row
+//! `ir::eval` interpreter, including retractions (incremental soundness).
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_linear_dataflow
+
+use std::collections::BTreeMap;
+use std::time::Instant;
+
+use interactive::corgi_logic::{compile_projection, infer_shape, transcode, untranscode};
+use interactive::ir::{self, Diff, Value as DValue};
+use interactive::parse::{BinOp, Term};
+
+use corgi::{Graph, NumOp, Shape, Value as CValue};
+
+type Row = DValue;
+
+/// Apply the compiled projection `graph` to a whole update batch, columnar, via corgi.
+/// (time, diff) pass through untouched; only (key, val) are transformed.
+fn corgi_apply(graph: &Graph<NumOp>, batch: Vec<((Row, Row), u64, Diff)>) -> Vec<((Row, Row), u64, Diff)> {
+    if batch.is_empty() {
+        return batch;
+    }
+    let kshape = infer_shape(&batch[0].0 .0);
+    let vshape = infer_shape(&batch[0].0 .1);
+    let in_shape = Shape::Prod(vec![kshape.clone(), vshape.clone()]);
+
+    let keys: Vec<DValue> = batch.iter().map(|x| x.0 .0.clone()).collect();
+    let vals: Vec<DValue> = batch.iter().map(|x| x.0 .1.clone()).collect();
+    let input = CValue::Prod(vec![transcode(&keys, &kshape), transcode(&vals, &vshape)]);
+
+    let out = corgi::eval_graph(graph, input);
+    let out_shape = corgi::shape_of(graph, &in_shape).expect("shape_of");
+    let Shape::Prod(out_fs) = &out_shape else { panic!("expected Prod output shape") };
+    let mut cols = out.into_prod("out");
+    let newvals = untranscode(cols.pop().unwrap(), &out_fs[1]);
+    let newkeys = untranscode(cols.pop().unwrap(), &out_fs[0]);
+
+    batch
+        .into_iter()
+        .enumerate()
+        .map(|(i, ((_, _), t, d))| ((newkeys[i].clone(), newvals[i].clone()), t, d))
+        .collect()
+}
+
+/// Run the corgi-Linear dataflow on `data` (rows with diffs), return consolidated output.
+fn run_corgi_dataflow(graph: Graph<NumOp>, data: Vec<((Row, Row), Diff)>) -> BTreeMap<(Row, Row), Diff> {
+    use std::sync::mpsc::channel;
+    use timely::dataflow::operators::*;
+    use timely::dataflow::channels::pact::Pipeline;
+    use timely::dataflow::operators::capture::{Capture, Event};
+    use differential_dataflow::AsCollection;
+    use differential_dataflow::input::Input;
+
+    let (tx, rx) = channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
+    timely::execute_directly(move |worker| {
+        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
+            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
+            let graph = graph.clone();
+            coll.inner
+                .unary(Pipeline, "CorgiLinear", move |_, _| {
+                    move |input, output| {
+                        input.for_each(|time, data| {
+                            let mut result = corgi_apply(&graph, std::mem::take(data));
+                            output.session(&time).give_container(&mut result);
+                        });
+                    }
+                })
+                .as_collection()
+                .inner
+                .capture_into(tx);
+            handle
+        });
+        for (row, diff) in data {
+            handle.update(row, diff);
+        }
+    });
+
+    let mut acc: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for event in rx {
+        if let Event::Messages(_, data) = event {
+            for ((k, v), _, d) in data {
+                *acc.entry((k, v)).or_insert(0) += d;
+            }
+        }
+    }
+    acc.retain(|_, d| *d != 0);
+    acc
+}
+
+/// Reference: the same projection via the per-row `ir::eval` interpreter.
+fn reference(key: &Term, val: &Term, data: &[((Row, Row), Diff)]) -> BTreeMap<(Row, Row), Diff> {
+    let mut acc: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for ((k, v), d) in data {
+        let mut env = vec![k.clone(), v.clone()];
+        let nk = ir::eval(key, &mut env);
+        let nv = ir::eval(val, &mut env);
+        *acc.entry((nk, nv)).or_insert(0) += d;
+    }
+    acc.retain(|_, d| *d != 0);
+    acc
+}
+
+fn main() {
+    // Projection: keep the key; reval val=[a,b] -> (a+b, a*3).  Var(0)=key, Var(1)=val.
+    let a = || Box::new(Term::Proj(Box::new(Term::Var(1)), 0));
+    let b = || Box::new(Term::Proj(Box::new(Term::Var(1)), 1));
+    let key = Term::Var(0);
+    let val = Term::Tuple(vec![
+        Term::Binary(BinOp::Add, a(), b()),
+        Term::Binary(BinOp::Mul, a(), Box::new(Term::Int(3))),
+    ]);
+
+    // Input shapes: key=Int (Prim), val=(Int,Int) (Prod[Prim,Prim]).
+    let kshape = infer_shape(&DValue::Int(0));
+    let vshape = infer_shape(&DValue::Tuple(vec![DValue::Int(0), DValue::Int(0)]));
+    let graph = compile_projection(&key, &val, &kshape, &vshape);
+
+    // Data with mixed diffs INCLUDING retractions (net-zero rows must vanish from both).
+    let n = 20_000usize;
+    let data: Vec<((Row, Row), Diff)> = (0..n)
+        .flat_map(|i| {
+            let row = (
+                DValue::Int((i % 10) as i64),
+                DValue::Tuple(vec![DValue::Int((i % 100) as i64), DValue::Int(((i * 7) % 97) as i64)]),
+            );
+            match i % 3 {
+                0 => vec![(row.clone(), 1), (row, -1)], // net zero -> must disappear
+                1 => vec![(row, 2)],
+                _ => vec![(row, 1)],
+            }
+        })
+        .collect();
+
+    let t0 = Instant::now();
+    let got = run_corgi_dataflow(graph, data.clone());
+    let elapsed = t0.elapsed();
+    let want = reference(&key, &val, &data);
+
+    assert_eq!(got.len(), want.len(), "output cardinality mismatch");
+    assert_eq!(got, want, "corgi-Linear dataflow output != interpreter reference");
+
+    println!("rung 2: corgi-Linear inside a real DD dataflow");
+    println!("  input updates (with retractions): {}", data.len());
+    println!("  output rows (consolidated):       {}", got.len());
+    println!("  matches interpreter reference:    YES (incl. net-zero retractions vanished)");
+    println!("  dataflow wall-clock:              {:?}", elapsed);
+    println!("\nINTEGRATION SOUND: corgi runs as DDIR's columnar Linear logic; (time,diff) preserved.");
+}
diff --git a/interactive/examples/corgi_perf.rs b/interactive/examples/corgi_perf.rs
new file mode 100644
index 000000000..22bb5019b
--- /dev/null
+++ b/interactive/examples/corgi_perf.rs
@@ -0,0 +1,150 @@
+//! End-to-end performance: the corgi backend vs the vec backend on whole DDIR programs (NOT the
+//! Phase-1 eval-only microbench). Measures the real thing this work produced — `corgi::evaluate`
+//! vs `vec::evaluate` — across two shapes of program:
+//!   1. LINEAR-HEAVY: a long chain of compilable Project/Filter ops over wide rows — corgi's
+//!      columnar strength (eval stays in columns; transcode only at the arrange boundary).
+//!   2. REACH: recursive reachability — join + distinct + concat + leave_dynamic; narrow rows,
+//!      per-key value slices where the columnar win doesn't apply and row-wise fallbacks + the
+//!      (eager, unoptimized) CorgiBatch merge dominate.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_perf
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(fields: &[i64]) -> Row {
+    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
+}
+
+/// Median wall-clock of `iters` runs of `f` (min 3), after one warmup.
+fn bench<F: FnMut()>(iters: usize, mut f: F) -> Duration {
+    f(); // warmup
+    let mut ts: Vec<Duration> = (0..iters.max(3))
+        .map(|_| {
+            let t = Instant::now();
+            f();
+            t.elapsed()
+        })
+        .collect();
+    ts.sort();
+    ts[ts.len() / 2]
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+fn compile(src: &str) -> interactive::scope_ir::Program {
+    let mut p = lower::lower_tree(parse::pipe::parse(src));
+    p.optimize();
+    p
+}
+
+fn report(name: &str, n: usize, vec_t: Duration, corgi_t: Duration) {
+    let ratio = corgi_t.as_secs_f64() / vec_t.as_secs_f64();
+    let faster = if ratio < 1.0 {
+        format!("corgi {:.2}x FASTER", 1.0 / ratio)
+    } else {
+        format!("corgi {ratio:.2}x slower")
+    };
+    println!("  {name:<22} n={n:<7}  vec {vec_t:>10.2?}   corgi {corgi_t:>10.2?}   → {faster}");
+}
+
+fn main() {
+    // ---------- 1. LINEAR-HEAVY (corgi's columnar strength) ----------
+    // Wide 6-field value; a chain of arithmetic Project maps + a filter, then arrange. All ops are
+    // corgi-compilable, so eval stays columnar; only the final arrange transcodes.
+    // Flat comma-separated projection fields (the pipe `(K ; V1, V2, ...)` already tuples the list;
+    // a `tuple(...)` field would NEST, so we list fields directly for a flat 6-wide value).
+    let linear_src = r#"
+        let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5], $0[0]);
+        let b = a | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);
+        let c = b | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);
+        let d = c | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);
+        let e = d | filter($1[0] != 999999);
+        export "result" = e | arrange;
+    "#;
+    let linear = compile(linear_src);
+
+    println!("1. LINEAR-HEAVY (3 wide arithmetic maps + filter + arrange; corgi columnar path):");
+    for &n in &[2_000usize, 20_000, 100_000] {
+        let mut seed = 0x1234_5678u64;
+        let input: Vec<(Row, Row)> = (0..n)
+            .map(|i| (tup(&[i as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64,
+                             (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64]),
+                      Value::unit()))
+            .collect();
+        let inputs = vec![input];
+        // sanity: identical output
+        assert_eq!(corgi::evaluate(&linear, &inputs), vec::evaluate(&linear, &inputs));
+        let vt = bench(5, || { std::hint::black_box(vec::evaluate(&linear, &inputs)); });
+        let ct = bench(5, || { std::hint::black_box(corgi::evaluate(&linear, &inputs)); });
+        report("linear-heavy", n, vt, ct);
+    }
+
+    // ---------- 2. REACH (recursive; join + distinct heavy, narrow rows) ----------
+    let reach = compile(r#"
+        let edges = input 0 | key($0[0] ; $0[1]);
+        let roots = input 1 | key($0[0] ;);
+        reach: {
+            let proposals = reach | join(edges, ($2 ;));
+            var reach = roots + proposals | distinct;
+        }
+        export "result" = reach::reach | arrange;
+    "#);
+
+    println!("\n2. REACH (recursive: join + distinct + concat + leave_dynamic; narrow rows):");
+    for &nodes in &[200usize, 1_000, 4_000] {
+        let mut seed = 0x9e37_79b9u64;
+        let n_edges = nodes * 3;
+        let edges: Vec<(Row, Row)> = (0..n_edges)
+            .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
+            .collect();
+        let roots = vec![(tup(&[0]), Value::unit())];
+        let inputs = vec![edges, roots];
+        assert_eq!(corgi::evaluate(&reach, &inputs), vec::evaluate(&reach, &inputs));
+        let vt = bench(3, || { std::hint::black_box(vec::evaluate(&reach, &inputs)); });
+        let ct = bench(3, || { std::hint::black_box(corgi::evaluate(&reach, &inputs)); });
+        report("reach", nodes, vt, ct);
+    }
+
+    // ---------- 3. LINEAR COMPUTE ONLY (deep chain, NO arrange) — isolates the columnar eval ----------
+    // 8 wide arithmetic maps, exported without arrange (only ToCorgi in / FromCorgi out transcode
+    // bracket the columnar chain). This is where corgi's columnar scalar logic should actually pay.
+    let mut deep = String::from("let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5], $0[0]);\n");
+    let mut prev = 'a';
+    for i in 0..8 {
+        let cur = (b'b' + i) as char;
+        deep.push_str(&format!(
+            "let {cur} = {prev} | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);\n"
+        ));
+        prev = cur;
+    }
+    deep.push_str(&format!("export \"result\" = {prev};\n"));
+    let deep = compile(&deep);
+
+    println!("\n3. LINEAR COMPUTE ONLY (8 wide maps, NO arrange — isolates the columnar eval):");
+    for &n in &[20_000usize, 100_000] {
+        let mut seed = 0xdead_beefu64;
+        let input: Vec<(Row, Row)> = (0..n)
+            .map(|i| (tup(&[i as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64,
+                             (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64]),
+                      Value::unit()))
+            .collect();
+        let inputs = vec![input];
+        assert_eq!(corgi::evaluate(&deep, &inputs), vec::evaluate(&deep, &inputs));
+        let vt = bench(5, || { std::hint::black_box(vec::evaluate(&deep, &inputs)); });
+        let ct = bench(5, || { std::hint::black_box(corgi::evaluate(&deep, &inputs)); });
+        report("linear-compute-8x", n, vt, ct);
+    }
+
+    println!("\n(Wall-clock includes a fixed timely single-worker setup per `evaluate` call, equal for both.)");
+}
diff --git a/interactive/examples/corgi_prof.rs b/interactive/examples/corgi_prof.rs
new file mode 100644
index 000000000..86820d475
--- /dev/null
+++ b/interactive/examples/corgi_prof.rs
@@ -0,0 +1,54 @@
+//! Reach-only profiling harness: runs the corgi backend on recursive reachability in a tight loop so
+//! a sampling profiler (samply) isolates the recursive join+distinct hot path.
+//!
+//!   ~/.cargo/bin/samply record --save-only -o /tmp/reach.json.gz -- \
+//!       ~/.cargo/bin/cargo run --release -p interactive --example corgi_prof
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+fn tup(fields: &[i64]) -> Value {
+    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(
+        r#"
+        let edges = input 0 | key($0[0] ; $0[1]);
+        let roots = input 1 | key($0[0] ;);
+        reach: {
+            let proposals = reach | join(edges, ($2 ;));
+            var reach = roots + proposals | distinct;
+        }
+        export "result" = reach::reach | arrange;
+    "#,
+    ));
+    p.optimize();
+
+    let nodes = 4_000usize;
+    let mut seed = 0x9e37_79b9u64;
+    let n_edges = nodes * 3;
+    let edges: Vec<(Value, Value)> = (0..n_edges)
+        .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
+        .collect();
+    let roots = vec![(tup(&[0]), Value::unit())];
+    let inputs = vec![edges, roots];
+
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(300);
+    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
+    let mut acc = 0usize;
+    for _ in 0..iters {
+        let out = if backend == "vec" { vec::evaluate(&p, &inputs) } else { corgi::evaluate(&p, &inputs) };
+        acc += out.values().map(|v| v.len()).sum::<usize>();
+    }
+    std::hint::black_box(acc);
+    eprintln!("done {iters} iters backend={backend} (acc={acc})");
+}
diff --git a/interactive/examples/corgi_program.rs b/interactive/examples/corgi_program.rs
new file mode 100644
index 000000000..639a713db
--- /dev/null
+++ b/interactive/examples/corgi_program.rs
@@ -0,0 +1,53 @@
+//! M3 (partial backend, end-to-end): run a real flat DDIR program through `render_tree::<CorgiBackend>`
+//! and check it matches the vec backend. Exercises Linear (key/filter), join, and reduce(count) — all
+//! corgi-native — composed via the real DDIR backend path. (Flat: no sub-scope, so `leave_dynamic`
+//! isn't reached; reduce works via the cursor-less `active_times` tactic.)
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_program
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn row(fields: &[i64]) -> Row {
+    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
+}
+
+fn main() {
+    let src = r#"
+        let a = input 0 | key($0[0] ; $0[1]);
+        let b = input 1 | key($0[0] ; $0[1]);
+        let j = a | join(b, ($0 ; tuple($1, $2)));
+        export "join"     = j;
+        export "count"    = j | count;
+        export "filtered" = j | filter($0 != 2);
+    "#;
+    let prog = lower::lower_tree(parse::pipe::parse(src));
+
+    let input0: Vec<(Row, Row)> = vec![
+        (row(&[1, 10]), Value::unit()),
+        (row(&[1, 11]), Value::unit()),
+        (row(&[2, 20]), Value::unit()),
+        (row(&[4, 40]), Value::unit()),
+    ];
+    let input1: Vec<(Row, Row)> = vec![
+        (row(&[1, 100]), Value::unit()),
+        (row(&[2, 200]), Value::unit()),
+        (row(&[3, 300]), Value::unit()),
+    ];
+    let inputs = vec![input0, input1];
+
+    let want = vec::evaluate(&prog, &inputs); // reference: the vec backend
+    let got = corgi::evaluate(&prog, &inputs); // the corgi backend
+
+    assert_eq!(got, want, "corgi backend output != vec backend");
+
+    println!("M3 end-to-end: a flat DDIR program (key + join + count + filter) via render_tree::<CorgiBackend>");
+    for name in ["join", "count", "filtered"] {
+        println!("  export {:?}: {} rows, == vec backend", name, got[name].len());
+    }
+    println!("  e.g. count = {:?}", got["count"].iter().map(|((k, v), d)| (k, v, d)).collect::<Vec<_>>());
+    println!("\nThe corgi backend renders a real multi-operator DDIR program correctly (vs vec).");
+}
diff --git a/interactive/examples/corgi_progs.rs b/interactive/examples/corgi_progs.rs
new file mode 100644
index 000000000..b200f4bff
--- /dev/null
+++ b/interactive/examples/corgi_progs.rs
@@ -0,0 +1,77 @@
+//! Run a canonical `.ddp` program through BOTH the corgi and vec backends and compare. Usage:
+//!   PROG=reach ~/.cargo/bin/cargo run --release -p interactive --example corgi_progs
+//! Picks inputs by program (small graphs). Reports OK / FAIL / panic per program; with no PROG,
+//! runs the whole set.
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(fields: &[i64]) -> Row {
+    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
+}
+fn rows(rs: &[&[i64]]) -> Vec<(Row, Row)> {
+    rs.iter().map(|f| (tup(f), Value::unit())).collect()
+}
+
+/// Per-program inputs (arity matches each `.ddp`'s `input N` usage).
+fn inputs_for(prog: &str) -> Vec<Vec<(Row, Row)>> {
+    let edges = rows(&[&[1, 2], &[2, 3], &[3, 4], &[5, 6], &[4, 2]]);
+    match prog {
+        "reach" => vec![edges, rows(&[&[1]])],
+        "scc" => vec![edges],
+        // stable: edges (l_node, l_pref, r_node, r_pref)
+        "stable" => vec![rows(&[&[1, 1, 10, 1], &[1, 2, 11, 1], &[2, 1, 10, 2], &[2, 2, 11, 2]])],
+        "unnest" => vec![rows(&[&[1, 2], &[3, 4]])],
+        "adt" => vec![edges],
+        "binders" => vec![rows(&[&[1, 2], &[3, 4]])],
+        other => panic!("no inputs configured for {other}"),
+    }
+}
+
+fn run_one(prog: &str) -> bool {
+    let path = format!("{}/examples/programs/{prog}.ddp", env!("CARGO_MANIFEST_DIR"));
+    let src = interactive::load_program(&path);
+    let stmts = parse::pipe::parse(&src);
+    let mut tree = lower::lower_tree(stmts);
+    tree.optimize();
+    let inputs = inputs_for(prog);
+
+    let want = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| vec::evaluate(&tree, &inputs)));
+    let got = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| corgi::evaluate(&tree, &inputs)));
+    match (want, got) {
+        (Ok(w), Ok(g)) => {
+            let ok = w == g;
+            println!("[{}] {prog}", if ok { "OK  " } else { "FAIL" });
+            if !ok {
+                println!("   vec  : {w:?}");
+                println!("   corgi: {g:?}");
+            }
+            ok
+        }
+        (Err(_), _) => {
+            println!("[VEC-PANIC] {prog} (reference itself panicked; skipping)");
+            true
+        }
+        (Ok(_), Err(_)) => {
+            println!("[CORGI-PANIC] {prog}");
+            false
+        }
+    }
+}
+
+fn main() {
+    std::panic::set_hook(Box::new(|_| {})); // quiet panics; we report them
+    let all = ["reach", "scc", "stable", "unnest", "adt", "binders"];
+    let progs: Vec<String> = match std::env::var("PROG") {
+        Ok(p) => vec![p],
+        Err(_) => all.iter().map(|s| s.to_string()).collect(),
+    };
+    let mut all_ok = true;
+    for p in &progs {
+        all_ok &= run_one(p);
+    }
+    println!("\n{}", if all_ok { "all programs match vec backend" } else { "some programs differ — see above" });
+}
diff --git a/interactive/examples/corgi_reach.rs b/interactive/examples/corgi_reach.rs
new file mode 100644
index 000000000..8aef198c6
--- /dev/null
+++ b/interactive/examples/corgi_reach.rs
@@ -0,0 +1,69 @@
+//! M4: run the canonical RECURSIVE DDIR program (`reach.ddp` — reachability) end-to-end through the
+//! corgi backend and check it matches the vec backend. This is the first program that exercises a
+//! dynamic sub-scope with a feedback `var` — i.e. `leave_dynamic` over `CorgiContainer` — plus join,
+//! distinct (reduce), concat (`+`), key, and arrange, all corgi-native.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reach
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn edge(s: i64, d: i64) -> (Row, Row) {
+    (Value::Tuple(vec![Value::Int(s), Value::Int(d)]), Value::unit())
+}
+fn node(n: i64) -> (Row, Row) {
+    (Value::Tuple(vec![Value::Int(n)]), Value::unit())
+}
+
+fn main() {
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/programs/reach.ddp");
+    let src = interactive::load_program(path);
+    let stmts = parse::pipe::parse(&src);
+    let mut prog = lower::lower_tree(stmts);
+    prog.optimize();
+
+    // A small graph: 1->2->3->4 and a disconnected 5->6; root = {1}. reach = {1,2,3,4}.
+    let edges = vec![edge(1, 2), edge(2, 3), edge(3, 4), edge(5, 6)];
+    let roots = vec![node(1)];
+    let inputs = vec![edges, roots];
+
+    let want = vec::evaluate(&prog, &inputs);
+    let got = corgi::evaluate(&prog, &inputs);
+
+    assert_eq!(got, want, "corgi backend != vec backend on reach.ddp");
+
+    // reach.ddp's export is `reach::reach | key(;)` — it collapses node identity, so `result` is a
+    // single (unit, unit) row whose diff is the COUNT of reachable nodes.
+    let total: i64 = got["result"].iter().map(|(_, d)| *d).sum();
+    println!("M4 RECURSIVE end-to-end: reach.ddp via render_tree::<CorgiBackend> == vec backend");
+    println!("  reach.ddp result == vec backend; reachable-node count from {{1}} = {total}");
+    assert_eq!(total, 4, "expected 4 reachable nodes");
+
+    // Identity-preserving variant (no `key(;)`) so we can name the reachable set.
+    let src2 = r#"
+        let edges = input 0 | key($0[0] ; $0[1]);
+        let roots = input 1 | key($0[0] ;);
+        reach: {
+            let proposals = reach | join(edges, ($2 ;));
+            var reach = roots + proposals | distinct;
+        }
+        export "result" = reach::reach | arrange;
+    "#;
+    let mut prog2 = lower::lower_tree(parse::pipe::parse(src2));
+    prog2.optimize();
+    let got2 = corgi::evaluate(&prog2, &inputs);
+    assert_eq!(got2, vec::evaluate(&prog2, &inputs), "corgi != vec on identity reach");
+    let reached: std::collections::BTreeSet<i64> = got2["result"]
+        .iter()
+        .map(|((k, _), _)| match k {
+            Value::Tuple(xs) if xs.len() == 1 => xs[0].as_int(),
+            other => panic!("unexpected reach key {other:?}"),
+        })
+        .collect();
+    println!("  reachable set from {{1}}: {reached:?}");
+    assert_eq!(reached, [1, 2, 3, 4].into_iter().collect());
+    println!("\nThe corgi backend runs a real RECURSIVE DDIR program (feedback var + leave_dynamic) correctly.");
+}
diff --git a/interactive/examples/corgi_reduce.rs b/interactive/examples/corgi_reduce.rs
new file mode 100644
index 000000000..22feb4cf1
--- /dev/null
+++ b/interactive/examples/corgi_reduce.rs
@@ -0,0 +1,79 @@
+//! M2(a): corgi can EXPRESS a reduce — group-by-key then fold each group — as one corgi program.
+//! This is the per-key scalar logic the incremental arrangement (M2b) will drive. Here we validate
+//! the LOGIC standalone (whole batch, non-incremental) vs a reference: sum-per-key and min-per-key.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reduce
+//!
+//! Program shape (built by hand):  input: List<(K,V)>  -group->  List<(K, List<V>)>
+//!   -map((k,vs) -> (k, REDUCE vs))->  List<(K, V)>     (one row; REDUCE = fold_add / fold_min)
+
+use std::collections::BTreeMap;
+
+use corgi::{ArithOp, Builder, CmpOp, Graph, NumOp, Op, Red, Value as CValue};
+
+/// Build `input: List<(K,V)> -> group -> map((k,vs) -> (k, vs `reduce`))`.
+fn reduce_program(reduce: Red) -> Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input(); // List<Prod[K,V]>
+    let grouped = b.add(CmpOp::GroupKey, vec![input]); // List<Prod[K, List<V>]>
+
+    // MapList body: one element = Prod[K, List<V>]  ->  Prod[K, reduced V]
+    let body = {
+        let mut bb = Builder::<NumOp>::default();
+        let e = bb.input();
+        let k = bb.add(Op::Field(0), vec![e]);
+        let vs = bb.add(Op::Field(1), vec![e]);
+        let red = bb.add(ArithOp::Reduce(reduce), vec![vs]); // List<V> -> V
+        let out = bb.tuple(vec![k, red]);
+        bb.finish(out)
+    };
+    let mapped = b.add(Op::MapList(Box::new(body)), vec![grouped]);
+    b.finish(mapped)
+}
+
+/// Run a reduce program over `(keys, vals)` as one `List<(K,V)>` row; return key -> reduced.
+fn run_reduce(g: &Graph<NumOp>, keys: &[u64], vals: &[u64]) -> BTreeMap<u64, u64> {
+    let n = keys.len();
+    let pairs = CValue::Prod(vec![CValue::u64(keys.to_vec()), CValue::u64(vals.to_vec())]);
+    let input = CValue::List(vec![n].into(), Box::new(pairs)); // one row of n elements
+    let out = eval_graph_local(g, input);
+    let (_bounds, inner) = out.into_list("reduce out");
+    let cols = inner.into_prod("reduce pairs");
+    let ks = cols[0].clone().into_u64("k");
+    let vs = cols[1].clone().into_u64("v");
+    ks.into_iter().zip(vs).collect()
+}
+
+fn eval_graph_local(g: &Graph<NumOp>, v: CValue) -> CValue {
+    corgi::eval_graph(g, v)
+}
+
+fn main() {
+    let n = 10_000usize;
+    let keys: Vec<u64> = (0..n).map(|i| (i % 7) as u64).collect();
+    let vals: Vec<u64> = (0..n).map(|i| ((i * 13) % 101) as u64).collect();
+
+    // references
+    let mut ref_sum: BTreeMap<u64, u64> = BTreeMap::new();
+    let mut ref_min: BTreeMap<u64, u64> = BTreeMap::new();
+    for (&k, &v) in keys.iter().zip(&vals) {
+        *ref_sum.entry(k).or_insert(0) += v;
+        let e = ref_min.entry(k).or_insert(u64::MAX);
+        *e = (*e).min(v);
+    }
+
+    let g_sum = reduce_program(Red::Add);
+    let g_min = reduce_program(Red::Min);
+    let got_sum = run_reduce(&g_sum, &keys, &vals);
+    let got_min = run_reduce(&g_min, &keys, &vals);
+
+    assert_eq!(got_sum, ref_sum, "sum-per-key mismatch");
+    assert_eq!(got_min, ref_min, "min-per-key mismatch");
+
+    println!("M2(a): corgi expresses reduce (GroupKey + per-group fold)");
+    println!("  {n} updates, {} distinct keys", ref_sum.len());
+    println!("  sum-per-key:  OK   (e.g. key 0 -> {})", got_sum[&0]);
+    println!("  min-per-key:  OK   (e.g. key 0 -> {})", got_min[&0]);
+    println!("\ncorgi can group-by-key and fold each group in one program — the reduce logic the");
+    println!("incremental arrangement (M2b) will drive per changed key.");
+}
diff --git a/interactive/examples/corgi_reduce_dataflow.rs b/interactive/examples/corgi_reduce_dataflow.rs
new file mode 100644
index 000000000..89b9be703
--- /dev/null
+++ b/interactive/examples/corgi_reduce_dataflow.rs
@@ -0,0 +1,221 @@
+//! M2(b) reduce LIVE: the cursor-less `CorgiReduceTactic` (built on Frank's `active_times`) driving
+//! a real `reduce_with_tactic` over a corgi-columnar arrangement. Count-per-key, fed across two
+//! times with a retraction-to-zero, read back from the output arrangement's batch stream
+//! (`Vec<Rc<CorgiBatch>>`, cursor-free) and compared to a Rust reference.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reduce_dataflow
+
+use std::collections::BTreeMap;
+use std::rc::Rc;
+
+use timely::order::Product;
+use timely::progress::Timestamp;
+use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::capture::{Capture, Event};
+use timely::dataflow::operators::*;
+
+use differential_dataflow::input::Input;
+use differential_dataflow::operators::arrange::arrangement::arrange_core;
+use differential_dataflow::operators::reduce::reduce_with_tactic;
+use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::trace::implementations::spine_fueled::Spine;
+use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
+
+use differential_dataflow::operators::reduce::ReduceTactic;
+use differential_dataflow::trace::Description;
+use timely::progress::Antichain;
+
+use interactive::corgi_arrange::{CorgiBatch, CorgiBatchBuilder};
+use interactive::corgi_backend::CorgiContainer;
+use interactive::corgi_logic::{infer_shape, transcode, untranscode};
+use interactive::corgi_reduce::CorgiReduceTactic;
+use interactive::ir::{Diff, Value as DValue};
+use interactive::parse::Reducer;
+
+type Row = DValue;
+
+fn read_batch<T: Clone>(b: &CorgiBatch<T, Diff>) -> Vec<((Row, Row), T, Diff)> {
+    if b.times.is_empty() {
+        return Vec::new();
+    }
+    let keys = untranscode(b.keys.clone(), &corgi::shape_of_value(&b.keys));
+    let vals = untranscode(b.vals.clone(), &corgi::shape_of_value(&b.vals));
+    keys.into_iter()
+        .zip(vals)
+        .zip(&b.times)
+        .zip(&b.diffs)
+        .map(|(((k, v), t), d)| ((k, v), t.clone(), *d))
+        .collect()
+}
+
+/// Run the corgi backend's reduce over `updates`, return final consolidated `(key, reduced_val)`.
+/// Generic over the time `T` so we can test both totally-ordered (`u64`) and partial-order
+/// (`Product<u64,u64>`) times — the latter exercises `active_times`' synthetic-join-time generation.
+fn run_corgi(updates: Vec<((Row, Row), u64, Diff)>, reducer: Reducer) -> BTreeMap<(Row, Row), Diff> {
+    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
+    timely::execute_directly(move |worker| {
+        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
+            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
+            let corgi = coll.inner.unary(Pipeline, "ToCorgi", |_, _| {
+                |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
+                        output.session(&cap).give_container(&mut c);
+                    });
+                }
+            });
+            let arr = arrange_core::<_, CorgiContainer<u64, Diff>, ContainerChunker<Vec<((Row, Row), u64, Diff)>>, MergeBatcher<VecMerger<(Row, Row), u64, Diff>>, RcBuilder<CorgiBatchBuilder<u64, Diff>>, Spine<Rc<CorgiBatch<u64, Diff>>>>(corgi, Pipeline, "CorgiArrange");
+            let reduced = reduce_with_tactic::<_, Spine<Rc<CorgiBatch<u64, Diff>>>, _>(arr, "CorgiReduce", CorgiReduceTactic::<u64>::new(reducer));
+            reduced
+                .stream
+                .unary(Pipeline, "ReadReduceOut", |_, _| {
+                    |input, output| {
+                        input.for_each(|cap, data| {
+                            let mut rows: Vec<((Row, Row), u64, Diff)> = Vec::new();
+                            for batch in data.iter() {
+                                rows.extend(read_batch(batch));
+                            }
+                            output.session(&cap).give_container(&mut rows);
+                        });
+                    }
+                })
+                .capture_into(tx);
+            handle
+        });
+        for ((k, v), t, d) in updates {
+            handle.update_at((k, v), t, d);
+        }
+    });
+
+    let mut got: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for event in rx {
+        if let Event::Messages(_, rows) = event {
+            for ((k, v), _, d) in rows {
+                *got.entry((k, v)).or_insert(0) += d;
+            }
+        }
+    }
+    got.retain(|_, d| *d != 0);
+    got
+}
+
+/// Rust reference: net input per (key,val), then the reducer per key → final `(key, reduced_val): 1`.
+fn reference<T>(updates: &[((Row, Row), T, Diff)], reducer: &Reducer) -> BTreeMap<(Row, Row), Diff> {
+    let mut net: BTreeMap<(i64, i64), Diff> = BTreeMap::new();
+    for ((k, v), _, d) in updates {
+        if let (DValue::Int(k), DValue::Int(v)) = (k, v) {
+            *net.entry((*k, *v)).or_insert(0) += d;
+        }
+    }
+    let mut by_key: BTreeMap<i64, Vec<(i64, Diff)>> = BTreeMap::new();
+    for ((k, v), d) in net {
+        by_key.entry(k).or_default().push((v, d));
+    }
+    let mut out: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for (k, vals) in by_key {
+        let reduced: Option<Row> = match reducer {
+            Reducer::Count => {
+                let c: Diff = vals.iter().map(|(_, d)| *d).sum();
+                (c > 0).then(|| DValue::Tuple(vec![DValue::Int(c)]))
+            }
+            Reducer::Min => vals.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).min().map(DValue::Int),
+            Reducer::Distinct => vals.iter().any(|(_, d)| *d > 0).then(DValue::unit),
+            Reducer::Collect => unreachable!("not tested here"),
+        };
+        if let Some(r) = reduced {
+            out.insert((DValue::Int(k), r), 1);
+        }
+    }
+    out
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+fn main() {
+    // Directed: Count, 2 rounds incl. retraction-to-zero (key 2 vanishes; key 1 counts down 2→1).
+    let directed: Vec<((Row, Row), u64, Diff)> = vec![
+        ((DValue::Int(1), DValue::Int(10)), 0, 1),
+        ((DValue::Int(1), DValue::Int(20)), 0, 1),
+        ((DValue::Int(2), DValue::Int(30)), 0, 1),
+        ((DValue::Int(1), DValue::Int(10)), 1, -1),
+        ((DValue::Int(2), DValue::Int(30)), 1, -1),
+        ((DValue::Int(3), DValue::Int(40)), 1, 1),
+    ];
+    assert_eq!(run_corgi(directed.clone(), Reducer::Count), reference(&directed, &Reducer::Count), "directed Count");
+    println!("directed Count (retraction-to-zero): OK");
+
+    // Randomized property test: Count over random multi-time ±1 updates (robust to any net diffs).
+    let mut seed = 0x51ed_c0_fefe_beadu64;
+    for it in 0..120 {
+        let n = (xorshift(&mut seed) % 24) as usize + 1;
+        let ups: Vec<((Row, Row), u64, Diff)> = (0..n)
+            .map(|_| {
+                let k = (xorshift(&mut seed) % 5) as i64;
+                let v = (xorshift(&mut seed) % 7) as i64;
+                let t = xorshift(&mut seed) % 3;
+                let d = if xorshift(&mut seed) % 4 == 0 { -1 } else { 1 };
+                ((DValue::Int(k), DValue::Int(v)), t, d)
+            })
+            .collect();
+        let got = run_corgi(ups.clone(), Reducer::Count);
+        let want = reference(&ups, &Reducer::Count);
+        assert_eq!(got, want, "randomized Count iter {it}: {ups:?}");
+    }
+    println!("randomized Count: 120 cases == reference (random keys/vals/times/retractions)");
+
+    // Directed well-formed Min & Distinct (set semantics, no over-retraction).
+    let setlike: Vec<((Row, Row), u64, Diff)> = vec![
+        ((DValue::Int(1), DValue::Int(50)), 0, 1),
+        ((DValue::Int(1), DValue::Int(30)), 0, 1),
+        ((DValue::Int(1), DValue::Int(70)), 1, 1),
+        ((DValue::Int(1), DValue::Int(30)), 2, -1), // remove the current min at t2
+        ((DValue::Int(2), DValue::Int(9)), 0, 1),
+    ];
+    assert_eq!(run_corgi(setlike.clone(), Reducer::Min), reference(&setlike, &Reducer::Min), "Min");
+    assert_eq!(run_corgi(setlike.clone(), Reducer::Distinct), reference(&setlike, &Reducer::Distinct), "Distinct");
+    println!("directed Min & Distinct (min changes under retraction): OK");
+
+    // PARTIAL-ORDER test: the crux of `active_times`. Two updates for key 1 at incomparable times
+    // (0,1) and (1,0); the count is 1 at each, but must become 2 at the synthetic join time (1,1) —
+    // a time present in NEITHER input. If `active_times` failed to derive (1,1), the final count
+    // would be wrong (Tuple[1]:2 instead of Tuple[2]:1).
+    // (Partial-order times can't use `new_collection` [needs TotalOrder], so drive `retire` directly
+    // over one interval covering everything — this is also the most direct test of `active_times`.)
+    type PT = Product<u64, u64>;
+    let key_rows = vec![DValue::Int(1), DValue::Int(1), DValue::Int(2)];
+    let val_rows = vec![DValue::Int(10), DValue::Int(20), DValue::Int(5)];
+    let times: Vec<PT> = vec![Product::new(0, 1), Product::new(1, 0), Product::new(0, 0)];
+    let keys = transcode(&key_rows, &infer_shape(&key_rows[0]));
+    let vals = transcode(&val_rows, &infer_shape(&val_rows[0]));
+    let min = Antichain::from_elem(PT::minimum());
+    let batch = Rc::new(CorgiBatch::from_unsorted(keys, vals, times, vec![1, 1, 1], Description::new(min.clone(), Antichain::new(), min.clone())));
+
+    let mut tactic = CorgiReduceTactic::<PT>::new(Reducer::Count);
+    let (produced, _frontier) = tactic.retire(vec![], vec![], vec![batch], &min, &Antichain::new(), &min);
+
+    let mut got: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+    for (_ship, b) in &produced {
+        for ((k, v), _t, d) in read_batch(b) {
+            *got.entry((k, v)).or_insert(0) += d;
+        }
+    }
+    got.retain(|_, d| *d != 0);
+    // key1 sees vals 10 and 20 (at incomparable times) → count 2 at the synthetic join (1,1); key2 → 1.
+    let want: BTreeMap<(Row, Row), Diff> = [
+        ((DValue::Int(1), DValue::Tuple(vec![DValue::Int(2)])), 1),
+        ((DValue::Int(2), DValue::Tuple(vec![DValue::Int(1)])), 1),
+    ]
+    .into_iter()
+    .collect();
+    assert_eq!(got, want, "partial-order Count via direct retire (synthetic join time)");
+    println!("partial-order Count via direct retire (synthetic join (1,1) from (0,1)+(1,0) → count 2): OK  <-- active_times core");
+
+    println!("\nCursor-less corgi REDUCE (active_times) verified live vs reference — the last operator works.");
+}
diff --git a/interactive/examples/corgi_reduce_trace.rs b/interactive/examples/corgi_reduce_trace.rs
new file mode 100644
index 000000000..ee3e8999f
--- /dev/null
+++ b/interactive/examples/corgi_reduce_trace.rs
@@ -0,0 +1,103 @@
+//! M2(b)-3: the Route-B reduce MECHANISM, end-to-end over a manually maintained corgi trace —
+//! before the arrange_core/reduce_with_tactic timely plumbing. A trace is an accumulated
+//! `CorgiBatch` (merged via `merge`, consolidated per (key,val)); the reducer is a corgi program
+//! (Count = GroupKey + fold_add over the diff column, so retractions just subtract). We apply
+//! batches AND retractions and check the corgi-reduced output matches a reference each step.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reduce_trace
+
+use std::collections::BTreeMap;
+
+use timely::progress::Antichain;
+use differential_dataflow::trace::Description;
+
+use interactive::corgi_arrange::{merge, CorgiBatch};
+
+use corgi::{ArithOp, Builder, CmpOp, Graph, NumOp, Op, Red, Value as CValue};
+
+/// Build a single-time (t=0) CorgiBatch from `((key,val), diff)` updates.
+fn make_batch(updates: &[((u64, u64), i64)]) -> CorgiBatch<u64, i64> {
+    let keys = CValue::u64(updates.iter().map(|u| u.0 .0).collect());
+    let vals = CValue::u64(updates.iter().map(|u| u.0 .1).collect());
+    let times = vec![0u64; updates.len()];
+    let diffs = updates.iter().map(|u| u.1).collect();
+    let desc = Description::new(Antichain::from_elem(0), Antichain::from_elem(1), Antichain::from_elem(0));
+    CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
+}
+
+/// corgi Count reducer: `input: List<(key, diff)> -> group -> map((k, ds) -> (k, ds fold_add))`.
+fn count_program() -> Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input();
+    let grouped = b.add(CmpOp::GroupKey, vec![input]);
+    let body = {
+        let mut bb = Builder::<NumOp>::default();
+        let e = bb.input();
+        let k = bb.add(Op::Field(0), vec![e]);
+        let ds = bb.add(Op::Field(1), vec![e]);
+        let sum = bb.add(ArithOp::Reduce(Red::Add), vec![ds]); // fold_add — u64 add == i64 add on bits
+        let out = bb.tuple(vec![k, sum]);
+        bb.finish(out)
+    };
+    let mapped = b.add(Op::MapList(Box::new(body)), vec![grouped]);
+    b.finish(mapped)
+}
+
+/// Run the corgi Count reducer over the trace; key -> net count (nonzero only).
+fn reduce_count(trace: &CorgiBatch<u64, i64>, g: &Graph<NumOp>) -> BTreeMap<u64, i64> {
+    let n = trace.times.len();
+    if n == 0 {
+        return BTreeMap::new();
+    }
+    let diffcol = CValue::u64(trace.diffs.iter().map(|&d| d as u64).collect());
+    let pairs = CValue::Prod(vec![trace.keys.clone(), diffcol]);
+    let input = CValue::List(vec![n].into(), Box::new(pairs));
+    let out = corgi::eval_graph(g, input);
+    let (_b, inner) = out.into_list("count out");
+    let cols = inner.into_prod("kc");
+    let ks = cols[0].clone().into_u64("k");
+    let cs = cols[1].clone().into_u64("c");
+    ks.into_iter()
+        .zip(cs)
+        .map(|(k, c)| (k, c as i64))
+        .filter(|(_, c)| *c != 0)
+        .collect()
+}
+
+fn main() {
+    let g = count_program();
+    let z = Antichain::from_elem(0u64);
+
+    // A reference: cumulative diff per key over all applied updates.
+    let mut ref_counts: BTreeMap<u64, i64> = BTreeMap::new();
+    let apply_ref = |ups: &[((u64, u64), i64)], r: &mut BTreeMap<u64, i64>| {
+        for ((k, _v), d) in ups {
+            *r.entry(*k).or_insert(0) += d;
+        }
+        r.retain(|_, c| *c != 0);
+    };
+
+    let steps: Vec<Vec<((u64, u64), i64)>> = vec![
+        vec![((1, 10), 1), ((1, 20), 1), ((2, 30), 1)],     // +: {1:2, 2:1}
+        vec![((1, 10), -1), ((3, 40), 1)],                   // retract one of key 1; add key 3 -> {1:1,2:1,3:1}
+        vec![((1, 20), -1)],                                 // key 1 -> 0, disappears -> {2:1,3:1}
+        vec![((2, 30), 2), ((2, 31), 1)],                    // key 2 multi-val -> {2:4,3:1}
+    ];
+
+    let mut trace: Option<CorgiBatch<u64, i64>> = None;
+    for (i, step) in steps.iter().enumerate() {
+        let nb = make_batch(step);
+        trace = Some(match trace.take() {
+            None => nb,
+            Some(t) => merge(&t, &nb, z.borrow()),
+        });
+        let got = reduce_count(trace.as_ref().unwrap(), &g);
+        apply_ref(step, &mut ref_counts);
+        assert_eq!(got, ref_counts, "step {i}: corgi reduce != reference");
+        println!("  step {i}: {:?}  OK", got);
+    }
+
+    println!("\nM2(b)-3: Route-B reduce MECHANISM verified incrementally (adds + retractions).");
+    println!("  trace = accumulated CorgiBatch (merged over corgi columns); reducer = corgi Count");
+    println!("  program; each step's corgi output == reference. Next: wire into reduce_with_tactic.");
+}
diff --git a/interactive/examples/corgi_smoke.rs b/interactive/examples/corgi_smoke.rs
new file mode 100644
index 000000000..6030467d5
--- /dev/null
+++ b/interactive/examples/corgi_smoke.rs
@@ -0,0 +1,23 @@
+//! Rung-0 smoke test: prove we can drive corgi from inside the DDIR crate.
+//! Build a corgi program, run it over a column, read the result back.
+//! `~/.cargo/bin/cargo run -p interactive --example corgi_smoke`
+
+fn main() {
+    // A columnar program: per-row x -> x + 100. corgi ops are ALREADY columnar over a Prim
+    // column (the column IS the batch of rows), so no `map` wrapper — the op is the vectorized map.
+    // (`map`/MapList is only for mapping over the inner lists of a List column.)
+    let g = corgi::parse_ml("input add_u64 100").expect("parse");
+    let input = corgi::Value::u64(vec![1, 2, 3, 40, 900]);
+    let out = corgi::eval_graph(&g, input);
+    println!("corgi map(+100) over [1,2,3,40,900] = {}", corgi::show(&out));
+
+    // Shape inference (the dynamic-typing primitive we lean on): observe data -> Shape.
+    let sample = corgi::Value::u64(vec![7, 8, 9]);
+    println!("inferred shape of u64 column = {:?}", corgi::shape_of_value(&sample));
+
+    // Static shape check of the program against that input shape.
+    match corgi::shape_of(&g, &corgi::shape_of_value(&sample)) {
+        Ok(s) => println!("program output shape = {:?}", s),
+        Err(e) => println!("shape error: {e}"),
+    }
+}
diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
new file mode 100644
index 000000000..9e204c332
--- /dev/null
+++ b/interactive/src/backend/corgi.rs
@@ -0,0 +1,401 @@
+//! corgi-native rendering substrate (Route B): corgi columns are the native representation, the
+//! arrangement is `Spine<Rc<CorgiBatch>>` (cursor-less), and the scalar logic is `eval_graph`.
+//! Parallels `backend::vec`. Linear/arrange/join are corgi-native; `reduce` awaits Frank's
+//! cursor-less `retire` design (the operator's interesting-times machinery).
+//!
+//! This iteration: the `Backend` impl SHAPE compiles (arrange + leave_dynamic real; linear/join/
+//! as_collection/reduce/inspect = `todo!()`), validating the trait wiring + `render_tree::<CorgiBackend>`.
+
+use timely::container::CapacityContainerBuilder;
+use timely::dataflow::Scope;
+use timely::dataflow::channels::pact::Pipeline;
+use timely::dataflow::operators::generic::Operator;
+
+use differential_dataflow::AsCollection;
+use differential_dataflow::Collection;
+use differential_dataflow::operators::join::join_with_tactic;
+use differential_dataflow::operators::reduce::reduce_with_tactic;
+use differential_dataflow::operators::arrange::arrangement::arrange_core;
+use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
+use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
+use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
+use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
+
+use corgi::arrange::gather;
+use corgi::Value as CValue;
+
+use crate::backend::Backend;
+use crate::corgi_chunk::{batch_to_rows, CorgiChunk, CorgiChunkBuilder};
+use crate::corgi_backend::CorgiContainer;
+use crate::corgi_join::CorgiJoinTactic;
+use crate::corgi_reduce::CorgiReduceTactic;
+use crate::corgi_logic::{compilable, compile_predicate, compile_projection};
+use crate::ir::{Diff, LinearOp, Time, Value as DValue};
+use crate::parse::{Projection, Reducer};
+use crate::scope_ir as st;
+
+/// Apply a `LinearOp` chain to one corgi container (the corgi-native row-wise compute per batch).
+/// Project = corgi `eval_graph`; Filter = corgi mask + `gather`; Negate = Rust — all columnar.
+/// The time/list-shaping ops (EnterAt/LiftIter/FlatMap) take a correctness-first row-wise path
+/// (untranscode → vec-style transform → `from_updates`), matching `backend::vec` exactly; a columnar
+/// fast-path is future work. `level` is the scope depth (locates the iteration coordinate).
+fn apply_ops(mut c: CC, ops: &[LinearOp], level: usize) -> CC {
+    use timely::order::Product;
+    use differential_dataflow::lattice::Lattice;
+    use differential_dataflow::dynamic::pointstamp::PointStamp;
+
+    for op in ops {
+        c = match op {
+            LinearOp::Project(p) if compilable(&p.key) && compilable(&p.val) => {
+                let (kshape, vshape) = (corgi::shape_of_value(&c.keys), corgi::shape_of_value(&c.vals));
+                let g = compile_projection(&p.key, &p.val, &kshape, &vshape);
+                let mut cols = corgi::eval_graph(&g, CValue::Prod(vec![c.keys, c.vals])).into_prod("linear project");
+                let vals = cols.pop().unwrap();
+                let keys = cols.pop().unwrap();
+                CorgiContainer { keys, vals, times: c.times, diffs: c.diffs }
+            }
+            LinearOp::Filter(cond) if compilable(cond) => {
+                let (kshape, vshape) = (corgi::shape_of_value(&c.keys), corgi::shape_of_value(&c.vals));
+                let g = compile_predicate(cond, &kshape, &vshape);
+                let mask = corgi::eval_graph(&g, CValue::Prod(vec![c.keys.clone(), c.vals.clone()])).into_u64("filter mask");
+                let keep: Vec<usize> = (0..mask.len()).filter(|&i| mask[i] != 0).collect();
+                let keys = gather(&c.keys, &keep);
+                let vals = gather(&c.vals, &keep);
+                let times = keep.iter().map(|&i| c.times[i].clone()).collect();
+                let diffs = keep.iter().map(|&i| c.diffs[i]).collect();
+                CorgiContainer { keys, vals, times, diffs }
+            }
+            // Row-wise fallback for projections/predicates the corgi compiler can't lower (List,
+            // Case/Inject, Unary, Hash) — `ir::eval`, parity with `backend::vec`.
+            LinearOp::Project(p) => {
+                let mut out: Vec<Upd> = Vec::new();
+                for ((k, v), t, d) in c.into_updates() {
+                    let mut env = vec![k, v];
+                    let nk = crate::ir::eval(&p.key, &mut env);
+                    let nv = crate::ir::eval(&p.val, &mut env);
+                    out.push(((nk, nv), t, d));
+                }
+                CorgiContainer::from_updates(out)
+            }
+            LinearOp::Filter(cond) => {
+                let mut out: Vec<Upd> = Vec::new();
+                for ((k, v), t, d) in c.into_updates() {
+                    let keep = { let mut env = vec![k.clone(), v.clone()]; crate::ir::eval(cond, &mut env).truthy() };
+                    if keep { out.push(((k, v), t, d)); }
+                }
+                CorgiContainer::from_updates(out)
+            }
+            LinearOp::Negate => {
+                for d in c.diffs.iter_mut() {
+                    *d = -*d;
+                }
+                c
+            }
+            // Row-wise ops (parity with `backend::vec::render_linear`).
+            LinearOp::EnterAt(field) => {
+                let mut out: Vec<Upd> = Vec::new();
+                for ((k, v), t, d) in c.into_updates() {
+                    let delay = {
+                        let mut env = vec![k.clone(), v.clone()];
+                        let raw = crate::ir::eval(field, &mut env).as_int() as u64;
+                        256 * (64 - raw.leading_zeros() as u64)
+                    };
+                    let mut coords = smallvec::SmallVec::<[u64; 1]>::new();
+                    for _ in 0..level.saturating_sub(1) { coords.push(0); }
+                    coords.push(delay);
+                    let delta = Product::new(0u64, PointStamp::new(coords));
+                    out.push(((k, v), t.join(&delta), d));
+                }
+                CorgiContainer::from_updates(out)
+            }
+            LinearOp::LiftIter => {
+                let mut out: Vec<Upd> = Vec::new();
+                for ((k, v), t, d) in c.into_updates() {
+                    let iter = level
+                        .checked_sub(1)
+                        .and_then(|idx| t.inner.get(idx).copied())
+                        .unwrap_or(0) as i64;
+                    out.push(((k, append_iter(v, iter)), t, d));
+                }
+                CorgiContainer::from_updates(out)
+            }
+            LinearOp::FlatMap(list_term) => {
+                let mut out: Vec<Upd> = Vec::new();
+                for ((k, v), t, d) in c.into_updates() {
+                    let elems = {
+                        let mut env = vec![k.clone(), v.clone()];
+                        match crate::ir::eval(list_term, &mut env) {
+                            DValue::List(xs) => xs,
+                            other => panic!("flatmap: expected a List, got {other:?}"),
+                        }
+                    };
+                    for (pos, elem) in elems.into_iter().enumerate() {
+                        out.push(((k.clone(), DValue::Tuple(vec![DValue::Int(pos as i64), elem])), t.clone(), d));
+                    }
+                }
+                CorgiContainer::from_updates(out)
+            }
+        };
+    }
+    c
+}
+
+/// Append the user-iter coordinate to a value (mirrors `backend::vec::append_iter`): extend a `Tuple`,
+/// or wrap any other value as `(value, iter)`.
+fn append_iter(val: DValue, iter: i64) -> DValue {
+    match val {
+        DValue::Tuple(mut xs) => { xs.push(DValue::Int(iter)); DValue::Tuple(xs) }
+        other => DValue::Tuple(vec![other, DValue::Int(iter)]),
+    }
+}
+
+type Row = DValue;
+type Upd = ((Row, Row), Time, Diff);
+type CC = CorgiContainer<Time, Diff>;
+type CTrace = differential_dataflow::trace::chunk::ChunkSpine<CorgiChunk<Time, Diff>>;
+
+/// The corgi rendering substrate.
+pub enum CorgiBackend {}
+
+impl Backend for CorgiBackend {
+    type Container = CC;
+    type Arr<'scope> = Arranged<'scope, TraceAgent<CTrace>>;
+
+    fn linear<'s>(c: Collection<'s, Time, CC>, ops: Vec<LinearOp>, level: usize) -> Collection<'s, Time, CC> {
+        // Container-level: fold the LinearOp chain over each corgi batch (no inter-op transcode).
+        // `level` is the scope depth (locates the iteration coordinate for LiftIter/EnterAt).
+        c.inner
+            .unary(Pipeline, "CorgiLinear", move |_, _| {
+                move |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut out = apply_ops(std::mem::take(data), &ops, level);
+                        output.session(&cap).give_container(&mut out);
+                    });
+                }
+            })
+            .as_collection()
+    }
+
+    fn arrange<'s>(c: Collection<'s, Time, CC>) -> Self::Arr<'s> {
+        arrange_core::<_, CC, ContainerChunker<Vec<Upd>>, MergeBatcher<VecMerger<(Row, Row), Time, Diff>>, RcBuilder<CorgiChunkBuilder<Time, Diff>>, CTrace>(
+            c.inner,
+            Pipeline,
+            "CorgiArrange",
+        )
+    }
+
+    fn as_collection<'s>(a: Self::Arr<'s>) -> Collection<'s, Time, CC> {
+        // Cursor-free: the arrangement's stream carries `Vec<Rc<CorgiBatch>>`; read each batch's
+        // updates (corgi columns → rows) and reassemble a corgi container of those updates.
+        a.stream
+            .unary(Pipeline, "CorgiAsCollection", |_, _| {
+                |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut rows = Vec::new();
+                        for batch in data.iter() {
+                            rows.extend(batch_to_rows(batch));
+                        }
+                        let mut c = CorgiContainer::from_updates(rows);
+                        output.session(&cap).give_container(&mut c);
+                    });
+                }
+            })
+            .as_collection()
+    }
+
+    fn join<'s>(l: Self::Arr<'s>, r: Self::Arr<'s>, projection: &Projection) -> Collection<'s, Time, CC> {
+        // The tactic compiles the projection per work-unit (shape-directed, for `Spread`).
+        let tactic = CorgiJoinTactic::new(projection.key.clone(), projection.val.clone());
+        // join_with_tactic emits Vec-rows (via the output session); a ToCorgi unary rebuilds the
+        // corgi container at the operator output boundary.
+        let rows = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<Upd>>>(l, r, tactic);
+        rows.unary(Pipeline, "JoinToCorgi", |_, _| {
+            |input, output| {
+                input.for_each(|cap, data| {
+                    let mut c = CorgiContainer::from_updates(std::mem::take(data));
+                    output.session(&cap).give_container(&mut c);
+                });
+            }
+        })
+        .as_collection()
+    }
+
+    fn reduce<'s>(a: Self::Arr<'s>, reducer: &Reducer) -> Self::Arr<'s> {
+        reduce_with_tactic::<_, CTrace, _>(a, "CorgiReduce", CorgiReduceTactic::new(reducer.clone()))
+    }
+
+    fn inspect<'s>(c: Collection<'s, Time, CC>, label: String) -> Collection<'s, Time, CC> {
+        c.inner
+            .unary(Pipeline, "CorgiInspect", move |_, _| {
+                move |input, output| {
+                    input.for_each(|cap, data| {
+                        let mut cont = std::mem::take(data);
+                        for ((k, v), t, d) in cont.clone().into_updates() {
+                            eprintln!("  [{label}] (({k:?}, {v:?}), {t:?}, {d})");
+                        }
+                        output.session(&cap).give_container(&mut cont);
+                    });
+                }
+            })
+            .as_collection()
+    }
+
+    fn leave_dynamic<'s>(c: Collection<'s, Time, CC>, level: usize) -> Collection<'s, Time, CC> {
+        // Mirror DD's `Collection::leave_dynamic` (dynamic/mod.rs:40), but over a `CorgiContainer`:
+        // strip all but `level-1` PointStamp coordinates from the capability AND from each row's time
+        // (stored columnar in `CorgiContainer.times`, not inline in the data tuples). The input
+        // connection summary advertises the `retain` so timely's progress tracking stays correct.
+        use timely::dataflow::operators::generic::{builder_rc::OperatorBuilder, OutputBuilder};
+        use timely::order::Product;
+        use timely::progress::Antichain;
+        use differential_dataflow::dynamic::pointstamp::{PointStamp, PointStampSummary};
+
+        let mut builder = OperatorBuilder::new("CorgiLeaveDynamic".to_string(), c.inner.scope());
+        let (output, stream) = builder.new_output();
+        let mut output = OutputBuilder::from(output);
+        let summary = Product { outer: Default::default(), inner: PointStampSummary { retain: Some(level - 1), actions: Vec::new() } };
+        let mut input = builder.new_input_connection(c.inner, Pipeline, [(0, Antichain::from_elem(summary))]);
+
+        builder.build(move |_capability| move |_frontier| {
+            let mut output = output.activate();
+            input.for_each(|cap, data| {
+                let mut new_time = cap.time().clone();
+                let mut v = std::mem::take(&mut new_time.inner).into_inner();
+                v.truncate(level - 1);
+                new_time.inner = PointStamp::new(v);
+                let new_cap = cap.delayed(&new_time, 0);
+                for t in data.times.iter_mut() {
+                    let mut v = std::mem::take(&mut t.inner).into_inner();
+                    v.truncate(level - 1);
+                    t.inner = PointStamp::new(v);
+                }
+                output.session(&new_cap).give_container(data);
+            });
+        });
+
+        stream.as_collection()
+    }
+}
+
+/// Render `s` with the corgi substrate. See [`crate::backend::render_tree`].
+pub fn render_tree<'s>(
+    s: &st::Scope,
+    scope: Scope<'s, Time>,
+    depth: usize,
+    imports: Vec<Collection<'s, Time, CC>>,
+) -> Vec<Collection<'s, Time, CC>> {
+    crate::backend::render_tree::<CorgiBackend>(s, scope, depth, imports)
+}
+
+/// Evaluate `program` on explicit inputs via the **corgi** backend (mirrors [`crate::backend::vec::evaluate`]).
+///
+/// Inputs/exports cross the iterative-scope boundary as Vec rows (which support refinement
+/// enter/leave); corgi containers exist only INSIDE the dynamic scope, where `Enter`/`Leave` are the
+/// same-Time identity. The `ToCorgi`/`FromCorgi` unaries are the only row↔corgi conversions.
+pub fn evaluate(
+    program: &st::Program,
+    inputs: &[Vec<(Row, Row)>],
+) -> std::collections::BTreeMap<String, Vec<((Row, Row), Diff)>> {
+    use std::collections::BTreeMap;
+    use std::sync::mpsc::channel;
+    use timely::dataflow::operators::core::capture::{Capture, Event};
+    use timely::dataflow::operators::generic::Operator;
+    use differential_dataflow::input::Input;
+    use differential_dataflow::AsCollection;
+    use differential_dataflow::dynamic::pointstamp::PointStamp;
+    use crate::corgi_backend::CorgiContainer;
+
+    let names: Vec<String> = program.root.exports.iter().map(|e| e.name.clone()).collect();
+    let mut txs = Vec::new();
+    let mut rxs = Vec::new();
+    for _ in &names {
+        let (tx, rx) = channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
+        txs.push(tx);
+        rxs.push(rx);
+    }
+
+    let program = program.clone();
+    let inputs: Vec<Vec<(Row, Row)>> = inputs.to_vec();
+    timely::execute_directly(move |worker| {
+        let mut handles = worker.dataflow::<u64, _, _>(|scope| {
+            let mut handles = Vec::new();
+            let mut collections = Vec::new();
+            for _ in 0..inputs.len() {
+                let (h, c) = scope.new_collection::<(Row, Row), Diff>();
+                handles.push(h);
+                collections.push(c);
+            }
+            let exports = scope.iterative::<PointStamp<u64>, _, _>(|inner| {
+                // Enter Vec collections (refinement), then convert each to a corgi container.
+                let mut corgi_imports = Vec::new();
+                for c in collections.iter().map(|c| c.clone().enter(inner)) {
+                    let cs = c
+                        .inner
+                        .unary(Pipeline, "ToCorgi", |_, _| {
+                            |input, output| {
+                                input.for_each(|cap, data| {
+                                    let mut cc = CorgiContainer::from_updates(std::mem::take(data));
+                                    output.session(&cap).give_container(&mut cc);
+                                });
+                            }
+                        })
+                        .as_collection();
+                    corgi_imports.push(cs);
+                }
+                let root_imports: Vec<_> = program
+                    .root
+                    .imports
+                    .iter()
+                    .map(|imp| match &imp.from {
+                        st::Source::Input(n) => corgi_imports[*n].clone(),
+                        other => panic!("corgi evaluate: unsupported source {other:?}"),
+                    })
+                    .collect();
+                let exports = render_tree(&program.root, inner.clone(), 0, root_imports);
+                // Convert corgi exports back to Vec rows, then leave the scope.
+                let mut leaved = Vec::new();
+                for c in exports {
+                    let rows = c
+                        .inner
+                        .unary(Pipeline, "FromCorgi", |_, _| {
+                            |input, output| {
+                                input.for_each(|cap, data| {
+                                    let mut rows = std::mem::take(data).into_updates();
+                                    output.session(&cap).give_container(&mut rows);
+                                });
+                            }
+                        })
+                        .as_collection();
+                    leaved.push(rows.leave(scope));
+                }
+                leaved
+            });
+            for (col, tx) in exports.into_iter().zip(txs) {
+                col.inner.capture_into(tx);
+            }
+            handles
+        });
+        for (i, rows) in inputs.iter().enumerate() {
+            for r in rows {
+                handles[i].update(r.clone(), 1);
+            }
+        }
+    });
+
+    names
+        .into_iter()
+        .zip(rxs)
+        .map(|(name, rx)| {
+            let mut acc: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
+            for event in rx {
+                if let Event::Messages(_, data) = event {
+                    for ((k, v), _, d) in data {
+                        *acc.entry((k, v)).or_insert(0) += d;
+                    }
+                }
+            }
+            (name, acc.into_iter().filter(|(_, d)| *d != 0).collect())
+        })
+        .collect()
+}
diff --git a/interactive/src/backend/mod.rs b/interactive/src/backend/mod.rs
index d1bbf5fa6..df67d70c9 100644
--- a/interactive/src/backend/mod.rs
+++ b/interactive/src/backend/mod.rs
@@ -11,6 +11,7 @@
 //! that pick a backend and call [`render_tree`].
 
 pub mod vec;
+pub mod corgi;
 // The columnar substrate is deferred on the Value-model port (it needs a
 // `Columnar`/columnar-storage story for `Value`); see `backend::vec`.
 // pub mod col;
diff --git a/interactive/src/corgi_arrange.rs b/interactive/src/corgi_arrange.rs
new file mode 100644
index 000000000..b760f3f91
--- /dev/null
+++ b/interactive/src/corgi_arrange.rs
@@ -0,0 +1,465 @@
+//! Phase 2 / M2(b) Route B — the cursor-less corgi arrangement batch.
+//!
+//! `CorgiBatch` stores a sorted, consolidated run of `(key, val, time, diff)` with key/val as corgi
+//! columns and time/diff as Rust Vecs. It implements `BatchReader` (len/description) but NO `Cursor`:
+//! navigation is the tactic's concern (it reads the corgi columns in bulk). Sorting/merging use the
+//! corgi `arrange` API (`compare_at` for the (key,val) order, `gather`/`gather_lanes` to materialize),
+//! with the time tiebreak + diff consolidation + time-advance in plain Rust (corgi never sees time).
+//!
+//! Order: (key, val) by corgi structural order, then time by `Ord`. Any total order works as long as
+//! it is used consistently (correctness compares multisets, not against DDIR's derived `Ord`).
+
+use std::cmp::Ordering;
+
+use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
+
+use differential_dataflow::difference::Semigroup;
+use differential_dataflow::lattice::Lattice;
+use differential_dataflow::trace::{Batch, BatchReader, Builder as DdBuilder, Description, Merger as DdMerger};
+
+use corgi::Value as CValue;
+use corgi::arrange::{compare_at, gather, gather_lanes};
+
+use crate::corgi_logic::{infer_shape, transcode, untranscode};
+use crate::ir::Value as DValue;
+
+/// A sorted, consolidated arrangement batch with corgi-columnar key/val payload.
+#[derive(Clone)]
+pub struct CorgiBatch<T, R> {
+    /// Key column (corgi), aligned with `vals`/`times`/`diffs`, sorted by (key, val, time).
+    pub keys: CValue,
+    /// Val column (corgi).
+    pub vals: CValue,
+    /// Per-update times (Rust; the lattice algebra lives here, not in corgi).
+    pub times: Vec<T>,
+    /// Per-update diffs (Rust).
+    pub diffs: Vec<R>,
+    /// Time bounds of the batch.
+    pub desc: Description<T>,
+}
+
+impl<T: Timestamp + Lattice, R: Semigroup + 'static> BatchReader for CorgiBatch<T, R> {
+    type Time = T;
+    fn len(&self) -> usize { self.times.len() }
+    fn description(&self) -> &Description<T> { &self.desc }
+}
+
+/// The (key,val) sort payload as one corgi Prod column (cheap Arc bumps).
+fn kv_of<T, R>(b: &CorgiBatch<T, R>) -> CValue {
+    CValue::Prod(vec![b.keys.clone(), b.vals.clone()])
+}
+
+/// Split a `Prod([keys, vals])` corgi value into its two columns.
+fn split_kv(kv: CValue) -> (CValue, CValue) {
+    let mut cols = kv.into_prod("corgi batch kv");
+    let vals = cols.pop().unwrap();
+    let keys = cols.pop().unwrap();
+    (keys, vals)
+}
+
+impl<T: Clone, R: Copy> CorgiBatch<T, R> {
+    /// Read the batch back to `((key, val), time, diff)` rows (cursor-free; untranscodes the corgi
+    /// key/val columns). Used by `Backend::as_collection`, the reduce tactic, and tests.
+    pub fn to_updates(&self) -> Vec<((DValue, DValue), T, R)> {
+        if self.times.is_empty() {
+            return Vec::new();
+        }
+        let keys = untranscode(self.keys.clone(), &corgi::shape_of_value(&self.keys));
+        let vals = untranscode(self.vals.clone(), &corgi::shape_of_value(&self.vals));
+        keys.into_iter()
+            .zip(vals)
+            .zip(&self.times)
+            .zip(&self.diffs)
+            .map(|(((k, v), t), d)| ((k, v), t.clone(), *d))
+            .collect()
+    }
+}
+
+impl<T: Timestamp + Lattice, R: Semigroup + Clone + 'static> CorgiBatch<T, R> {
+    /// Build a batch from parallel, UNSORTED columns: sort by (key,val,time) and consolidate
+    /// equal (key,val,time) triples (dropping zero diffs).
+    pub fn from_unsorted(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>, desc: Description<T>) -> Self {
+        let n = times.len();
+        let kv = CValue::Prod(vec![keys, vals]);
+        let mut perm: Vec<usize> = (0..n).collect();
+        perm.sort_by(|&i, &j| compare_at(&kv, i, &kv, j).then_with(|| times[i].cmp(&times[j])));
+        let kv_s = gather(&kv, &perm);
+        let times_s: Vec<T> = perm.iter().map(|&i| times[i].clone()).collect();
+        let diffs_s: Vec<R> = perm.iter().map(|&i| diffs[i].clone()).collect();
+
+        let (mut keep, mut ot, mut od) = (Vec::new(), Vec::new(), Vec::new());
+        let mut i = 0;
+        while i < n {
+            let t = times_s[i].clone();
+            let mut d = diffs_s[i].clone();
+            let mut k = i + 1;
+            while k < n && compare_at(&kv_s, i, &kv_s, k) == Ordering::Equal && times_s[k] == t {
+                d.plus_equals(&diffs_s[k]);
+                k += 1;
+            }
+            if !d.is_zero() {
+                keep.push(i);
+                ot.push(t);
+                od.push(d);
+            }
+            i = k;
+        }
+        let (keys, vals) = split_kv(gather(&kv_s, &keep));
+        CorgiBatch { keys, vals, times: ot, diffs: od, desc }
+    }
+}
+
+/// Advance a group's (time, diff) pairs to `frontier`, consolidate by advanced time, and emit the
+/// surviving rows pointing at one representative source row `(rep_tag, rep_off)` (same key/val).
+#[allow(clippy::too_many_arguments)]
+fn emit_group<T, R>(
+    pairs: Vec<(T, R)>,
+    rep_tag: usize,
+    rep_off: usize,
+    frontier: AntichainRef<T>,
+    tags: &mut Vec<usize>,
+    off: &mut Vec<usize>,
+    times: &mut Vec<T>,
+    diffs: &mut Vec<R>,
+) where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone,
+{
+    let mut adv: Vec<(T, R)> = pairs
+        .into_iter()
+        .map(|(mut t, d)| {
+            t.advance_by(frontier);
+            (t, d)
+        })
+        .collect();
+    adv.sort_by(|a, b| a.0.cmp(&b.0));
+    let mut k = 0;
+    while k < adv.len() {
+        let t = adv[k].0.clone();
+        let mut d = adv[k].1.clone();
+        k += 1;
+        while k < adv.len() && adv[k].0 == t {
+            d.plus_equals(&adv[k].1);
+            k += 1;
+        }
+        if !d.is_zero() {
+            tags.push(rep_tag);
+            off.push(rep_off);
+            times.push(t);
+            diffs.push(d);
+        }
+    }
+}
+
+/// Merge two sorted `CorgiBatch`es into one, advancing all times to `frontier` and consolidating.
+/// (key,val) groups are walked in sorted order via `compare_at`; each group's (time,diff) pairs from
+/// both sources are advanced+consolidated; output columns are materialized with `gather_lanes`.
+pub fn merge<T, R>(b1: &CorgiBatch<T, R>, b2: &CorgiBatch<T, R>, frontier: AntichainRef<T>) -> CorgiBatch<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let kv1 = kv_of(b1);
+    let kv2 = kv_of(b2);
+    let (n1, n2) = (b1.len(), b2.len());
+    let (mut i, mut j) = (0, 0);
+    let (mut tags, mut off) = (Vec::new(), Vec::new());
+    let (mut times, mut diffs) = (Vec::new(), Vec::new());
+
+    // length of b1's (key,val) run starting at `s`.
+    let run1 = |s: usize, i: &mut usize| {
+        let mut pairs = Vec::new();
+        while *i < n1 && compare_at(&kv1, s, &kv1, *i) == Ordering::Equal {
+            pairs.push((b1.times[*i].clone(), b1.diffs[*i].clone()));
+            *i += 1;
+        }
+        pairs
+    };
+    let run2 = |s: usize, j: &mut usize| {
+        let mut pairs = Vec::new();
+        while *j < n2 && compare_at(&kv2, s, &kv2, *j) == Ordering::Equal {
+            pairs.push((b2.times[*j].clone(), b2.diffs[*j].clone()));
+            *j += 1;
+        }
+        pairs
+    };
+
+    while i < n1 && j < n2 {
+        match compare_at(&kv1, i, &kv2, j) {
+            Ordering::Less => {
+                let s = i;
+                let pairs = run1(s, &mut i);
+                emit_group(pairs, 0, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
+            }
+            Ordering::Greater => {
+                let s = j;
+                let pairs = run2(s, &mut j);
+                emit_group(pairs, 1, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
+            }
+            Ordering::Equal => {
+                let (s1, s2) = (i, j);
+                let mut pairs = run1(s1, &mut i);
+                pairs.extend(run2(s2, &mut j));
+                emit_group(pairs, 0, s1, frontier, &mut tags, &mut off, &mut times, &mut diffs);
+            }
+        }
+    }
+    while i < n1 {
+        let s = i;
+        let pairs = run1(s, &mut i);
+        emit_group(pairs, 0, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
+    }
+    while j < n2 {
+        let s = j;
+        let pairs = run2(s, &mut j);
+        emit_group(pairs, 1, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
+    }
+
+    // An empty source carries a `Unit(0)` placeholder shape (see `Batch::empty`), which would trip
+    // `gather_lanes`' cross-source shape check even though no tag references it. Substitute the
+    // non-empty side's `kv` for any empty source so all sources share the real shape; the substituted
+    // reference is never indexed (no tag points to an empty side).
+    let (src0, src1) = match (n1 == 0, n2 == 0) {
+        (false, true) => (&kv1, &kv1),
+        (true, false) => (&kv2, &kv2),
+        _ => (&kv1, &kv2),
+    };
+    let (keys, vals) = if tags.is_empty() {
+        // Both empty (or fully cancelled): use whichever source has a real shape.
+        let witness = if n1 != 0 { &b1.keys } else { &b2.keys };
+        let witness_v = if n1 != 0 { &b1.vals } else { &b2.vals };
+        (gather(witness, &[]), gather(witness_v, &[]))
+    } else {
+        split_kv(gather_lanes(&[Some(src0), Some(src1)], &tags, &off))
+    };
+    let lower = b1.desc.lower().meet(b2.desc.lower());
+    let upper = b1.desc.upper().join(b2.desc.upper());
+    let desc = Description::new(lower, upper, frontier.to_owned());
+    CorgiBatch { keys, vals, times, diffs, desc }
+}
+
+/// `Batch::Merger` for `CorgiBatch`: an eager wrapper around [`merge`]. Correctness-first — it does
+/// the whole merge on the first `work` and leaves `fuel` untouched (positive → "complete"), so there
+/// is no latency smoothing yet. Fuel-bounded incremental merging is a later refinement.
+pub struct CorgiMerger<T, R> {
+    result: Option<CorgiBatch<T, R>>,
+    frontier: Antichain<T>,
+}
+
+impl<T, R> DdMerger<CorgiBatch<T, R>> for CorgiMerger<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    fn new(_s1: &CorgiBatch<T, R>, _s2: &CorgiBatch<T, R>, frontier: AntichainRef<T>) -> Self {
+        CorgiMerger { result: None, frontier: frontier.to_owned() }
+    }
+    fn work(&mut self, s1: &CorgiBatch<T, R>, s2: &CorgiBatch<T, R>, _fuel: &mut isize) {
+        if self.result.is_none() {
+            self.result = Some(merge(s1, s2, self.frontier.borrow()));
+        }
+    }
+    fn done(self) -> CorgiBatch<T, R> {
+        self.result.expect("CorgiMerger::done called before work")
+    }
+}
+
+impl<T, R> Batch for CorgiBatch<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    type Merger = CorgiMerger<T, R>;
+    fn empty(lower: Antichain<T>, upper: Antichain<T>) -> Self {
+        CorgiBatch {
+            keys: CValue::Unit(0),
+            vals: CValue::Unit(0),
+            times: Vec::new(),
+            diffs: Vec::new(),
+            desc: Description::new(lower, upper, Antichain::from_elem(T::minimum())),
+        }
+    }
+}
+
+/// Build a `CorgiBatch` from DDIR row updates (the arrangement-ingest boundary transcode). The
+/// batcher delivers sorted+consolidated chains; `from_unsorted` re-sorts idempotently for safety.
+fn build_batch<T, R>(updates: Vec<((DValue, DValue), T, R)>, desc: Description<T>) -> CorgiBatch<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    if updates.is_empty() {
+        return CorgiBatch { keys: CValue::Unit(0), vals: CValue::Unit(0), times: Vec::new(), diffs: Vec::new(), desc };
+    }
+    let kshape = infer_shape(&updates[0].0 .0);
+    let vshape = infer_shape(&updates[0].0 .1);
+    let keys_rows: Vec<DValue> = updates.iter().map(|u| u.0 .0.clone()).collect();
+    let vals_rows: Vec<DValue> = updates.iter().map(|u| u.0 .1.clone()).collect();
+    let times = updates.iter().map(|u| u.1.clone()).collect();
+    let diffs = updates.iter().map(|u| u.2.clone()).collect();
+    let keys = transcode(&keys_rows, &kshape);
+    let vals = transcode(&vals_rows, &vshape);
+    CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
+}
+
+/// DD `Builder` for `CorgiBatch`: consumes sorted/consolidated row chains (the batcher's `Output`)
+/// and builds a corgi-columnar batch. `Input = Vec<((key,val), time, diff)>` so the existing
+/// `MergeBatcher` over vec rows can be reused as the `Batcher`. Wrapped by `RcBuilder` → `Rc<CorgiBatch>`.
+pub struct CorgiBatchBuilder<T, R> {
+    updates: Vec<((DValue, DValue), T, R)>,
+}
+
+impl<T, R> DdBuilder for CorgiBatchBuilder<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    type Input = Vec<((DValue, DValue), T, R)>;
+    type Time = T;
+    type Output = CorgiBatch<T, R>;
+
+    fn with_capacity(_keys: usize, _vals: usize, upds: usize) -> Self {
+        CorgiBatchBuilder { updates: Vec::with_capacity(upds) }
+    }
+    fn push(&mut self, chunk: &mut Self::Input) {
+        self.updates.append(chunk);
+    }
+    fn done(self, description: Description<T>) -> CorgiBatch<T, R> {
+        build_batch(self.updates, description)
+    }
+    fn seal(chain: &mut Vec<Self::Input>, description: Description<T>) -> CorgiBatch<T, R> {
+        let mut all = Vec::new();
+        for c in chain.iter_mut() {
+            all.append(c);
+        }
+        build_batch(all, description)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn xorshift(seed: &mut u64) -> u64 {
+        *seed ^= *seed << 13;
+        *seed ^= *seed >> 7;
+        *seed ^= *seed << 17;
+        *seed
+    }
+
+    /// Build a CorgiBatch from u64 (key,val) updates with a [lower,upper) description.
+    fn batch(updates: &[((u64, u64), u64, i64)], lower: u64, upper: u64) -> CorgiBatch<u64, i64> {
+        let keys = CValue::u64(updates.iter().map(|u| u.0 .0).collect());
+        let vals = CValue::u64(updates.iter().map(|u| u.0 .1).collect());
+        let times = updates.iter().map(|u| u.1).collect();
+        let diffs = updates.iter().map(|u| u.2).collect();
+        let desc = Description::new(
+            Antichain::from_elem(lower),
+            Antichain::from_elem(upper),
+            Antichain::from_elem(0u64),
+        );
+        CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
+    }
+
+    /// Read a batch back to a ((k,v),t)->d map.
+    fn read(b: &CorgiBatch<u64, i64>) -> std::collections::BTreeMap<((u64, u64), u64), i64> {
+        let ks = b.keys.clone().into_u64("k");
+        let vs = b.vals.clone().into_u64("v");
+        let mut m = std::collections::BTreeMap::new();
+        for idx in 0..b.times.len() {
+            *m.entry(((ks[idx], vs[idx]), b.times[idx])).or_insert(0) += b.diffs[idx];
+        }
+        m.retain(|_, d| *d != 0);
+        m
+    }
+
+    /// Reference: union both update sets, advance times to `f`, consolidate by ((k,v),t).
+    fn reference(u1: &[((u64, u64), u64, i64)], u2: &[((u64, u64), u64, i64)], f: u64) -> std::collections::BTreeMap<((u64, u64), u64), i64> {
+        let mut m = std::collections::BTreeMap::new();
+        for u in u1.iter().chain(u2) {
+            let t = u.1.max(f); // advance_by for a total u64 order = max
+            *m.entry((u.0, t)).or_insert(0) += u.2;
+        }
+        m.retain(|_, d| *d != 0);
+        m
+    }
+
+    #[test]
+    fn from_unsorted_sorts_and_consolidates() {
+        let u = vec![((1, 0), 3, 1), ((0, 0), 0, 1), ((1, 0), 3, 1), ((0, 0), 0, -1), ((2, 5), 1, 1)];
+        let b = batch(&u, 0, 10);
+        // (0,0)@0 cancels; (1,0)@3 sums to 2; (2,5)@1 stays.
+        let got = read(&b);
+        assert_eq!(got.get(&((1, 0), 3)), Some(&2));
+        assert_eq!(got.get(&((0, 0), 0)), None);
+        assert_eq!(got.get(&((2, 5), 1)), Some(&1));
+    }
+
+    #[test]
+    fn builder_builds_corgi_batch() {
+        let rows: Vec<((DValue, DValue), u64, i64)> = vec![
+            ((DValue::Int(1), DValue::Int(10)), 0, 1),
+            ((DValue::Int(1), DValue::Int(10)), 0, 1), // dup -> consolidates to diff 2
+            ((DValue::Int(2), DValue::Int(20)), 0, 1),
+        ];
+        let desc = Description::new(Antichain::from_elem(0u64), Antichain::from_elem(1u64), Antichain::from_elem(0u64));
+        let mut b = CorgiBatchBuilder::<u64, i64>::with_capacity(0, 0, 3);
+        b.push(&mut rows.clone());
+        let batch = b.done(desc);
+        assert_eq!(batch.len(), 2, "consolidated to 2 distinct (key,val)");
+        let ks = batch.keys.clone().into_u64("k");
+        let vs = batch.vals.clone().into_u64("v");
+        // locate (1,10) and check its diff is 2
+        let idx = (0..batch.len()).find(|&i| ks[i] == 1 && vs[i] == 10).expect("(1,10) present");
+        assert_eq!(batch.diffs[idx], 2);
+    }
+
+    #[test]
+    fn merger_trait_drives() {
+        // Drive the Batch::Merger (fuel loop, as the spine does) and confirm == reference.
+        let u1 = vec![((0, 0), 0, 1), ((1, 0), 2, 1), ((1, 0), 5, 1)];
+        let u2 = vec![((1, 0), 2, 1), ((2, 3), 0, 1), ((0, 0), 0, -1)];
+        let f = 3u64;
+        let b1 = batch(&u1, 0, 10);
+        let b2 = batch(&u2, 0, 10);
+        let mut m = CorgiMerger::new(&b1, &b2, Antichain::from_elem(f).borrow());
+        loop {
+            let mut fuel = 1isize;
+            m.work(&b1, &b2, &mut fuel);
+            if fuel > 0 {
+                break;
+            }
+        }
+        let out = m.done();
+        assert_eq!(read(&out), reference(&u1, &u2, f));
+    }
+
+    #[test]
+    fn merge_matches_reference() {
+        let mut seed = 0x1234_5678_9abc_def1u64;
+        for _ in 0..300 {
+            let gen = |seed: &mut u64| -> Vec<((u64, u64), u64, i64)> {
+                let n = (xorshift(seed) % 30) as usize + 1;
+                (0..n)
+                    .map(|_| {
+                        let k = xorshift(seed) % 6;
+                        let v = xorshift(seed) % 4;
+                        let t = xorshift(seed) % 8;
+                        let d = if xorshift(seed) % 4 == 0 { -1 } else { 1 };
+                        ((k, v), t, d)
+                    })
+                    .collect()
+            };
+            let u1 = gen(&mut seed);
+            let u2 = gen(&mut seed);
+            let f = xorshift(&mut seed) % 8;
+
+            let b1 = batch(&u1, 0, 10);
+            let b2 = batch(&u2, 0, 10);
+            let merged = merge(&b1, &b2, Antichain::from_elem(f).borrow());
+
+            assert_eq!(read(&merged), reference(&u1, &u2, f), "f={f}\n u1={u1:?}\n u2={u2:?}");
+        }
+    }
+}
diff --git a/interactive/src/corgi_backend.rs b/interactive/src/corgi_backend.rs
new file mode 100644
index 000000000..5458c34e0
--- /dev/null
+++ b/interactive/src/corgi_backend.rs
@@ -0,0 +1,149 @@
+//! Phase 2 — the corgi-native container: corgi columns for the (key,val) payload, plain Rust
+//! Vecs for time/diff (corgi never touches the lattice). This is what flows on dataflow edges in
+//! the corgi backend; operators transform block→block via `eval_graph` with NO per-op transcode.
+//! Conversion to/from DDIR rows happens only at I/O boundaries (`from_updates`/`into_updates`).
+//!
+//! Minimal trait surface for a pipelined (single-worker) dataflow: `Accountable + Default + Clone`
+//! (= `timely::Container`). `Negate`/`Enter`/`Leave`/`ResultsIn` (iterative scopes) come with M3.
+
+use timely::Accountable;
+use timely::progress::{PathSummary, Timestamp};
+
+use differential_dataflow::collection::containers::{Enter, Leave, Negate, ResultsIn};
+use differential_dataflow::difference::Abelian;
+
+use crate::corgi_logic::{infer_shape_cols, transcode, untranscode};
+use crate::ir::Value as DValue;
+
+type Row = DValue;
+
+/// A batch of `(key, val, time, diff)` updates: payload columnar (corgi), time/diff native Rust.
+pub struct CorgiContainer<T, R> {
+    /// Key column (corgi columnar `Value`).
+    pub keys: corgi::Value,
+    /// Val column (corgi columnar `Value`).
+    pub vals: corgi::Value,
+    /// Per-update times (corgi never reads these; the Rust side keeps the lattice algebra).
+    pub times: Vec<T>,
+    /// Per-update diffs.
+    pub diffs: Vec<R>,
+}
+
+impl<T, R> Default for CorgiContainer<T, R> {
+    fn default() -> Self {
+        // Empty sentinel columns (shape-agnostic length-0 unit columns).
+        CorgiContainer { keys: corgi::Value::Unit(0), vals: corgi::Value::Unit(0), times: Vec::new(), diffs: Vec::new() }
+    }
+}
+
+impl<T: Clone, R: Clone> Clone for CorgiContainer<T, R> {
+    fn clone(&self) -> Self {
+        // corgi `Value` clone is an Arc bump on the leaf buffers — columns are shared, not copied.
+        CorgiContainer { keys: self.keys.clone(), vals: self.vals.clone(), times: self.times.clone(), diffs: self.diffs.clone() }
+    }
+}
+
+impl<T: 'static, R: 'static> Accountable for CorgiContainer<T, R> {
+    #[inline]
+    fn record_count(&self) -> i64 {
+        self.times.len() as i64
+    }
+}
+
+/// Draining a `CorgiContainer` yields its DDIR row updates (untranscode) — lets the standard
+/// `ContainerChunker<Vec<((key,val),T,R)>>` chunk a corgi-container stream into row chains for the
+/// reused `MergeBatcher`, which the `CorgiBatchBuilder` then transcodes back to corgi columns at
+/// arrangement build (the one ingest-boundary round-trip; reduce/join read corgi columns).
+impl<T: Clone + 'static, R: Clone + 'static> timely::container::DrainContainer for CorgiContainer<T, R> {
+    type Item<'a> = ((Row, Row), T, R) where Self: 'a;
+    type DrainIter<'a> = std::vec::IntoIter<((Row, Row), T, R)> where Self: 'a;
+    fn drain(&mut self) -> Self::DrainIter<'_> {
+        std::mem::take(self).into_updates().into_iter()
+    }
+}
+
+impl<T: Clone + 'static, R: Clone + 'static> CorgiContainer<T, R> {
+    /// Build a container from DDIR row updates — the **ingest boundary** transcode (once per batch).
+    /// Shapes are inferred by scanning the whole column ([`infer_shape_cols`]) — required so a
+    /// `Variant` column discovers all its arms (a single sample shows only one tag).
+    pub fn from_updates(updates: Vec<((Row, Row), T, R)>) -> Self {
+        if updates.is_empty() {
+            return Self::default();
+        }
+        let keys_rows: Vec<DValue> = updates.iter().map(|u| u.0 .0.clone()).collect();
+        let vals_rows: Vec<DValue> = updates.iter().map(|u| u.0 .1.clone()).collect();
+        let kshape = infer_shape_cols(&keys_rows);
+        let vshape = infer_shape_cols(&vals_rows);
+        let times = updates.iter().map(|u| u.1.clone()).collect();
+        let diffs = updates.iter().map(|u| u.2.clone()).collect();
+        CorgiContainer { keys: transcode(&keys_rows, &kshape), vals: transcode(&vals_rows, &vshape), times, diffs }
+    }
+
+    /// Read the container back to DDIR row updates — the **egress boundary** transcode (once).
+    /// corgi `Value` is self-describing, so shapes come from `shape_of_value`.
+    pub fn into_updates(self) -> Vec<((Row, Row), T, R)> {
+        if self.times.is_empty() {
+            return Vec::new();
+        }
+        let kshape = corgi::shape_of_value(&self.keys);
+        let vshape = corgi::shape_of_value(&self.vals);
+        let keys_rows = untranscode(self.keys, &kshape);
+        let vals_rows = untranscode(self.vals, &vshape);
+        keys_rows
+            .into_iter()
+            .zip(vals_rows)
+            .zip(self.times)
+            .zip(self.diffs)
+            .map(|(((k, v), t), d)| ((k, v), t, d))
+            .collect()
+    }
+}
+
+// --- Container traits required by the `Backend` bound + iterative scopes ---
+// time/diff live in Rust, so these are plain Rust passes; the corgi key/val columns only move
+// (`gather`) when `ResultsIn` drops rows. `Enter`/`Leave` are identity for DDIR's same-Time dynamic
+// timestamp model (region entry doesn't change the time type; `leave_dynamic` pops the coord).
+
+impl<T: Timestamp, R: Abelian + 'static> Negate for CorgiContainer<T, R> {
+    fn negate(mut self) -> Self {
+        for d in self.diffs.iter_mut() {
+            d.negate();
+        }
+        self
+    }
+}
+
+impl<T: Timestamp, R: 'static> Enter<T, T> for CorgiContainer<T, R> {
+    type InnerContainer = Self;
+    fn enter(self) -> Self {
+        self
+    }
+}
+
+impl<T: Timestamp, R: 'static> Leave<T, T> for CorgiContainer<T, R> {
+    type OuterContainer = Self;
+    fn leave(self) -> Self {
+        self
+    }
+}
+
+impl<T: Timestamp, R: Clone + 'static> ResultsIn<T::Summary> for CorgiContainer<T, R> {
+    fn results_in(self, step: &T::Summary) -> Self {
+        let n = self.times.len();
+        let mut keep = Vec::with_capacity(n);
+        let mut new_times = Vec::with_capacity(n);
+        for (i, t) in self.times.iter().enumerate() {
+            if let Some(nt) = step.results_in(t) {
+                keep.push(i);
+                new_times.push(nt);
+            }
+        }
+        if keep.len() == n {
+            return CorgiContainer { keys: self.keys, vals: self.vals, times: new_times, diffs: self.diffs };
+        }
+        let keys = corgi::arrange::gather(&self.keys, &keep);
+        let vals = corgi::arrange::gather(&self.vals, &keep);
+        let diffs = keep.iter().map(|&i| self.diffs[i].clone()).collect();
+        CorgiContainer { keys, vals, times: new_times, diffs }
+    }
+}
diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
new file mode 100644
index 000000000..d84cef7a7
--- /dev/null
+++ b/interactive/src/corgi_chunk.rs
@@ -0,0 +1,654 @@
+//! `CorgiChunk`: a [`Chunk`](differential_dataflow::trace::chunk::Chunk) whose key/val payload is a
+//! pair of corgi columns (time/diff stay Rust `Vec`s). It is a **`Chunk` but NOT `NavigableChunk`**:
+//! it exposes no `Ord` key, no cursor, no sorted-trie layout — the merge/advance/settle transducers
+//! drive everything through corgi's own structural order (`compare_at`) and gather primitives
+//! (`gather`, `gather_lanes`). Consumption is the tactics' job (they read the columns in bulk), which
+//! is exactly why cursor-less `Chunk` suffices here.
+//!
+//! This is a faithful port of the reference [`VecChunk`](differential_dataflow::trace::chunk::vec):
+//! same resumable merge→advance→settle pipeline and grade-at-yield invariant, with the flat
+//! `Rc<Vec<row>>` swapped for corgi columns. Adopting the `Chunk` framework gives us the fueled,
+//! graded `ChunkBatchMerger` for free — replacing the eager whole-trace `CorgiMerger`.
+//!
+//! Order: `(key, val)` by corgi structural order (`compare_at` over `Prod([keys, vals])`), then `time`
+//! by `Ord`. Any consistent total order is fine — correctness compares multisets, not DDIR's `Ord`.
+//!
+//! Simplification vs `VecChunk`: `merge` processes only the two front chunks per call (no mid-merge
+//! refill), so `gather_lanes` source indices stay valid for the whole call. The `Chunk` contract
+//! permits this — "consume at least one input; the harness may re-invoke."
+
+use std::collections::{HashMap, VecDeque};
+use std::rc::Rc;
+
+use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
+
+use differential_dataflow::difference::Semigroup;
+use differential_dataflow::lattice::Lattice;
+use differential_dataflow::trace::chunk::{merge_chains, pack, Chunk, ChunkBatch};
+use differential_dataflow::trace::{Builder as DdBuilder, Description};
+
+use corgi::arrange::{compare_at, compare_idx, find_ranges, gather, gather_lanes, sort_perm};
+use corgi::Value as CValue;
+
+use crate::corgi_logic::{infer_shape_cols, transcode, untranscode};
+use crate::ir::Value as DValue;
+
+use std::cmp::Ordering;
+
+/// A DDIR row update: `((key, val), time, diff)`.
+pub type Upd<T, R> = ((DValue, DValue), T, R);
+
+/// The grading target (also the merge/advance emit-chunk size). Larger than `VecChunk`'s 8192 to
+/// amortize corgi's per-chunk columnar set-up (each chunk boundary costs a `gather` materialization);
+/// bigger chunks mean fewer boundaries. Bounded so the fueled merger still yields.
+const TARGET: usize = 1 << 18;
+
+/// Shared, immutable chunk contents. `Clone` of a `CorgiChunk` is an `Rc` bump.
+struct Inner<T, R> {
+    /// Key column (corgi), aligned with `vals`/`times`/`diffs`, sorted by `(key, val, time)`.
+    keys: CValue,
+    /// Val column (corgi).
+    vals: CValue,
+    /// Per-update times (the lattice algebra lives here; corgi never sees time).
+    times: Vec<T>,
+    /// Per-update diffs.
+    diffs: Vec<R>,
+}
+
+/// A sorted, consolidated run of `((key, val), time, diff)` with corgi-columnar key/val, shared via `Rc`.
+pub struct CorgiChunk<T, R>(Rc<Inner<T, R>>);
+
+impl<T, R> Clone for CorgiChunk<T, R> {
+    fn clone(&self) -> Self { CorgiChunk(Rc::clone(&self.0)) }
+}
+
+impl<T, R> Default for CorgiChunk<T, R> {
+    fn default() -> Self {
+        CorgiChunk(Rc::new(Inner { keys: CValue::Unit(0), vals: CValue::Unit(0), times: Vec::new(), diffs: Vec::new() }))
+    }
+}
+
+/// Split a `Prod([keys, vals])` corgi value into its two columns.
+fn split_kv(kv: CValue) -> (CValue, CValue) {
+    let mut cols = kv.into_prod("corgi chunk kv");
+    let vals = cols.pop().unwrap();
+    let keys = cols.pop().unwrap();
+    (keys, vals)
+}
+
+impl<T: Clone, R: Clone> CorgiChunk<T, R> {
+    fn from_parts(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
+        CorgiChunk(Rc::new(Inner { keys, vals, times, diffs }))
+    }
+    /// The `(key, val)` sort payload as one corgi `Prod` column (cheap `Arc` bumps).
+    fn kv(&self) -> CValue { CValue::Prod(vec![self.0.keys.clone(), self.0.vals.clone()]) }
+    fn from_kv(kv: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
+        let (keys, vals) = split_kv(kv);
+        Self::from_parts(keys, vals, times, diffs)
+    }
+    pub fn keys(&self) -> &CValue { &self.0.keys }
+    pub fn vals(&self) -> &CValue { &self.0.vals }
+    pub fn times(&self) -> &[T] { &self.0.times }
+    pub fn diffs(&self) -> &[R] { &self.0.diffs }
+}
+
+/// Total order used throughout: `(key, val)` structurally, then `time`.
+#[inline]
+fn cmp_at<T: Ord>(a_kv: &CValue, ai: usize, at: &T, b_kv: &CValue, bi: usize, bt: &T) -> Ordering {
+    compare_at(a_kv, ai, b_kv, bi).then_with(|| at.cmp(bt))
+}
+
+impl<T, R> CorgiChunk<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    /// Materialize `[start, end)` of accumulated `(tag → src, off, time, diff)` into `TARGET`-sized
+    /// output chunks. `srcs` are the (stable) source kv columns the tags/offs index into.
+    fn emit(
+        srcs: &[Option<&CValue>],
+        tags: &[usize],
+        offs: &[usize],
+        times: &[T],
+        diffs: &[R],
+        out: &mut VecDeque<Self>,
+    ) {
+        let n = times.len();
+        let mut s = 0;
+        while s < n {
+            let e = (s + TARGET).min(n);
+            let kv = gather_lanes(srcs, &tags[s..e], &offs[s..e]);
+            out.push_back(Self::from_kv(kv, times[s..e].to_vec(), diffs[s..e].to_vec()));
+            s = e;
+        }
+    }
+
+    /// Concatenate a run of (globally-sorted) chunks into one combined `(kv, times, diffs)`.
+    fn concat(chunks: &[Self]) -> (CValue, Vec<T>, Vec<R>) {
+        let kvs: Vec<CValue> = chunks.iter().map(Self::kv).collect();
+        let srcs: Vec<Option<&CValue>> = kvs.iter().map(Some).collect();
+        let total: usize = chunks.iter().map(Self::len_).sum();
+        let (mut tags, mut offs) = (Vec::with_capacity(total), Vec::with_capacity(total));
+        let (mut times, mut diffs) = (Vec::with_capacity(total), Vec::with_capacity(total));
+        for (ti, ch) in chunks.iter().enumerate() {
+            for o in 0..ch.len_() { tags.push(ti); offs.push(o); }
+            times.extend_from_slice(ch.times());
+            diffs.extend_from_slice(ch.diffs());
+        }
+        let kv = if total == 0 { CValue::Unit(0) } else { gather_lanes(&srcs, &tags, &offs) };
+        (kv, times, diffs)
+    }
+
+    fn len_(&self) -> usize { self.0.times.len() }
+}
+
+impl<T, R> Chunk for CorgiChunk<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    type Time = T;
+    const TARGET: usize = TARGET;
+
+    fn len(&self) -> usize { self.0.times.len() }
+
+    /// Two-pointer merge of the two front chunks through their shared horizon, consolidating equal
+    /// `(key, val, time)` triples. Accumulates `(tag, off)` against the two stable source kv columns
+    /// and materializes output via `gather_lanes`; the survivor's suffix is pushed back once.
+    fn merge(in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>) {
+        let c1 = in1.pop_front().unwrap();
+        let c2 = in2.pop_front().unwrap();
+        let (kv1, kv2) = (c1.kv(), c2.kv());
+        let (n1, n2) = (c1.len_(), c2.len_());
+        let (t1, d1) = (c1.times(), c1.diffs());
+        let (t2, d2) = (c2.times(), c2.diffs());
+
+        let (mut tags, mut offs) = (Vec::new(), Vec::new());
+        let (mut times, mut diffs) = (Vec::new(), Vec::new());
+        let (mut p1, mut p2) = (0usize, 0usize);
+        while p1 < n1 && p2 < n2 {
+            match cmp_at(&kv1, p1, &t1[p1], &kv2, p2, &t2[p2]) {
+                Ordering::Less => { tags.push(0); offs.push(p1); times.push(t1[p1].clone()); diffs.push(d1[p1].clone()); p1 += 1; }
+                Ordering::Greater => { tags.push(1); offs.push(p2); times.push(t2[p2].clone()); diffs.push(d2[p2].clone()); p2 += 1; }
+                Ordering::Equal => {
+                    let mut d = d1[p1].clone();
+                    d.plus_equals(&d2[p2]);
+                    if !d.is_zero() { tags.push(0); offs.push(p1); times.push(t1[p1].clone()); diffs.push(d); }
+                    p1 += 1; p2 += 1;
+                }
+            }
+        }
+
+        let srcs = [Some(&kv1), Some(&kv2)];
+        Self::emit(&srcs, &tags, &offs, &times, &diffs, out);
+
+        // Push back the survivor's unconsumed suffix (all `>` the horizon), ahead of its deque.
+        if p1 < n1 {
+            let idx: Vec<usize> = (p1..n1).collect();
+            in1.push_front(Self::from_kv(gather(&kv1, &idx), t1[p1..].to_vec(), d1[p1..].to_vec()));
+        }
+        if p2 < n2 {
+            let idx: Vec<usize> = (p2..n2).collect();
+            in2.push_front(Self::from_kv(gather(&kv2, &idx), t2[p2..].to_vec(), d2[p2..].to_vec()));
+        }
+    }
+
+    fn extract(
+        input: &mut VecDeque<Self>,
+        frontier: AntichainRef<T>,
+        residual: &mut Antichain<T>,
+        keep: &mut VecDeque<Self>,
+        ship: &mut VecDeque<Self>,
+    ) {
+        // One input chunk per call: partition into keep (`>= frontier`) and ship pieces via `gather`.
+        let Some(chunk) = input.pop_front() else { return };
+        let kv = chunk.kv();
+        let (times, diffs) = (chunk.times(), chunk.diffs());
+        let (mut ki, mut si) = (Vec::new(), Vec::new());
+        for i in 0..chunk.len_() {
+            if frontier.less_equal(&times[i]) { residual.insert_ref(&times[i]); ki.push(i); } else { si.push(i); }
+        }
+        if !ki.is_empty() {
+            let t: Vec<T> = ki.iter().map(|&i| times[i].clone()).collect();
+            let d: Vec<R> = ki.iter().map(|&i| diffs[i].clone()).collect();
+            keep.push_back(Self::from_kv(gather(&kv, &ki), t, d));
+        }
+        if !si.is_empty() {
+            let t: Vec<T> = si.iter().map(|&i| times[i].clone()).collect();
+            let d: Vec<R> = si.iter().map(|&i| diffs[i].clone()).collect();
+            ship.push_back(Self::from_kv(gather(&kv, &si), t, d));
+        }
+    }
+
+    fn advance(
+        input: &mut VecDeque<Self>,
+        frontier: AntichainRef<T>,
+        done: bool,
+        out: &mut VecDeque<Self>,
+    ) {
+        // Concatenate the pushed-back carry with the newly-arrived chunks, then advance/consolidate
+        // each *complete* `(key, val)` group; withhold the last group as the carry unless `done`.
+        if input.is_empty() { return; }
+        let chunks: Vec<Self> = input.drain(..).collect();
+        let (ckv, ctimes, cdiffs) = Self::concat(&chunks);
+        let n = ctimes.len();
+        if n == 0 { return; }
+
+        // Giant-key case: whole buffer is one `(key, val)` → no group provably complete.
+        if !done && compare_at(&ckv, 0, &ckv, n - 1) == Ordering::Equal {
+            input.push_front(Self::from_kv(ckv, ctimes, cdiffs));
+            return;
+        }
+
+        // Withhold the trailing group as the carry unless `done`.
+        let end = if done {
+            n
+        } else {
+            let mut start = n;
+            while start > 0 && compare_at(&ckv, start - 1, &ckv, n - 1) == Ordering::Equal { start -= 1; }
+            start
+        };
+        if end < n {
+            let idx: Vec<usize> = (end..n).collect();
+            input.push_front(Self::from_kv(gather(&ckv, &idx), ctimes[end..].to_vec(), cdiffs[end..].to_vec()));
+        }
+
+        // Advance + consolidate each complete group; emit `TARGET`-sized chunks. All rows of a group
+        // share `(key, val)`, so one representative offset materializes each output row's kv.
+        let srcs = [Some(&ckv)];
+        let (mut tags, mut offs) = (Vec::new(), Vec::new());
+        let (mut otimes, mut odiffs) = (Vec::new(), Vec::new());
+        let mut i = 0;
+        while i < end {
+            let mut j = i;
+            while j < end && compare_at(&ckv, i, &ckv, j) == Ordering::Equal { j += 1; }
+            let mut pairs: Vec<(T, R)> = (i..j)
+                .map(|k| { let mut t = ctimes[k].clone(); t.advance_by(frontier); (t, cdiffs[k].clone()) })
+                .collect();
+            pairs.sort_by(|a, b| a.0.cmp(&b.0));
+            let mut k = 0;
+            while k < pairs.len() {
+                let t = pairs[k].0.clone();
+                let mut d = pairs[k].1.clone();
+                k += 1;
+                while k < pairs.len() && pairs[k].0 == t { d.plus_equals(&pairs[k].1); k += 1; }
+                if !d.is_zero() {
+                    tags.push(0); offs.push(i); otimes.push(t); odiffs.push(d);
+                    if otimes.len() >= TARGET {
+                        Self::emit(&srcs, &tags, &offs, &otimes, &odiffs, out);
+                        tags.clear(); offs.clear(); otimes.clear(); odiffs.clear();
+                    }
+                }
+            }
+            i = j;
+        }
+        if !otimes.is_empty() { Self::emit(&srcs, &tags, &offs, &otimes, &odiffs, out); }
+    }
+
+    /// Maximal packing via the harness [`pack`]: coalesce by concatenating columns (`gather_lanes`),
+    /// split with `gather`, seal as a no-op (corgi chunks are never paged here).
+    fn settle(input: &mut VecDeque<Self>, done: bool, out: &mut VecDeque<Self>) {
+        pack(
+            input,
+            done,
+            out,
+            |acc, next| {
+                let (na, nb) = (acc.len_(), next.len_());
+                let kvs = [acc.kv(), next.kv()];
+                let srcs = [Some(&kvs[0]), Some(&kvs[1])];
+                let mut tags = Vec::with_capacity(na + nb);
+                let mut offs = Vec::with_capacity(na + nb);
+                for o in 0..na { tags.push(0); offs.push(o); }
+                for o in 0..nb { tags.push(1); offs.push(o); }
+                let kv = gather_lanes(&srcs, &tags, &offs);
+                let mut times = acc.times().to_vec();
+                times.extend_from_slice(next.times());
+                let mut diffs = acc.diffs().to_vec();
+                diffs.extend_from_slice(next.diffs());
+                *acc = Self::from_kv(kv, times, diffs);
+            },
+            |chunk, m| {
+                let kv = chunk.kv();
+                let left: Vec<usize> = (0..m).collect();
+                let right: Vec<usize> = (m..chunk.len_()).collect();
+                let l = Self::from_kv(gather(&kv, &left), chunk.times()[..m].to_vec(), chunk.diffs()[..m].to_vec());
+                let r = Self::from_kv(gather(&kv, &right), chunk.times()[m..].to_vec(), chunk.diffs()[m..].to_vec());
+                (l, r)
+            },
+            |chunk| chunk,
+        );
+    }
+}
+
+/// Sort parallel columns by `(key, val, time)` and consolidate exact `(key, val, time)` triples
+/// (summing diffs, dropping zeros). Returns a sorted+consolidated `(keys, vals, times, diffs)`.
+///
+/// Multi-record: one columnar `sort_perm` (discrimination sort) orders by `(key, val)`, one batched
+/// `compare_idx` flags adjacent-equal runs; only the small per-run *time* tiebreak is a Rust sort
+/// (time is not a corgi type). No per-pair `compare_at`.
+fn sort_consolidate<T, R>(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> (CValue, CValue, Vec<T>, Vec<R>)
+where
+    T: Ord + Clone,
+    R: Semigroup + Clone,
+{
+    let n = times.len();
+    if n == 0 {
+        return (keys, vals, times, diffs);
+    }
+    let kv = CValue::Prod(vec![keys, vals]);
+    // Batched argsort by (key, val); reorder the parallel Rust columns by the same permutation.
+    let perm = sort_perm(&kv);
+    let kv_s = gather(&kv, &perm);
+    let times_s: Vec<T> = perm.iter().map(|&i| times[i].clone()).collect();
+    let diffs_s: Vec<R> = perm.iter().map(|&i| diffs[i].clone()).collect();
+    // Batched adjacent-equality over the kv-sorted column: `adj[m] == 0` iff `kv_s[m] == kv_s[m+1]`.
+    let adj: Vec<i8> = if n > 1 {
+        let left: Vec<usize> = (0..n - 1).collect();
+        let right: Vec<usize> = (1..n).collect();
+        compare_idx(&kv_s, &kv_s, &left, &right)
+    } else {
+        Vec::new()
+    };
+
+    // Walk maximal equal-`(key,val)` runs; within each, order by time and consolidate equal times.
+    let (mut keep, mut ot, mut od) = (Vec::new(), Vec::new(), Vec::new());
+    let mut i = 0;
+    while i < n {
+        let mut j = i + 1;
+        while j < n && adj[j - 1] == 0 {
+            j += 1;
+        }
+        let mut run: Vec<usize> = (i..j).collect();
+        run.sort_by(|&a, &b| times_s[a].cmp(&times_s[b]));
+        let mut k = 0;
+        while k < run.len() {
+            let rep = run[k];
+            let t = times_s[rep].clone();
+            let mut d = diffs_s[rep].clone();
+            k += 1;
+            while k < run.len() && times_s[run[k]] == t {
+                d.plus_equals(&diffs_s[run[k]]);
+                k += 1;
+            }
+            if !d.is_zero() {
+                keep.push(rep);
+                ot.push(t);
+                od.push(d);
+            }
+        }
+        i = j;
+    }
+    let (keys, vals) = split_kv(gather(&kv_s, &keep));
+    (keys, vals, ot, od)
+}
+
+impl<T, R> CorgiChunk<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    /// One sorted+consolidated chunk from DDIR rows (the arrange-ingest transcode boundary). Shapes
+    /// are inferred by whole-column scan ([`infer_shape_cols`]) so variant arms resolve correctly.
+    pub fn from_rows(rows: &[Upd<T, R>]) -> Self {
+        if rows.is_empty() { return Self::default(); }
+        let keys_rows: Vec<DValue> = rows.iter().map(|u| u.0 .0.clone()).collect();
+        let vals_rows: Vec<DValue> = rows.iter().map(|u| u.0 .1.clone()).collect();
+        let keys = transcode(&keys_rows, &infer_shape_cols(&keys_rows));
+        let vals = transcode(&vals_rows, &infer_shape_cols(&vals_rows));
+        let times = rows.iter().map(|u| u.1.clone()).collect();
+        let diffs = rows.iter().map(|u| u.2.clone()).collect();
+        let (keys, vals, times, diffs) = sort_consolidate(keys, vals, times, diffs);
+        Self::from_parts(keys, vals, times, diffs)
+    }
+
+    /// Untranscode this chunk back to DDIR rows (egress / history read).
+    pub fn to_rows(&self) -> Vec<Upd<T, R>> {
+        if self.len_() == 0 { return Vec::new(); }
+        let keys = untranscode(self.0.keys.clone(), &corgi::shape_of_value(&self.0.keys));
+        let vals = untranscode(self.0.vals.clone(), &corgi::shape_of_value(&self.0.vals));
+        keys.into_iter()
+            .zip(vals)
+            .zip(&self.0.times)
+            .zip(&self.0.diffs)
+            .map(|(((k, v), t), d)| ((k, v), t.clone(), d.clone()))
+            .collect()
+    }
+}
+
+/// Read a whole `ChunkBatch<CorgiChunk>` back to DDIR rows (across all chunks) — the cursor-less
+/// history read used by `as_collection` and the reduce tactic.
+pub fn batch_to_rows<T, R>(b: &ChunkBatch<CorgiChunk<T, R>>) -> Vec<Upd<T, R>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let mut out = Vec::new();
+    for ch in &b.chunks { out.extend(ch.to_rows()); }
+    out
+}
+
+/// Build a `ChunkBatch<CorgiChunk>` from DDIR rows: transcode+sort+consolidate into one chunk, then
+/// `settle` it into a graded chunk sequence.
+fn rows_to_batch<T, R>(rows: Vec<Upd<T, R>>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let chunk = CorgiChunk::from_rows(&rows);
+    let mut input = VecDeque::new();
+    if chunk.len_() > 0 { input.push_back(chunk); }
+    let mut output = VecDeque::new();
+    CorgiChunk::settle(&mut input, true, &mut output);
+    ChunkBatch::new(output.into(), description)
+}
+
+/// DD [`Builder`](DdBuilder) that consumes sorted/consolidated row chains (the vec batcher's `Output`)
+/// and builds a `ChunkBatch<CorgiChunk>`. `Input = Vec<Upd>` so the existing `MergeBatcher` over vec
+/// rows can stay the arrange batcher; only the builder + trace become chunk-native. `RcBuilder` wraps
+/// it → `Rc<ChunkBatch<CorgiChunk>>`.
+pub struct CorgiChunkBuilder<T, R> {
+    rows: Vec<Upd<T, R>>,
+}
+
+impl<T, R> DdBuilder for CorgiChunkBuilder<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    type Input = Vec<Upd<T, R>>;
+    type Time = T;
+    type Output = ChunkBatch<CorgiChunk<T, R>>;
+
+    fn with_capacity(_keys: usize, _vals: usize, upds: usize) -> Self {
+        CorgiChunkBuilder { rows: Vec::with_capacity(upds) }
+    }
+    fn push(&mut self, chunk: &mut Self::Input) { self.rows.append(chunk); }
+    fn done(self, description: Description<T>) -> Self::Output { rows_to_batch(self.rows, description) }
+    fn seal(chain: &mut Vec<Self::Input>, description: Description<T>) -> Self::Output {
+        let mut all = Vec::new();
+        for c in chain.iter_mut() { all.append(c); }
+        rows_to_batch(all, description)
+    }
+}
+
+/// A single sorted+consolidated run over corgi columns — the join tactic's per-side input, produced
+/// by merging a batch list [`flatten_batches`]. Separate `keys`/`vals` columns so the merge-join can
+/// compare by key (`compare_at`) and `gather` matched runs.
+pub struct SortedRun<T, R> {
+    pub keys: CValue,
+    pub vals: CValue,
+    pub times: Vec<T>,
+    pub diffs: Vec<R>,
+}
+
+/// Flatten a list of batches into one sorted+consolidated run over columns (no row round-trip, no
+/// re-sort). Each batch's `.chunks` is already a sorted, consolidated chain; we **merge** those chains
+/// (reusing their order via `merge_chains` → `CorgiChunk::merge`) into one, then concatenate. `None`
+/// if empty. This replaces an earlier concat+full-sort that dominated recursive (reach) cost.
+pub fn flatten_batches<T, R>(batches: &[Rc<ChunkBatch<CorgiChunk<T, R>>>]) -> Option<SortedRun<T, R>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let mut merged: VecDeque<CorgiChunk<T, R>> = VecDeque::new();
+    for b in batches {
+        if b.chunks.is_empty() { continue; }
+        if merged.is_empty() {
+            merged.extend(b.chunks.iter().cloned());
+        } else {
+            let chain: Vec<CorgiChunk<T, R>> = merged.drain(..).collect();
+            merge_chains(chain, b.chunks.clone(), &mut merged);
+        }
+    }
+    if merged.is_empty() { return None; }
+    // The merged chain is globally sorted+consolidated: concatenate (no sort) into one flat run.
+    let chunks: Vec<CorgiChunk<T, R>> = merged.into();
+    let (kv, times, diffs) = CorgiChunk::concat(&chunks);
+    let (keys, vals) = split_kv(kv);
+    Some(SortedRun { keys, vals, times, diffs })
+}
+
+/// Semijoin: for each key in `needle_keys` (a set of DDIR keys), gather its `(val, time, diff)`
+/// history from `batches` via a batched `find` probe over the flattened, sorted source — untranscoding
+/// only the matched rows, never the whole trace. Returns a `key -> history` map (only matched keys
+/// present), the drop-in replacement for grouping untranscode-all rows by key. `O(|needle|·log|source|)`
+/// probe + `O(matched)` untranscode, vs the old `O(|source|)` untranscode + hash-group.
+pub fn semijoin_history<T, R>(
+    batches: &[Rc<ChunkBatch<CorgiChunk<T, R>>>],
+    needle_keys: &[DValue],
+) -> HashMap<DValue, Vec<(DValue, T, R)>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let mut out: HashMap<DValue, Vec<(DValue, T, R)>> = HashMap::new();
+    if needle_keys.is_empty() {
+        return out;
+    }
+    // Each chunk already holds a sorted key column, so probe each in place — NO flatten/merge (which
+    // would re-materialize the whole accumulated trace every round). Transcode the needle once with
+    // the arrangement's key shape (taken from the first non-empty chunk; the schema is uniform).
+    let shape = batches
+        .iter()
+        .flat_map(|b| b.chunks.iter())
+        .find(|c| c.len_() > 0)
+        .map(|c| corgi::shape_of_value(c.keys()));
+    let Some(shape) = shape else { return out };
+    let needle_col = transcode(needle_keys, &shape);
+
+    for b in batches {
+        for chunk in &b.chunks {
+            if chunk.len_() == 0 {
+                continue;
+            }
+            let (lo, hi) = find_ranges(&needle_col, chunk.keys());
+            let mut matched: Vec<usize> = Vec::new();
+            for i in 0..needle_keys.len() {
+                matched.extend(lo[i]..hi[i]);
+            }
+            if matched.is_empty() {
+                continue;
+            }
+            let vcol = gather(chunk.vals(), &matched);
+            let vals = untranscode(vcol.clone(), &corgi::shape_of_value(&vcol));
+            let mut c = 0;
+            for i in 0..needle_keys.len() {
+                let len = hi[i] - lo[i];
+                if len == 0 {
+                    continue;
+                }
+                let entry = out.entry(needle_keys[i].clone()).or_default();
+                for k in 0..len {
+                    let r = matched[c + k];
+                    entry.push((vals[c + k].clone(), chunk.times()[r].clone(), chunk.diffs()[r].clone()));
+                }
+                c += len;
+            }
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use differential_dataflow::trace::chunk::{ChunkBatchMerger, is_graded};
+    use differential_dataflow::trace::{Description, Merger};
+    use std::collections::BTreeMap;
+
+    fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+    /// Build a single sorted+consolidated CorgiChunk from u64 (key,val,time,diff) rows.
+    fn chunk(rows: &[((u64, u64), u64, i64)]) -> CorgiChunk<u64, i64> {
+        // Sort + consolidate by ((k,v),t) so a chunk is a legal sorted run.
+        let mut m: BTreeMap<((u64, u64), u64), i64> = BTreeMap::new();
+        for &(kv, t, d) in rows { *m.entry((kv, t)).or_insert(0) += d; }
+        m.retain(|_, d| *d != 0);
+        let keys = CValue::u64(m.keys().map(|((k, _), _)| *k).collect());
+        let vals = CValue::u64(m.keys().map(|((_, v), _)| *v).collect());
+        let times = m.keys().map(|(_, t)| *t).collect();
+        let diffs = m.values().copied().collect();
+        CorgiChunk::from_parts(keys, vals, times, diffs)
+    }
+
+    fn read_batch(b: &ChunkBatch<CorgiChunk<u64, i64>>) -> BTreeMap<((u64, u64), u64), i64> {
+        let mut m = BTreeMap::new();
+        for ch in &b.chunks {
+            let ks = ch.keys().clone().into_u64("k");
+            let vs = ch.vals().clone().into_u64("v");
+            for i in 0..ch.len_() { *m.entry(((ks[i], vs[i]), ch.times()[i])).or_insert(0) += ch.diffs()[i]; }
+        }
+        m.retain(|_, d| *d != 0);
+        m
+    }
+
+    fn reference(u1: &[((u64, u64), u64, i64)], u2: &[((u64, u64), u64, i64)], f: u64) -> BTreeMap<((u64, u64), u64), i64> {
+        let mut m = BTreeMap::new();
+        for u in u1.iter().chain(u2) { *m.entry((u.0, u.1.max(f))).or_insert(0) += u.2; } // advance_by on u64 = max
+        m.retain(|_, d| *d != 0);
+        m
+    }
+
+    /// Cut a consolidated set into a batch of small chunks (globally sorted; groups straddle).
+    fn batch(rows: &[((u64, u64), u64, i64)], sz: usize) -> ChunkBatch<CorgiChunk<u64, i64>> {
+        let mut m: BTreeMap<((u64, u64), u64), i64> = BTreeMap::new();
+        for &(kv, t, d) in rows { *m.entry((kv, t)).or_insert(0) += d; }
+        m.retain(|_, d| *d != 0);
+        let all: Vec<((u64, u64), u64, i64)> = m.into_iter().map(|((kv, t), d)| (kv, t, d)).collect();
+        let chunks: Vec<_> = all.chunks(sz.max(1)).map(chunk).collect();
+        let desc = Description::new(Antichain::from_elem(0u64), Antichain::from_elem(10u64), Antichain::from_elem(0u64));
+        ChunkBatch::new(chunks, desc)
+    }
+
+    #[test]
+    fn batch_merger_resumable_matches_reference() {
+        let mut seed = 0x9E3779B97F4A7C15u64;
+        for _ in 0..200 {
+            let gen = |seed: &mut u64| -> Vec<((u64, u64), u64, i64)> {
+                let n = (xorshift(seed) % 40) as usize + 1;
+                (0..n).map(|_| {
+                    let k = xorshift(seed) % 10; let v = xorshift(seed) % 3; let t = xorshift(seed) % 6;
+                    let d = if xorshift(seed) % 4 == 0 { -1 } else { 1 };
+                    ((k, v), t, d)
+                }).collect()
+            };
+            let u1 = gen(&mut seed);
+            let u2 = gen(&mut seed);
+            let sz = (xorshift(&mut seed) % 4) as usize + 1;
+            let f = xorshift(&mut seed) % 6;
+            let (s1, s2) = (batch(&u1, sz), batch(&u2, sz));
+            let frontier = Antichain::from_elem(f);
+
+            let mut merger = ChunkBatchMerger::new(&s1, &s2, frontier.borrow());
+            loop {
+                let mut fuel = 1isize; // tiny → many yields, each settling
+                merger.work(&s1, &s2, &mut fuel);
+                if fuel > 0 { break; }
+            }
+            let result = merger.done();
+            assert!(is_graded(&result.chunks), "ungraded: {:?}", result.chunks.iter().map(Chunk::len).collect::<Vec<_>>());
+            assert_eq!(read_batch(&result), reference(&u1, &u2, f), "u1={u1:?}\nu2={u2:?}\nf={f}");
+        }
+    }
+}
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi_join.rs
new file mode 100644
index 000000000..7a233810e
--- /dev/null
+++ b/interactive/src/corgi_join.rs
@@ -0,0 +1,134 @@
+//! Phase 2 / M2(b)-4 — the cursor-less corgi JOIN tactic (Route B; reduce `retire` is Frank's).
+//!
+//! `join_with_tactic` needs only `TraceReader` (not `Navigable`), so a cursor-less `CorgiBatch`
+//! arrangement drives a custom `JoinTactic`: `defer` queues bilinear units (fresh batch list ×
+//! accumulated other side, keyed by `Fresh`); `work` (NEXT ITERATION) merges each side's list to one
+//! run, merge-joins by key over corgi columns (`compare_at`), cross-products matched val runs with
+//! lattice time-join + diff-multiply, runs the projection corgi program, and emits via the session.
+//!
+//! THIS ITERATION: struct + `defer` + a stub `work`, compiling as a valid `JoinTactic` (validates the
+//! generic-bound wiring). The join COMPUTE is already validated in `examples/corgi_join_mechanism.rs`.
+
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+use timely::container::PushInto;
+use timely::ContainerBuilder;
+use timely::dataflow::operators::generic::OutputBuilderSession;
+use timely::dataflow::operators::Capability;
+use timely::progress::Timestamp;
+
+use differential_dataflow::lattice::Lattice;
+use differential_dataflow::operators::join::{EffortBuilder, Fresh, JoinTactic};
+
+use corgi::arrange::{find_ranges, gather};
+use corgi::Value as CValue;
+
+use differential_dataflow::trace::chunk::ChunkBatch;
+
+use crate::corgi_chunk::{flatten_batches, CorgiChunk};
+use crate::corgi_logic::{compile_join_projection, untranscode};
+use crate::ir::{Diff, Value as DValue};
+use crate::parse::Term;
+
+type Row = DValue;
+type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
+
+/// A deferred bilinear join unit: a fresh batch list joined against the accumulated other side.
+/// (The accumulated-side advance-by-meet — an output-neutral consolidation optimization — is deferred;
+/// `merge_one` consolidates each side without advancing, which is correct.)
+struct CorgiDeferred<T: Timestamp + Lattice> {
+    left: Vec<CBatch<T>>,
+    right: Vec<CBatch<T>>,
+    capability: Capability<T>,
+}
+
+/// Cursor-less corgi join tactic. Holds the projection `Term`s (`Var(0)=key`, `Var(1)=val0`,
+/// `Var(2)=val1`); compiled to a corgi graph per work-unit using the matched columns' shapes (so
+/// `Spread` resolves against the actual key/val arities).
+pub struct CorgiJoinTactic<T: Timestamp + Lattice> {
+    key: Term,
+    val: Term,
+    todo0: VecDeque<CorgiDeferred<T>>, // fresh on input0
+    todo1: VecDeque<CorgiDeferred<T>>, // fresh on input1
+}
+
+impl<T: Timestamp + Lattice> CorgiJoinTactic<T> {
+    pub fn new(key: Term, val: Term) -> Self {
+        CorgiJoinTactic { key, val, todo0: VecDeque::new(), todo1: VecDeque::new() }
+    }
+}
+
+impl<T, CB> JoinTactic<CBatch<T>, CBatch<T>, CB> for CorgiJoinTactic<T>
+where
+    T: Timestamp + Lattice,
+    CB: ContainerBuilder + PushInto<((Row, Row), T, Diff)>,
+{
+    fn defer(&mut self, input0: Vec<CBatch<T>>, input1: Vec<CBatch<T>>, fresh: Fresh, capability: Capability<T>) {
+        let unit = CorgiDeferred { left: input0, right: input1, capability };
+        match fresh {
+            Fresh::Input0 => self.todo0.push_back(unit),
+            Fresh::Input1 => self.todo1.push_back(unit),
+        }
+    }
+
+    fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>) {
+        // Eager (correctness-first): run every queued unit fully. Fuel budgeting is a later
+        // refinement; leaving `fuel` non-negative signals "complete" to the operator.
+        while let Some(unit) = self.todo0.pop_front() {
+            run_unit(unit, &self.key, &self.val, output);
+        }
+        while let Some(unit) = self.todo1.pop_front() {
+            run_unit(unit, &self.key, &self.val, output);
+        }
+        *fuel = 0;
+    }
+}
+
+/// Join one deferred bilinear unit: merge-join the two runs by key over corgi columns, cross-product
+/// matched val runs (lattice time-join + diff-multiply), project via corgi, emit at the capability.
+fn run_unit<T, CB>(unit: CorgiDeferred<T>, key: &Term, val: &Term, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>)
+where
+    T: Timestamp + Lattice,
+    CB: ContainerBuilder + PushInto<((Row, Row), T, Diff)>,
+{
+    let Some(left) = flatten_batches(&unit.left) else { return };
+    let Some(right) = flatten_batches(&unit.right) else { return };
+    let nl = left.times.len();
+
+    // Multi-record merge-join: one batched `find` gives, per left row, the equal-range of its key in
+    // the sorted right keys. Cross-product each left row with its matched right rows (lattice
+    // time-join + diff-multiply). Replaces the per-pair `compare_at` scan.
+    let (lo, hi) = find_ranges(&left.keys, &right.keys);
+    let (mut li, mut ri): (Vec<usize>, Vec<usize>) = (Vec::new(), Vec::new());
+    let (mut ot, mut od): (Vec<T>, Vec<Diff>) = (Vec::new(), Vec::new());
+    for a in 0..nl {
+        for b in lo[a]..hi[a] {
+            li.push(a);
+            ri.push(b);
+            ot.push(left.times[a].join(&right.times[b]));
+            od.push(left.diffs[a] * right.diffs[b]);
+        }
+    }
+    if li.is_empty() {
+        return;
+    }
+
+    // gather matched (key, val0, val1) columns, run the projection corgi program, untranscode.
+    let kc = gather(&left.keys, &li);
+    let v0 = gather(&left.vals, &li);
+    let v1 = gather(&right.vals, &ri);
+    // Compile the projection against the matched columns' shapes (so `Spread` resolves correctly).
+    let proj = compile_join_projection(key, val, &corgi::shape_of_value(&kc), &corgi::shape_of_value(&v0), &corgi::shape_of_value(&v1));
+    let projected = corgi::eval_graph(&proj, CValue::Prod(vec![kc, v0, v1]));
+    let mut cols = projected.into_prod("corgi join projection");
+    let nv = cols.pop().unwrap();
+    let nk = cols.pop().unwrap();
+    let newkeys = untranscode(nk.clone(), &corgi::shape_of_value(&nk));
+    let newvals = untranscode(nv.clone(), &corgi::shape_of_value(&nv));
+
+    let mut session = output.session_with_builder(&unit.capability);
+    for x in 0..li.len() {
+        session.give(((newkeys[x].clone(), newvals[x].clone()), ot[x].clone(), od[x]));
+    }
+}
diff --git a/interactive/src/corgi_logic.rs b/interactive/src/corgi_logic.rs
new file mode 100644
index 000000000..3132aa93e
--- /dev/null
+++ b/interactive/src/corgi_logic.rs
@@ -0,0 +1,481 @@
+//! corgi as DDIR's columnar scalar logic: compile a `Term` to a corgi `Graph<NumOp>`,
+//! transcode DDIR rows (`ir::Value`) to/from corgi columnar `Value`, directed by a `Shape`
+//! inferred from the data (the dynamic-typing primitive). See SPIKE.md.
+//!
+//! The compiler (`compile`) covers Var/Bound/Int/Tuple(+Spread)/Proj/Binary/If/Fold over non-negative
+//! ints; terms it can't lower (List, Case/Inject, Unary, Hash — see `compilable`) fall back to row-wise
+//! `ir::eval` in the backend. The transcode layer is total over `Shape` (Prim/Unit/Prod/List/Sum), so a
+//! `Variant` column round-trips via corgi `Sum` (see `infer_shape_cols` for the all-rows arm scan).
+
+use crate::ir::Value as DValue;
+use crate::parse::{BinOp, Term};
+
+use corgi::{ArithOp, BinOp as CBinOp, Builder, CmpOp, Graph, Kind, NumOp, Op, Pred, Shape, Value as CValue};
+
+/// Dynamic typing: form a corgi `Shape` by observing a sample row.
+pub fn infer_shape(sample: &DValue) -> Shape {
+    match sample {
+        DValue::Int(_) => Shape::Prim(64),
+        DValue::Tuple(xs) if xs.is_empty() => Shape::Unit, // DDIR unit ↔ corgi length-carrying Unit
+        DValue::Tuple(xs) => Shape::Prod(xs.iter().map(infer_shape).collect()),
+        DValue::List(xs) => Shape::List(Box::new(infer_shape(xs.first().expect("nonempty list")))),
+        DValue::Variant(..) => panic!("variant shape inference is a later rung"),
+    }
+}
+
+/// Dynamic typing over a whole COLUMN: infer a `Shape` by scanning every row, not just a sample.
+/// Required for sum types — a `Variant` column's shape is the union of all arms that appear, which a
+/// single sample can't reveal (it shows only one tag). Non-sum shapes match [`infer_shape`] but recurse
+/// column-wise so nested variants are covered too. (`from_updates` uses this; `infer_shape` stays for
+/// the single-sample callers that never carry variants.)
+pub fn infer_shape_cols(rows: &[DValue]) -> Shape {
+    let Some(first) = rows.first() else { return Shape::Unit };
+    match first {
+        DValue::Int(_) => Shape::Prim(64),
+        DValue::Tuple(xs) if xs.is_empty() => Shape::Unit,
+        DValue::Tuple(xs) => {
+            let n = xs.len();
+            Shape::Prod(
+                (0..n)
+                    .map(|i| {
+                        let col: Vec<DValue> = rows
+                            .iter()
+                            .map(|r| match r {
+                                DValue::Tuple(f) => f[i].clone(),
+                                other => panic!("infer_shape_cols: expected Tuple, got {other:?}"),
+                            })
+                            .collect();
+                        infer_shape_cols(&col)
+                    })
+                    .collect(),
+            )
+        }
+        DValue::List(_) => {
+            let flat: Vec<DValue> = rows
+                .iter()
+                .flat_map(|r| match r {
+                    DValue::List(xs) => xs.clone(),
+                    other => panic!("infer_shape_cols: expected List, got {other:?}"),
+                })
+                .collect();
+            Shape::List(Box::new(infer_shape_cols(&flat)))
+        }
+        DValue::Variant(..) => {
+            // One lane per variant 0..=max_tag; a lane present in the data gets its arm's shape (from
+            // that arm's rows), an absent tag stays `None` (⊥, uncommitted — adopts a sibling on join).
+            let max_tag = rows
+                .iter()
+                .map(|r| match r {
+                    DValue::Variant(t, _) => *t as usize,
+                    other => panic!("infer_shape_cols: expected Variant, got {other:?}"),
+                })
+                .max()
+                .unwrap();
+            let lanes = (0..=max_tag)
+                .map(|tag| {
+                    let payloads: Vec<DValue> = rows
+                        .iter()
+                        .filter_map(|r| match r {
+                            DValue::Variant(t, p) if *t as usize == tag => Some((**p).clone()),
+                            _ => None,
+                        })
+                        .collect();
+                    (!payloads.is_empty()).then(|| infer_shape_cols(&payloads))
+                })
+                .collect();
+            Shape::Sum(lanes)
+        }
+    }
+}
+
+/// AoS rows -> SoA corgi columns, directed by `shape`.
+pub fn transcode(rows: &[DValue], shape: &Shape) -> CValue {
+    match shape {
+        Shape::Prim(_) => CValue::u64(rows.iter().map(|r| r.as_int() as u64).collect()),
+        Shape::Unit => CValue::Unit(rows.len()),
+        Shape::Prod(fs) => CValue::Prod(
+            fs.iter()
+                .enumerate()
+                .map(|(i, fsi)| {
+                    let sub: Vec<DValue> = rows
+                        .iter()
+                        .map(|r| match r {
+                            DValue::Tuple(xs) => xs[i].clone(),
+                            other => panic!("transcode: expected Tuple, got {other:?}"),
+                        })
+                        .collect();
+                    transcode(&sub, fsi)
+                })
+                .collect(),
+        ),
+        Shape::List(elem) => {
+            // List column = per-row END offsets + a flattened element column.
+            let mut ends = Vec::with_capacity(rows.len());
+            let mut flat: Vec<DValue> = Vec::new();
+            let mut acc = 0usize;
+            for r in rows {
+                match r {
+                    DValue::List(xs) => {
+                        acc += xs.len();
+                        ends.push(acc);
+                        flat.extend(xs.iter().cloned());
+                    }
+                    other => panic!("transcode: expected List, got {other:?}"),
+                }
+            }
+            CValue::List(ends.into(), Box::new(transcode(&flat, elem)))
+        }
+        Shape::Sum(lanes) => {
+            // Per-row tag, plus one packed lane per committed variant (its arm's rows in row order;
+            // `Value::sum_opt` derives each row's within-lane offset). Absent arms stay `⊥` (None).
+            let tags: Vec<usize> = rows
+                .iter()
+                .map(|r| match r {
+                    DValue::Variant(t, _) => *t as usize,
+                    other => panic!("transcode: expected Variant, got {other:?}"),
+                })
+                .collect();
+            let lane_vals: Vec<Option<CValue>> = lanes
+                .iter()
+                .enumerate()
+                .map(|(tag, ls)| {
+                    ls.as_ref().map(|lshape| {
+                        let payloads: Vec<DValue> = rows
+                            .iter()
+                            .filter_map(|r| match r {
+                                DValue::Variant(t, p) if *t as usize == tag => Some((**p).clone()),
+                                _ => None,
+                            })
+                            .collect();
+                        transcode(&payloads, lshape)
+                    })
+                })
+                .collect();
+            CValue::sum_opt(tags, lane_vals)
+        }
+    }
+}
+
+/// SoA corgi columns -> AoS rows, directed by `shape`. Inverse of [`transcode`].
+pub fn untranscode(col: CValue, shape: &Shape) -> Vec<DValue> {
+    match shape {
+        Shape::Prim(_) => col.into_u64("untranscode").into_iter().map(|x| DValue::Int(x as i64)).collect(),
+        Shape::Unit => vec![DValue::unit(); col.len()],
+        Shape::Prod(fs) => {
+            let cols = col.into_prod("untranscode");
+            let n = if cols.is_empty() { 0 } else { cols[0].len() };
+            let per_field: Vec<Vec<DValue>> =
+                cols.into_iter().zip(fs.iter()).map(|(c, fsi)| untranscode(c, fsi)).collect();
+            (0..n).map(|i| DValue::Tuple(per_field.iter().map(|f| f[i].clone()).collect())).collect()
+        }
+        Shape::List(elem) => {
+            // Inverse of transcode's List: per-row END offsets + a flattened element column → one
+            // `List` per row, slicing the untranscoded flat column by each row's span.
+            let (bounds, vals) = match col {
+                CValue::List(b, vals) => (b, *vals),
+                other => panic!("untranscode: expected List, got {other:?}"),
+            };
+            let flat = untranscode(vals, elem);
+            let ends: Vec<usize> = match &bounds {
+                corgi::Bounds::Offsets(v) => v.clone(),
+                corgi::Bounds::Stride(k, rows) => (1..=*rows).map(|i| i * k).collect(),
+            };
+            let mut out = Vec::with_capacity(ends.len());
+            let mut start = 0usize;
+            for end in ends {
+                out.push(DValue::List(flat[start..end].to_vec()));
+                start = end;
+            }
+            out
+        }
+        Shape::Sum(lanes) => {
+            // Inverse of transcode's Sum: untranscode each committed lane, then for each row pull its
+            // payload from its lane at the recorded within-lane OFFSET (robust to row reordering from
+            // a prior gather/merge — not a sequential cursor).
+            let (tags, offsets, variant_vals) = col.into_sum("untranscode");
+            let lane_rows: Vec<Option<Vec<DValue>>> = variant_vals
+                .into_iter()
+                .zip(lanes.iter())
+                .map(|(v, ls)| match (v, ls) {
+                    (Some(cv), Some(lshape)) => Some(untranscode(cv, lshape)),
+                    _ => None,
+                })
+                .collect();
+            tags.iter()
+                .zip(&offsets)
+                .map(|(&tag, &off)| {
+                    let payload = lane_rows[tag].as_ref().expect("untranscode: committed lane")[off].clone();
+                    DValue::Variant(tag as u32, Box::new(payload))
+                })
+                .collect()
+        }
+    }
+}
+
+/// Structural shape of a "place" Term (Var/Proj chain) given the env vars' shapes — used to resolve
+/// `Spread`'s arity (how many fields to splice) and (later) Proj-on-list vs Proj-on-tuple.
+pub fn shape_of_place(t: &Term, env_shapes: &[Shape]) -> Shape {
+    match t {
+        Term::Var(i) => env_shapes[*i].clone(),
+        Term::Proj(inner, i) => match shape_of_place(inner, env_shapes) {
+            Shape::Prod(fs) => fs[*i].clone(),
+            Shape::List(e) => *e,
+            other => panic!("shape_of_place: Proj on non-aggregate {other:?}"),
+        },
+        other => panic!("shape_of_place: unsupported place {other:?}"),
+    }
+}
+
+/// Best-effort structural `Shape` of a (non-place) compiled `Term`, used to decide cross-shape
+/// `Eq`/`Ne`: DDIR compares `Value`s structurally, so e.g. `Tuple != Int` is *always* true (the
+/// variants differ) — but corgi's `CmpOp::Rel` requires matching shapes. When the operand shapes
+/// differ we fold the comparison to a constant instead of emitting a (panicking) `Rel`.
+fn infer_term_shape(t: &Term, env_shapes: &[Shape]) -> Shape {
+    match t {
+        Term::Var(i) => env_shapes[*i].clone(),
+        Term::Int(_) => Shape::Prim(64),
+        Term::Proj(inner, i) => match infer_term_shape(inner, env_shapes) {
+            Shape::Prod(fs) => fs[*i].clone(),
+            Shape::List(e) => *e,
+            other => panic!("infer_term_shape: Proj on non-aggregate {other:?}"),
+        },
+        Term::Tuple(fields) => {
+            let mut fs = Vec::new();
+            for f in fields {
+                match f {
+                    Term::Spread(inner) => match infer_term_shape(inner, env_shapes) {
+                        Shape::Prod(inner_fs) => fs.extend(inner_fs),
+                        Shape::Unit => {}
+                        other => fs.push(other),
+                    },
+                    _ => fs.push(infer_term_shape(f, env_shapes)),
+                }
+            }
+            if fs.is_empty() { Shape::Unit } else { Shape::Prod(fs) }
+        }
+        Term::If { then, .. } => infer_term_shape(then, env_shapes),
+        // Arithmetic, comparisons, and anything else scalar-ish reduce to a primitive column.
+        _ => Shape::Prim(64),
+    }
+}
+
+/// Whether [`compile`] can lower this term to a corgi graph. Terms that use features the corgi
+/// compiler doesn't model yet — `List`, `Inject`/`Case` (sum types), `Unary`, `Hash` — return false,
+/// and the backend falls back to row-wise `ir::eval` (parity with `backend::vec`).
+pub fn compilable(t: &Term) -> bool {
+    match t {
+        Term::Var(_) | Term::Bound(_) | Term::Int(_) => true,
+        Term::Proj(inner, _) | Term::Spread(inner) => compilable(inner),
+        Term::Tuple(fs) => fs.iter().all(compilable),
+        Term::Binary(_, l, r) => compilable(l) && compilable(r),
+        Term::If { cond, then, els } => compilable(cond) && compilable(then) && compilable(els),
+        Term::Fold { list, init, step } => compilable(list) && compilable(init) && compilable(step),
+        _ => false, // List, Inject, Case, Unary, Hash — row-wise fallback.
+    }
+}
+
+/// Compile a `Term` to a corgi node. `env[i]` = node for `Var(i)`; `env_shapes[i]` = its shape
+/// (for `Spread`). Binders push on top (read by `Bound(k)`). `anchor` sizes `Lit` broadcasts.
+pub fn compile(term: &Term, b: &mut Builder<NumOp>, env: &[usize], env_shapes: &[Shape], anchor: usize) -> usize {
+    match term {
+        Term::Var(i) => env[*i],
+        Term::Bound(k) => env[env.len() - 1 - *k],
+        Term::Int(n) => b.add(Op::Lit(CValue::u64(vec![*n as u64])), vec![anchor]),
+        Term::Tuple(fields) => {
+            // A `Spread(place)` child splices the place's `Prod` fields in place (the flat-row model).
+            let mut ids: Vec<usize> = Vec::new();
+            for f in fields {
+                match f {
+                    Term::Spread(inner) => {
+                        let node = compile(inner, b, env, env_shapes, anchor);
+                        match shape_of_place(inner, env_shapes) {
+                            Shape::Prod(fs) => {
+                                for i in 0..fs.len() {
+                                    ids.push(b.add(Op::Field(i), vec![node]));
+                                }
+                            }
+                            Shape::Unit => {} // unit splices nothing
+                            _ => ids.push(node), // scalar: splice the value itself
+                        }
+                    }
+                    _ => ids.push(compile(f, b, env, env_shapes, anchor)),
+                }
+            }
+            // An empty field list is DDIR unit: emit a length-carrying `Unit` column over the anchor,
+            // NOT `Prod([])` (an empty product has no rows to count, so the row count would be lost).
+            if ids.is_empty() {
+                b.add(Op::Unit, vec![anchor])
+            } else {
+                b.tuple(ids)
+            }
+        }
+        Term::Proj(t, i) => {
+            let id = compile(t, b, env, env_shapes, anchor);
+            b.add(Op::Field(*i), vec![id])
+        }
+        Term::Binary(op, l, r) => {
+            let lid = compile(l, b, env, env_shapes, anchor);
+            let rid = compile(r, b, env, env_shapes, anchor);
+            let pair = |b: &mut Builder<NumOp>, x, y| b.tuple(vec![x, y]);
+            match op {
+                BinOp::Add => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Add, Kind::U, 64), vec![p]) }
+                BinOp::Sub => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Sub, Kind::U, 64), vec![p]) }
+                BinOp::Mul => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Mul, Kind::U, 64), vec![p]) }
+                BinOp::Eq | BinOp::Ne => {
+                    // Cross-shape structural compare folds to a constant (Eq→0, Ne→1) over `anchor`;
+                    // same-shape emits a real corgi `Rel`.
+                    if infer_term_shape(l, env_shapes) != infer_term_shape(r, env_shapes) {
+                        let v = if matches!(op, BinOp::Ne) { 1u64 } else { 0u64 };
+                        b.add(Op::Lit(CValue::u64(vec![v])), vec![anchor])
+                    } else {
+                        let pred = if matches!(op, BinOp::Eq) { Pred::Eq } else { Pred::Ne };
+                        let p = pair(b, lid, rid);
+                        b.add(CmpOp::Rel(pred), vec![p])
+                    }
+                }
+                BinOp::Lt => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Lt), vec![p]) }
+                BinOp::Le => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Le), vec![p]) }
+                BinOp::Gt => { let p = pair(b, rid, lid); b.add(CmpOp::Rel(Pred::Lt), vec![p]) }
+                BinOp::Ge => { let p = pair(b, rid, lid); b.add(CmpOp::Rel(Pred::Le), vec![p]) }
+                BinOp::And => { let p = pair(b, lid, rid); b.add(CmpOp::Min, vec![p]) }
+                BinOp::Or => { let p = pair(b, lid, rid); b.add(CmpOp::Max, vec![p]) }
+            }
+        }
+        Term::If { cond, then, els } => {
+            let c = compile(cond, b, env, env_shapes, anchor);
+            let t = compile(then, b, env, env_shapes, anchor);
+            let e = compile(els, b, env, env_shapes, anchor);
+            let sel = b.tuple(vec![c, t, e]);
+            b.add(Op::Select, vec![sel])
+        }
+        // Fold over a List. corgi `Op::Fold` consumes `Prod([seed, List<A>])` and folds each row's
+        // list; its body is a closed sub-graph over `Prod([acc, elem])`. DDIR's step sees
+        // elem=Bound(0), acc=Bound(1), so the body env is [acc, elem] (Bound counts from the top).
+        // Restriction (this rung): the step references only its binders (monoid-style), not outer
+        // Vars — corgi closes the body; an outer reference would need CapList capture.
+        Term::Fold { list, init, step } => {
+            let init_id = compile(init, b, env, env_shapes, anchor);
+            let list_id = compile(list, b, env, env_shapes, anchor);
+            let pair = b.tuple(vec![init_id, list_id]);
+            let body = compile_fold_body(step);
+            b.add(Op::Fold(Box::new(body)), vec![pair])
+        }
+        other => panic!("compile: unsupported Term in this rung: {other:?}"),
+    }
+}
+
+/// Compile a `Fold` step into a closed corgi sub-graph over `Prod([acc, elem])`.
+/// Env `[acc, elem]` so `Bound(0)`=elem (top), `Bound(1)`=acc — matching `ir::eval`'s Fold.
+fn compile_fold_body(step: &Term) -> Graph<NumOp> {
+    let mut bb = Builder::<NumOp>::default();
+    let inp = bb.input();
+    let acc = bb.add(Op::Field(0), vec![inp]);
+    let elem = bb.add(Op::Field(1), vec![inp]);
+    // Monoid fold bodies use only binders (no Spread/Proj-on-list), so no env shapes are needed.
+    let out = compile(step, &mut bb, &[acc, elem], &[], inp);
+    bb.finish(out)
+}
+
+/// Compile a single `Term` whose `Var(0)` is the whole input row/column. (Spread-free terms only —
+/// the bench/chain/fold examples — so no env shape is needed.)
+pub fn compile_term_single(term: &Term) -> Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input();
+    let out = compile(term, &mut b, &[input], &[], input);
+    b.finish(out)
+}
+
+/// Compile a `Filter` predicate over `Var(0)=key` (shape `kshape`), `Var(1)=val` (`vshape`) → mask.
+pub fn compile_predicate(cond: &Term, kshape: &Shape, vshape: &Shape) -> Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input();
+    let var_k = b.add(Op::Field(0), vec![input]);
+    let var_v = b.add(Op::Field(1), vec![input]);
+    let out = compile(cond, &mut b, &[var_k, var_v], &[kshape.clone(), vshape.clone()], input);
+    b.finish(out)
+}
+
+/// Compile a join projection: key/val Terms over `Var(0)=key`, `Var(1)=val0`, `Var(2)=val1` (with
+/// their shapes for `Spread`). Input `Prod([key, val0, val1])`; output `Prod([newkey, newval])`.
+pub fn compile_join_projection(key: &Term, val: &Term, kshape: &Shape, v0shape: &Shape, v1shape: &Shape) -> Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input();
+    let var_k = b.add(Op::Field(0), vec![input]);
+    let var_0 = b.add(Op::Field(1), vec![input]);
+    let var_1 = b.add(Op::Field(2), vec![input]);
+    let env = [var_k, var_0, var_1];
+    let shapes = [kshape.clone(), v0shape.clone(), v1shape.clone()];
+    let nk = compile(key, &mut b, &env, &shapes, input);
+    let nv = compile(val, &mut b, &env, &shapes, input);
+    let out = b.tuple(vec![nk, nv]);
+    b.finish(out)
+}
+
+/// Compile a DDIR `Projection` over `Var(0)=key` (`kshape`), `Var(1)=val` (`vshape`).
+/// Input `Prod([key, val])`; output `Prod([newkey, newval])`.
+pub fn compile_projection(key: &Term, val: &Term, kshape: &Shape, vshape: &Shape) -> Graph<NumOp> {
+    let mut b = Builder::<NumOp>::default();
+    let input = b.input();
+    let var_k = b.add(Op::Field(0), vec![input]);
+    let var_v = b.add(Op::Field(1), vec![input]);
+    let env = [var_k, var_v];
+    let shapes = [kshape.clone(), vshape.clone()];
+    let nk = compile(key, &mut b, &env, &shapes, input);
+    let nv = compile(val, &mut b, &env, &shapes, input);
+    let out = b.tuple(vec![nk, nv]);
+    b.finish(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ir::Value as V;
+
+    /// Round-trip a column of rows through infer_shape_cols → transcode → untranscode.
+    fn roundtrip(rows: Vec<V>) {
+        let shape = infer_shape_cols(&rows);
+        let col = transcode(&rows, &shape);
+        let back = untranscode(col, &shape);
+        assert_eq!(back, rows, "roundtrip mismatch (shape {shape:?})");
+    }
+
+    #[test]
+    fn roundtrip_variant_single_arm() {
+        // binders-style: a single constructor wrapping a list.
+        roundtrip(vec![
+            V::Variant(0, Box::new(V::List(vec![V::Int(1), V::Int(2)]))),
+            V::Variant(0, Box::new(V::List(vec![V::Int(3)]))),
+            V::Variant(0, Box::new(V::List(vec![]))),
+        ]);
+    }
+
+    #[test]
+    fn roundtrip_variant_multi_arm() {
+        // adt-style: two arms, interleaved; payloads of different shape per arm.
+        roundtrip(vec![
+            V::Variant(0, Box::new(V::Int(10))),
+            V::Variant(1, Box::new(V::Tuple(vec![V::Int(1), V::Int(2)]))),
+            V::Variant(0, Box::new(V::Int(20))),
+            V::Variant(1, Box::new(V::Tuple(vec![V::Int(3), V::Int(4)]))),
+            V::Variant(0, Box::new(V::Int(30))),
+        ]);
+    }
+
+    #[test]
+    fn roundtrip_variant_absent_arm_is_bottom() {
+        // tags {0, 2} present, arm 1 absent → a ⊥ lane; round-trip must still reconstruct.
+        roundtrip(vec![
+            V::Variant(0, Box::new(V::Int(1))),
+            V::Variant(2, Box::new(V::Int(2))),
+            V::Variant(0, Box::new(V::Int(3))),
+        ]);
+    }
+
+    #[test]
+    fn roundtrip_nested_variant_in_tuple() {
+        roundtrip(vec![
+            V::Tuple(vec![V::Int(1), V::Variant(0, Box::new(V::Int(7)))]),
+            V::Tuple(vec![V::Int(2), V::Variant(1, Box::new(V::unit()))]),
+        ]);
+    }
+}
diff --git a/interactive/src/corgi_reduce.rs b/interactive/src/corgi_reduce.rs
new file mode 100644
index 000000000..c82a4a8ab
--- /dev/null
+++ b/interactive/src/corgi_reduce.rs
@@ -0,0 +1,285 @@
+//! Phase 2 / M2(b) — the cursor-less corgi REDUCE tactic (Route B), built on Frank's `active_times`.
+//!
+//! `reduce_with_tactic` needs only `TraceReader` (not `Navigable`), so a cursor-less `CorgiBatch`
+//! arrangement drives a custom `ReduceTactic`. The incremental skeleton mirrors DD's `CursorTactic`/
+//! `HistoryReplayer` but swaps the lazy interesting-time derivation for the explicit (over-deriving)
+//! `active_times`, and the cursor reads for corgi-column reads:
+//!
+//!   per changed key (input keys ∪ carried pending keys):
+//!     read input history (source+input batches) & output history (output batches) to rows
+//!     novel = input times in [lower,upper) ∪ carried pending times;  prior = input times < lower
+//!     active_times(upper, prior, novel) -> active (∈[lower,upper)) + pended (≥upper)
+//!     for t in active (increasing): desired = reduce(Σ input ≤ t); cur = Σ (output ≤ t ⊎ emitted ≤ t)
+//!       emit (desired − cur) at t, into the held bucket = largest held time ≤ t
+//!     carry pended → next pending
+//!   build one output batch per held time (tile [lower,upper)); held frontier = pending times
+//!
+//! The per-key reducer runs in RUST (the DDIR `Reducer`s, matching `backend::vec`) — at each
+//! interesting time it sees a tiny per-key value slice, where corgi's columnar win doesn't apply
+//! (corgi pays on wide columns); corgi's role in reduce is the columnar *storage* + merge/advance.
+
+use std::collections::{BTreeSet, HashMap};
+use std::rc::Rc;
+
+use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
+
+use differential_dataflow::lattice::Lattice;
+use differential_dataflow::operators::reduce::ReduceTactic;
+use differential_dataflow::trace::Builder as _;
+use differential_dataflow::trace::Description;
+use differential_dataflow::trace::chunk::ChunkBatch;
+
+use crate::corgi_chunk::{batch_to_rows, CorgiChunk, CorgiChunkBuilder};
+use crate::ir::{Diff, Value as DValue};
+use crate::parse::Reducer;
+
+type Row = DValue;
+
+/// Determines the active times for an interval `[lower, upper)` (Frank's definition).
+///
+/// Active times are joins of input times (`novel` + `prior`) that are `>= lower` but not `>= upper`;
+/// the over-derivation is sound (a non-changing time yields a zero delta). Times `>= upper` are
+/// `pended` for a future interval. `novel ∈ [lower, upper)` (seeds); `prior ∈ ..lower)` (join partners).
+fn active_times<T: Lattice + Ord + Clone>(
+    upper: AntichainRef<T>,
+    prior: &[T],
+    novel: &[T],
+    active: &mut BTreeSet<T>,
+    pended: &mut BTreeSet<T>,
+) {
+    let mut todo: BTreeSet<T> = novel.iter().cloned().collect();
+    while let Some(next) = todo.pop_first() {
+        if upper.less_equal(&next) {
+            pended.insert(next);
+        } else if active.insert(next.clone()) {
+            for t in novel.iter().chain(prior.iter()) {
+                let join = next.join(t);
+                if !active.contains(&join) {
+                    todo.insert(join);
+                }
+            }
+        }
+    }
+}
+
+/// Consolidate `(val, diff)` pairs (sum per val, drop zeros), sorted by val.
+fn consolidate_vals(mut v: Vec<(Row, Diff)>) -> Vec<(Row, Diff)> {
+    v.sort_by(|a, b| a.0.cmp(&b.0));
+    let mut out: Vec<(Row, Diff)> = Vec::with_capacity(v.len());
+    for (val, d) in v {
+        if let Some(last) = out.last_mut() {
+            if last.0 == val {
+                last.1 += d;
+                continue;
+            }
+        }
+        out.push((val, d));
+    }
+    out.retain(|(_, d)| *d != 0);
+    out
+}
+
+/// The DDIR reducers, in Rust — matching `backend::vec`'s closures so output == the vec backend.
+fn reduce_logic(reducer: &Reducer, input: &[(Row, Diff)]) -> Vec<(Row, Diff)> {
+    match reducer {
+        Reducer::Min => input
+            .iter()
+            .filter(|(_, d)| *d > 0)
+            .map(|(v, _)| v.clone())
+            .min()
+            .map(|m| vec![(m, 1)])
+            .unwrap_or_default(),
+        Reducer::Distinct => {
+            if input.iter().any(|(_, d)| *d > 0) {
+                vec![(DValue::unit(), 1)]
+            } else {
+                Vec::new()
+            }
+        }
+        Reducer::Count => {
+            let count: Diff = input.iter().map(|(_, d)| *d).sum();
+            if count > 0 {
+                vec![(DValue::Tuple(vec![DValue::Int(count)]), 1)]
+            } else {
+                Vec::new()
+            }
+        }
+        Reducer::Collect => {
+            let mut items = Vec::new();
+            for (v, d) in input {
+                for _ in 0..(*d).max(0) {
+                    items.push(v.clone());
+                }
+            }
+            vec![(DValue::List(items), 1)]
+        }
+    }
+}
+
+/// Cursor-less corgi reduce tactic. Stateful: carries per-key pending (deferred ≥upper) times.
+pub struct CorgiReduceTactic<T> {
+    reducer: Reducer,
+    pending: HashMap<Row, Vec<T>>,
+}
+
+impl<T> CorgiReduceTactic<T> {
+    pub fn new(reducer: Reducer) -> Self {
+        CorgiReduceTactic { reducer, pending: HashMap::new() }
+    }
+}
+
+impl<T> ReduceTactic<Rc<ChunkBatch<CorgiChunk<T, Diff>>>, Rc<ChunkBatch<CorgiChunk<T, Diff>>>> for CorgiReduceTactic<T>
+where
+    T: Timestamp + Lattice + Ord,
+{
+    fn retire(
+        &mut self,
+        source_batches: Vec<Rc<ChunkBatch<CorgiChunk<T, Diff>>>>,
+        output_batches: Vec<Rc<ChunkBatch<CorgiChunk<T, Diff>>>>,
+        input_batches: Vec<Rc<ChunkBatch<CorgiChunk<T, Diff>>>>,
+        lower: &Antichain<T>,
+        upper: &Antichain<T>,
+        held: &Antichain<T>,
+    ) -> (Vec<(T, Rc<ChunkBatch<CorgiChunk<T, Diff>>>)>, Antichain<T>) {
+        // Only work if we hold a time we can actually ship in [.., upper).
+        if held.elements().iter().all(|t| upper.less_equal(t)) {
+            return (Vec::new(), held.clone());
+        }
+
+        // Incremental key selection: only keys touched by the new input delta (`input_batches`) or
+        // carrying pending times can change output in [lower, upper). Unchanged accumulated keys
+        // cannot — reconsidering them was an O(all keys × rounds) blowup (mirrors DD's reduce, which
+        // only recomputes keys the new batch touches). Restricting the per-key histories to `changed`
+        // also keeps `group_by_key`'s BTreeMap + `Value::cmp` cost proportional to the delta.
+        let mut changed: std::collections::HashSet<Row> = std::collections::HashSet::new();
+        for b in &input_batches {
+            for ((k, _), _, _) in batch_to_rows(b) { changed.insert(k); }
+        }
+        for k in self.pending.keys() { changed.insert(k.clone()); }
+        if changed.is_empty() {
+            // No input delta and no carried pending → no key's output can change this interval, and
+            // nothing remains to hold. Downgrade to the EMPTY frontier: this matches what the full
+            // flow computes (an empty `pending` → empty frontier). Returning `held` here would keep
+            // the capability forever and DEADLOCK a recursive scope (scc), which reach never exercised.
+            self.pending.clear();
+            return (Vec::new(), Antichain::new());
+        }
+
+        // Full per-key input history (source ∪ input) and output history, restricted to `changed`.
+        // (A `find`-semijoin read was tried here and measured SLOWER: the source read is only ~7% of
+        // reduce cost, and `find`'s per-chunk overhead exceeds the untranscode it saves. The dominant
+        // cost is the row-wise per-key compute below, which needs a columnar segmented-fold, not a
+        // faster read. See `corgi_chunk::semijoin_history` — kept for when that lands / at larger scale.)
+        let mut input_hist: HashMap<Row, Vec<(Row, T, Diff)>> = HashMap::new();
+        for b in source_batches.iter().chain(input_batches.iter()) {
+            for ((k, v), t, d) in batch_to_rows(b) {
+                if changed.contains(&k) { input_hist.entry(k).or_default().push((v, t, d)); }
+            }
+        }
+        let mut output_hist: HashMap<Row, Vec<(Row, T, Diff)>> = HashMap::new();
+        for b in &output_batches {
+            for ((k, v), t, d) in batch_to_rows(b) {
+                if changed.contains(&k) { output_hist.entry(k).or_default().push((v, t, d)); }
+            }
+        }
+        let keys = changed;
+
+        // One output-row buffer per held time (ship-time bucket); a delta at `t` routes to the
+        // largest held time `<= t`.
+        let held_elems: Vec<T> = held.elements().to_vec();
+        let mut builders: Vec<Vec<((Row, Row), T, Diff)>> = vec![Vec::new(); held_elems.len()];
+
+        let mut new_pending: HashMap<Row, Vec<T>> = HashMap::new();
+
+        for key in keys {
+            let in_hist = input_hist.get(&key).cloned().unwrap_or_default();
+            let out_hist = output_hist.get(&key).cloned().unwrap_or_default();
+
+            // novel (seeds) = input times in [lower,upper) ∪ carried pending; prior = times < lower.
+            let mut novel: Vec<T> = in_hist
+                .iter()
+                .map(|(_, t, _)| t.clone())
+                .filter(|t| lower.less_equal(t) && !upper.less_equal(t))
+                .collect();
+            if let Some(p) = self.pending.get(&key) {
+                novel.extend(p.iter().cloned());
+            }
+            let prior: Vec<T> = in_hist.iter().map(|(_, t, _)| t.clone()).filter(|t| !lower.less_equal(t)).collect();
+            novel.sort();
+            novel.dedup();
+
+            let mut active = BTreeSet::new();
+            let mut pended = BTreeSet::new();
+            active_times(upper.borrow(), &prior, &novel, &mut active, &mut pended);
+            if !pended.is_empty() {
+                new_pending.entry(key.clone()).or_default().extend(pended);
+            }
+            if active.is_empty() {
+                continue;
+            }
+
+            // Running output (committed output + deltas emitted this pass), accumulated as-of each t.
+            let mut emitted: Vec<(Row, T, Diff)> = Vec::new();
+            for t in active {
+                let in_acc = consolidate_vals(
+                    in_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect(),
+                );
+                let mut cur: Vec<(Row, Diff)> =
+                    out_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect();
+                cur.extend(emitted.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)));
+                let cur = consolidate_vals(cur);
+
+                let desired = reduce_logic(&self.reducer, &in_acc);
+
+                let mut delta: HashMap<Row, Diff> = HashMap::new();
+                for (v, d) in desired {
+                    *delta.entry(v).or_insert(0) += d;
+                }
+                for (v, d) in cur {
+                    *delta.entry(v).or_insert(0) -= d;
+                }
+                delta.retain(|_, d| *d != 0);
+                if delta.is_empty() {
+                    continue;
+                }
+
+                let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
+                for (v, d) in delta {
+                    emitted.push((v.clone(), t.clone(), d));
+                    builders[idx].push(((key.clone(), v), t.clone(), d));
+                }
+            }
+        }
+
+        self.pending = new_pending;
+
+        // Build one output batch per held time, tiling [lower, upper) (mirrors CursorTactic).
+        let mut produced = Vec::new();
+        let mut out_lower = lower.clone();
+        for (index, rows) in builders.into_iter().enumerate() {
+            let mut out_upper = upper.clone();
+            for t in &held_elems[index + 1..] {
+                out_upper.insert(t.clone());
+            }
+            if out_upper != out_lower {
+                let desc = Description::new(out_lower.clone(), out_upper.clone(), Antichain::from_elem(T::minimum()));
+                let mut builder = CorgiChunkBuilder::<T, Diff>::with_capacity(0, 0, rows.len());
+                let mut rows = rows;
+                builder.push(&mut rows);
+                let batch = Rc::new(builder.done(desc));
+                produced.push((held_elems[index].clone(), batch));
+                out_lower = out_upper;
+            }
+        }
+
+        // New held frontier = all carried pending times.
+        let mut frontier = Antichain::new();
+        for times in self.pending.values() {
+            for t in times {
+                frontier.insert(t.clone());
+            }
+        }
+        (produced, frontier)
+    }
+}
diff --git a/interactive/src/lib.rs b/interactive/src/lib.rs
index 1146d8c4a..8258e932a 100644
--- a/interactive/src/lib.rs
+++ b/interactive/src/lib.rs
@@ -1,5 +1,11 @@
 pub mod parse;
 pub mod ir;
+pub mod corgi_logic;
+pub mod corgi_backend;
+pub mod corgi_arrange;
+pub mod corgi_chunk;
+pub mod corgi_join;
+pub mod corgi_reduce;
 pub mod lower;
 pub mod scope_ir;
 pub mod backend;

From 23cf139c88afce35c6ef7615f254f218b86985a4 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 19:46:57 -0400
Subject: [PATCH 11/68] =?UTF-8?q?interactive:=20operator=20scorecard=20?=
 =?UTF-8?q?=E2=80=94=20per-operator=20corgi-vs-vec=20perf=20triage?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A standing harness that isolates each backend operator in a minimal DDIR
program, asserts corgi == vec, and reports the corgi/vec ratio against a
target. `PROG=<name> BACKEND=<corgi|vec>` loops one case for samply.

Baseline (n=100k linear / 20k arrange-y):
  map8            0.30x  ✓ (columnar compute, no row boundary)
  filter          0.75x  ✓
  arrange         1.5x   ✗   \
  join            1.5x   ✗    >  every operator with a columns<->rows
  reduce_distinct 2.0x   ✗   /   transcode boundary loses
  reduce_count    2.0x   ✗
  reach           2.0x   ✗

Corrects an earlier whole-program-profile conclusion ("only the reduce is
slow"): per-operator, arrange and join are independently ~1.5x — the shared
cost is the transcode boundary, not one operator. Beating vec means removing
row boundaries (chunk-native ingest, columnar operator emit).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/examples/corgi_scorecard.rs | 209 ++++++++++++++++++++++++
 1 file changed, 209 insertions(+)
 create mode 100644 interactive/examples/corgi_scorecard.rs

diff --git a/interactive/examples/corgi_scorecard.rs b/interactive/examples/corgi_scorecard.rs
new file mode 100644
index 000000000..65a5b5ccb
--- /dev/null
+++ b/interactive/examples/corgi_scorecard.rs
@@ -0,0 +1,209 @@
+//! Operator scorecard — the standing per-operator perf-triage harness for the corgi backend.
+//!
+//! Each case is a minimal DDIR program that isolates ONE backend operator so its corgi-vs-vec ratio
+//! is read directly, instead of reverse-engineered from a whole program. Every case also asserts
+//! corgi == vec (correctness gate) before timing.
+//!
+//! Two modes:
+//!   * scorecard (default):  bench every case, print `vec | corgi | ratio | target | verdict`.
+//!       ~/.cargo/bin/cargo run --release -p interactive --example corgi_scorecard
+//!   * profile one case:     PROG=<name> BACKEND=<corgi|vec> ITERS=<n> loops that case (for samply).
+//!       BACKEND=corgi ITERS=400 samply record ... -- .../corgi_scorecard   # PROG=reduce_distinct etc.
+//!
+//! Targets encode the thesis: parity with vec is the FLOOR (never lose on an operator), beating vec
+//! is the GOAL (columnar corgi should avoid the row backend's interpretation + Value pointer-chasing).
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse, scope_ir};
+
+type Row = Value;
+
+fn tup(fields: &[i64]) -> Row {
+    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+fn compile(src: &str) -> scope_ir::Program {
+    let mut p = lower::lower_tree(parse::pipe::parse(src));
+    p.optimize();
+    p
+}
+
+/// Median wall-clock over `iters` runs (min 3), after a warmup.
+fn bench<F: FnMut()>(iters: usize, mut f: F) -> Duration {
+    f();
+    let mut ts: Vec<Duration> = (0..iters.max(3))
+        .map(|_| { let t = Instant::now(); f(); t.elapsed() })
+        .collect();
+    ts.sort();
+    ts[ts.len() / 2]
+}
+
+/// A wide 6-field keyed collection: `(key ; f1..f6)`. Shared input for the compute/arrange cases.
+fn wide_input(n: usize, seed: u64) -> Vec<(Row, Row)> {
+    let mut s = seed;
+    (0..n)
+        .map(|i| {
+            let f = |s: &mut u64| (xorshift(s) % 1000) as i64;
+            (tup(&[i as i64, f(&mut s), f(&mut s), f(&mut s), f(&mut s), f(&mut s)]), Value::unit())
+        })
+        .collect()
+}
+
+/// Edges over `nodes` (key = src, val = dst) — for join / reduce / reach.
+fn edges(nodes: usize, fanout: usize, seed: u64) -> Vec<(Row, Row)> {
+    let mut s = seed;
+    (0..nodes * fanout)
+        .map(|_| (tup(&[(xorshift(&mut s) % nodes as u64) as i64, (xorshift(&mut s) % nodes as u64) as i64]), Value::unit()))
+        .collect()
+}
+
+/// A scorecard case: the operator it isolates, its program, inputs, sizes, and target ratio.
+struct Case {
+    name: &'static str,
+    isolates: &'static str,
+    src: String,
+    inputs: fn(usize) -> Vec<Vec<(Row, Row)>>,
+    sizes: Vec<usize>,
+    target: f64, // corgi/vec ratio we're aiming at (<=1 = parity-or-better)
+}
+
+fn cases() -> Vec<Case> {
+    // 8 wide arithmetic maps, NO arrange — pure columnar compute.
+    let mut map8 = String::from("let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5], $0[0]);\n");
+    let mut prev = 'a';
+    for i in 0..8 {
+        let cur = (b'b' + i) as char;
+        map8.push_str(&format!(
+            "let {cur} = {prev} | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);\n"
+        ));
+        prev = cur;
+    }
+    map8.push_str(&format!("export \"r\" = {prev};\n"));
+
+    vec![
+        Case {
+            name: "map8",
+            isolates: "linear (map, columnar eval, no arrange)",
+            src: map8,
+            inputs: |n| vec![wide_input(n, 0xdead_beef)],
+            sizes: vec![20_000, 100_000],
+            target: 0.5,
+        },
+        Case {
+            name: "filter",
+            isolates: "linear (filter, no arrange)",
+            src: "let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5]);\n\
+                   let b = a | filter($1[0] != 999999);\n\
+                   let c = b | filter($1[1] != 999999);\n\
+                   export \"r\" = c | filter($1[2] != 999999);\n".into(),
+            inputs: |n| vec![wide_input(n, 0x1234_5678)],
+            sizes: vec![20_000, 100_000],
+            target: 0.6,
+        },
+        Case {
+            name: "arrange",
+            isolates: "arrange (build + as_collection + transcode)",
+            src: "export \"r\" = input 0 | key($0[0] ; $0[1]) | arrange;\n".into(),
+            inputs: |n| vec![wide_input(n, 0x0a0a_0a0a)],
+            sizes: vec![20_000, 100_000],
+            target: 1.0,
+        },
+        Case {
+            name: "join",
+            isolates: "join (non-recursive, find merge-join)",
+            src: "let a = input 0 | key($0[0] ; $0[1]);\n\
+                  let b = input 1 | key($0[0] ; $0[1]);\n\
+                  export \"r\" = a | join(b, ($1 ; $2)) | arrange;\n".into(),
+            inputs: |n| vec![edges(n, 2, 0x11), edges(n, 2, 0x22)],
+            sizes: vec![5_000, 20_000],
+            target: 1.0,
+        },
+        Case {
+            name: "reduce_distinct",
+            isolates: "reduce (distinct, non-recursive)",
+            src: "export \"r\" = input 0 | key($0[0] ; $0[1]) | distinct | arrange;\n".into(),
+            inputs: |n| vec![edges(n, 4, 0x33)],
+            sizes: vec![5_000, 20_000],
+            target: 1.0,
+        },
+        Case {
+            name: "reduce_count",
+            isolates: "reduce (count, non-recursive)",
+            src: "export \"r\" = input 0 | key($0[0] ; $0[1]) | count | arrange;\n".into(),
+            inputs: |n| vec![edges(n, 4, 0x44)],
+            sizes: vec![5_000, 20_000],
+            target: 1.0,
+        },
+        Case {
+            name: "reach",
+            isolates: "integration (recursive join + distinct)",
+            src: "let edges = input 0 | key($0[0] ; $0[1]);\n\
+                  let roots = input 1 | key($0[0] ;);\n\
+                  reach: {\n\
+                    let proposals = reach | join(edges, ($2 ;));\n\
+                    var reach = roots + proposals | distinct;\n\
+                  }\n\
+                  export \"r\" = reach::reach | arrange;\n".into(),
+            inputs: |n| vec![edges(n, 3, 0x9e37), vec![(tup(&[0]), Value::unit())]],
+            sizes: vec![1_000, 4_000],
+            target: 1.0,
+        },
+    ]
+}
+
+fn verdict(ratio: f64, target: f64) -> &'static str {
+    if ratio <= target { "✓ AT TARGET" }
+    else if ratio < 1.0 { "win, below target" }
+    else if ratio < 1.3 { "~ near parity" }
+    else { "✗ SLOW" }
+}
+
+fn main() {
+    let prog = std::env::var("PROG").ok();
+
+    // Profile mode: loop one case's largest size on one backend (for samply).
+    if let Some(name) = prog {
+        let case = cases().into_iter().find(|c| c.name == name).unwrap_or_else(|| panic!("no case {name}"));
+        let p = compile(&case.src);
+        let n = *case.sizes.last().unwrap();
+        let inputs = (case.inputs)(n);
+        let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
+        let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(400);
+        let mut acc = 0usize;
+        for _ in 0..iters {
+            let out = if backend == "vec" { vec::evaluate(&p, &inputs) } else { corgi::evaluate(&p, &inputs) };
+            acc += out.values().map(|v| v.len()).sum::<usize>();
+        }
+        std::hint::black_box(acc);
+        eprintln!("done {name} backend={backend} iters={iters} (acc={acc})");
+        return;
+    }
+
+    // Scorecard mode.
+    println!("{:<16} {:<44} {:>8} {:>10} {:>10} {:>7} {:>7}  {}",
+             "case", "isolates", "n", "vec", "corgi", "ratio", "target", "verdict");
+    println!("{}", "-".repeat(130));
+    for case in cases() {
+        let p = compile(&case.src);
+        for &n in &case.sizes {
+            let inputs = (case.inputs)(n);
+            assert_eq!(corgi::evaluate(&p, &inputs), vec::evaluate(&p, &inputs), "MISMATCH in {}", case.name);
+            let vt = bench(5, || { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+            let ct = bench(5, || { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+            let ratio = ct.as_secs_f64() / vt.as_secs_f64();
+            println!("{:<16} {:<44} {:>8} {:>9.2?} {:>9.2?} {:>6.2}x {:>6.2}x  {}",
+                     case.name, case.isolates, n, vt, ct, ratio, case.target, verdict(ratio, case.target));
+        }
+    }
+    println!("\nfloor = parity (ratio 1.0); goal = beat vec (ratio < 1.0). Profile a case: PROG=<name> BACKEND=corgi samply record ...");
+}

From a6f02e7ec892e7f06af087c62d75da81fa265f47 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 20:12:49 -0400
Subject: [PATCH 12/68] =?UTF-8?q?interactive:=20remove=20arrange/join=20tr?=
 =?UTF-8?q?anscode=20boundaries=20=E2=80=94=20both=20now=20beat=20vec?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The columns↔rows transcodes at operator edges were self-inflicted, not
inherent. Removed all three:

  - as_collection: read chunk columns straight into a CorgiContainer
    (chunks_to_columns), no untranscode→from_updates round-trip.
  - join emit: the projection already yields corgi columns; emit them via
    give_container into a CapacityContainerBuilder<CorgiContainer> and drop the
    JoinToCorgi unary — no untranscode + per-row give + re-transcode.
  - arrange ingest: CorgiChunker (a ContainerBuilder) sort-consolidates each
    input CorgiContainer's columns directly into CorgiChunks — replacing
    ContainerChunker's drain-to-rows + VecMerger + row-based builder. It
    ACCUMULATES to TARGET before consolidating, so it emits few large chunks,
    not one tiny chunk per input container (else the columnar per-chunk set-up
    dominates on many small batches).

Scorecard (corgi/vec): arrange 1.5x→0.9x (BEATS vec), join 1.5x→0.7x (BEATS
vec), reduce_distinct/count 2.0x→1.35x, reach 1.9x→1.45x. All 6 programs match
vec; 33 lib tests pass. Remaining reduce gap is the row-wise reducer (Rust over
Value rows) — next: columnar consolidate via corgi group→fold_add→filter.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs |  41 +++++------
 interactive/src/corgi_chunk.rs   | 120 +++++++++++++++++++++++++++++++
 interactive/src/corgi_join.rs    |  23 +++---
 3 files changed, 146 insertions(+), 38 deletions(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index 9e204c332..7fe5c738c 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -17,16 +17,13 @@ use differential_dataflow::operators::join::join_with_tactic;
 use differential_dataflow::operators::reduce::reduce_with_tactic;
 use differential_dataflow::operators::arrange::arrangement::arrange_core;
 use differential_dataflow::operators::arrange::{Arranged, TraceAgent};
-use differential_dataflow::trace::implementations::chunker::ContainerChunker;
-use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
-use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
-use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
+use differential_dataflow::trace::chunk::{ChunkBatcher, ChunkBuilder};
 
 use corgi::arrange::gather;
 use corgi::Value as CValue;
 
 use crate::backend::Backend;
-use crate::corgi_chunk::{batch_to_rows, CorgiChunk, CorgiChunkBuilder};
+use crate::corgi_chunk::{chunks_to_columns, CorgiChunk, CorgiChunker};
 use crate::corgi_backend::CorgiContainer;
 use crate::corgi_join::CorgiJoinTactic;
 use crate::corgi_reduce::CorgiReduceTactic;
@@ -178,7 +175,10 @@ impl Backend for CorgiBackend {
     }
 
     fn arrange<'s>(c: Collection<'s, Time, CC>) -> Self::Arr<'s> {
-        arrange_core::<_, CC, ContainerChunker<Vec<Upd>>, MergeBatcher<VecMerger<(Row, Row), Time, Diff>>, RcBuilder<CorgiChunkBuilder<Time, Diff>>, CTrace>(
+        // Column-native ingest: `CorgiChunker` sort-consolidates each input `CorgiContainer`'s
+        // columns straight into a `CorgiChunk` (no drain-to-rows), then the standard chunk batcher +
+        // builder. No columns→rows→columns round-trip at the arrangement boundary.
+        arrange_core::<_, CC, CorgiChunker<Time, Diff>, ChunkBatcher<CorgiChunk<Time, Diff>>, ChunkBuilder<CorgiChunk<Time, Diff>>, CTrace>(
             c.inner,
             Pipeline,
             "CorgiArrange",
@@ -186,17 +186,19 @@ impl Backend for CorgiBackend {
     }
 
     fn as_collection<'s>(a: Self::Arr<'s>) -> Collection<'s, Time, CC> {
-        // Cursor-free: the arrangement's stream carries `Vec<Rc<CorgiBatch>>`; read each batch's
-        // updates (corgi columns → rows) and reassemble a corgi container of those updates.
+        // Cursor-free AND transcode-free: the arrangement's batches already hold corgi columns, so
+        // concatenate each batch's chunk columns straight into a `CorgiContainer` — no columns→rows→
+        // columns round-trip (the old `batch_to_rows` + `from_updates` path).
         a.stream
             .unary(Pipeline, "CorgiAsCollection", |_, _| {
                 |input, output| {
                     input.for_each(|cap, data| {
-                        let mut rows = Vec::new();
+                        let mut chunks: Vec<CorgiChunk<Time, Diff>> = Vec::new();
                         for batch in data.iter() {
-                            rows.extend(batch_to_rows(batch));
+                            chunks.extend(batch.chunks.iter().cloned());
                         }
-                        let mut c = CorgiContainer::from_updates(rows);
+                        let (keys, vals, times, diffs) = chunks_to_columns(&chunks);
+                        let mut c = CorgiContainer { keys, vals, times, diffs };
                         output.session(&cap).give_container(&mut c);
                     });
                 }
@@ -205,20 +207,11 @@ impl Backend for CorgiBackend {
     }
 
     fn join<'s>(l: Self::Arr<'s>, r: Self::Arr<'s>, projection: &Projection) -> Collection<'s, Time, CC> {
-        // The tactic compiles the projection per work-unit (shape-directed, for `Spread`).
+        // The tactic compiles the projection per work-unit (shape-directed, for `Spread`) and emits
+        // corgi columns directly into a `CorgiContainer` (via `give_container`) — the output stream is
+        // column-native, so there is no row round-trip / no `JoinToCorgi` unary.
         let tactic = CorgiJoinTactic::new(projection.key.clone(), projection.val.clone());
-        // join_with_tactic emits Vec-rows (via the output session); a ToCorgi unary rebuilds the
-        // corgi container at the operator output boundary.
-        let rows = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<Upd>>>(l, r, tactic);
-        rows.unary(Pipeline, "JoinToCorgi", |_, _| {
-            |input, output| {
-                input.for_each(|cap, data| {
-                    let mut c = CorgiContainer::from_updates(std::mem::take(data));
-                    output.session(&cap).give_container(&mut c);
-                });
-            }
-        })
-        .as_collection()
+        join_with_tactic::<_, _, _, CapacityContainerBuilder<CC>>(l, r, tactic).as_collection()
     }
 
     fn reduce<'s>(a: Self::Arr<'s>, reducer: &Reducer) -> Self::Arr<'s> {
diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index d84cef7a7..bbc348056 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -402,6 +402,13 @@ where
         Self::from_parts(keys, vals, times, diffs)
     }
 
+    /// One sorted+consolidated chunk from columns already in corgi form (the column-native arrange
+    /// ingest — no transcode, unlike `from_rows`).
+    pub fn from_columns(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
+        let (keys, vals, times, diffs) = sort_consolidate(keys, vals, times, diffs);
+        Self::from_parts(keys, vals, times, diffs)
+    }
+
     /// Untranscode this chunk back to DDIR rows (egress / history read).
     pub fn to_rows(&self) -> Vec<Upd<T, R>> {
         if self.len_() == 0 { return Vec::new(); }
@@ -428,6 +435,22 @@ where
     out
 }
 
+/// Concatenate chunks' columns into flat `(keys, vals, times, diffs)` with **no transcode** — for
+/// reading an arrangement back column-natively (e.g. `Backend::as_collection` straight into a
+/// `CorgiContainer`), instead of untranscoding to rows and re-transcoding.
+pub fn chunks_to_columns<T, R>(chunks: &[CorgiChunk<T, R>]) -> (CValue, CValue, Vec<T>, Vec<R>)
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    if chunks.iter().all(|c| c.len_() == 0) {
+        return (CValue::Unit(0), CValue::Unit(0), Vec::new(), Vec::new());
+    }
+    let (kv, times, diffs) = CorgiChunk::concat(chunks);
+    let (keys, vals) = split_kv(kv);
+    (keys, vals, times, diffs)
+}
+
 /// Build a `ChunkBatch<CorgiChunk>` from DDIR rows: transcode+sort+consolidate into one chunk, then
 /// `settle` it into a graded chunk sequence.
 fn rows_to_batch<T, R>(rows: Vec<Upd<T, R>>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
@@ -472,6 +495,103 @@ where
     }
 }
 
+/// A column-native arrange **chunker**: turns input `CorgiContainer`s into sorted+consolidated
+/// `CorgiChunk`s WITHOUT `ContainerChunker`'s drain-to-rows (which untranscodes). Paired with the
+/// standard `ChunkBatcher`/`ChunkBuilder`, the arrange ingest stays column-native — no
+/// columns→rows→columns round-trip at the arrangement boundary.
+///
+/// Crucially it **accumulates to `TARGET`** before consolidating (like `ContainerChunker`), so it
+/// emits few large chunks rather than one tiny chunk per input container — otherwise the columnar
+/// per-chunk set-up (`gather`/`sort_perm`) dominates when input arrives as many small batches.
+pub struct CorgiChunker<T, R> {
+    /// Un-consolidated key/val column blocks (one per absorbed container), flat time/diff.
+    k_blocks: Vec<CValue>,
+    v_blocks: Vec<CValue>,
+    times: Vec<T>,
+    diffs: Vec<R>,
+    ready: VecDeque<CorgiChunk<T, R>>,
+    current: Option<CorgiChunk<T, R>>,
+}
+
+impl<T, R> Default for CorgiChunker<T, R> {
+    fn default() -> Self {
+        CorgiChunker { k_blocks: Vec::new(), v_blocks: Vec::new(), times: Vec::new(), diffs: Vec::new(), ready: VecDeque::new(), current: None }
+    }
+}
+
+/// Concatenate column blocks into one column (multi-source `gather_lanes`, no sort).
+fn concat_blocks(blocks: &[CValue]) -> CValue {
+    if blocks.len() == 1 {
+        return blocks[0].clone();
+    }
+    let srcs: Vec<Option<&CValue>> = blocks.iter().map(Some).collect();
+    let (mut tags, mut offs) = (Vec::new(), Vec::new());
+    for (ti, b) in blocks.iter().enumerate() {
+        for o in 0..b.len() { tags.push(ti); offs.push(o); }
+    }
+    gather_lanes(&srcs, &tags, &offs)
+}
+
+impl<T, R> CorgiChunker<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    /// Consolidate the accumulated blocks into one graded chunk (concat columns, then sort+consolidate).
+    fn flush(&mut self) {
+        if self.times.is_empty() {
+            return;
+        }
+        let keys = concat_blocks(&self.k_blocks);
+        let vals = concat_blocks(&self.v_blocks);
+        self.k_blocks.clear();
+        self.v_blocks.clear();
+        let times = std::mem::take(&mut self.times);
+        let diffs = std::mem::take(&mut self.diffs);
+        let chunk = CorgiChunk::from_columns(keys, vals, times, diffs);
+        if chunk.len_() > 0 {
+            self.ready.push_back(chunk);
+        }
+    }
+}
+
+impl<T, R> timely::container::PushInto<&mut crate::corgi_backend::CorgiContainer<T, R>> for CorgiChunker<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    fn push_into(&mut self, c: &mut crate::corgi_backend::CorgiContainer<T, R>) {
+        if c.times.is_empty() {
+            return;
+        }
+        self.k_blocks.push(std::mem::replace(&mut c.keys, CValue::Unit(0)));
+        self.v_blocks.push(std::mem::replace(&mut c.vals, CValue::Unit(0)));
+        self.times.append(&mut c.times);
+        self.diffs.append(&mut c.diffs);
+        if self.times.len() >= TARGET {
+            self.flush();
+        }
+    }
+}
+
+impl<T, R> timely::container::ContainerBuilder for CorgiChunker<T, R>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    type Container = CorgiChunk<T, R>;
+    // `extract` ships ready chunks, leaving the sub-TARGET remainder to accumulate further.
+    fn extract(&mut self) -> Option<&mut Self::Container> {
+        self.current = self.ready.pop_front();
+        self.current.as_mut()
+    }
+    // `finish` also flushes the remainder (called until it returns None).
+    fn finish(&mut self) -> Option<&mut Self::Container> {
+        self.flush();
+        self.extract()
+    }
+}
+
 /// A single sorted+consolidated run over corgi columns — the join tactic's per-side input, produced
 /// by merging a batch list [`flatten_batches`]. Separate `keys`/`vals` columns so the merge-join can
 /// compare by key (`compare_at`) and `gather` matched runs.
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi_join.rs
index 7a233810e..2f25c6fa6 100644
--- a/interactive/src/corgi_join.rs
+++ b/interactive/src/corgi_join.rs
@@ -12,7 +12,6 @@
 use std::collections::VecDeque;
 use std::rc::Rc;
 
-use timely::container::PushInto;
 use timely::ContainerBuilder;
 use timely::dataflow::operators::generic::OutputBuilderSession;
 use timely::dataflow::operators::Capability;
@@ -26,12 +25,11 @@ use corgi::Value as CValue;
 
 use differential_dataflow::trace::chunk::ChunkBatch;
 
+use crate::corgi_backend::CorgiContainer;
 use crate::corgi_chunk::{flatten_batches, CorgiChunk};
-use crate::corgi_logic::{compile_join_projection, untranscode};
-use crate::ir::{Diff, Value as DValue};
+use crate::corgi_logic::compile_join_projection;
+use crate::ir::Diff;
 use crate::parse::Term;
-
-type Row = DValue;
 type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 
 /// A deferred bilinear join unit: a fresh batch list joined against the accumulated other side.
@@ -62,7 +60,7 @@ impl<T: Timestamp + Lattice> CorgiJoinTactic<T> {
 impl<T, CB> JoinTactic<CBatch<T>, CBatch<T>, CB> for CorgiJoinTactic<T>
 where
     T: Timestamp + Lattice,
-    CB: ContainerBuilder + PushInto<((Row, Row), T, Diff)>,
+    CB: ContainerBuilder<Container = CorgiContainer<T, Diff>>,
 {
     fn defer(&mut self, input0: Vec<CBatch<T>>, input1: Vec<CBatch<T>>, fresh: Fresh, capability: Capability<T>) {
         let unit = CorgiDeferred { left: input0, right: input1, capability };
@@ -90,7 +88,7 @@ where
 fn run_unit<T, CB>(unit: CorgiDeferred<T>, key: &Term, val: &Term, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>)
 where
     T: Timestamp + Lattice,
-    CB: ContainerBuilder + PushInto<((Row, Row), T, Diff)>,
+    CB: ContainerBuilder<Container = CorgiContainer<T, Diff>>,
 {
     let Some(left) = flatten_batches(&unit.left) else { return };
     let Some(right) = flatten_batches(&unit.right) else { return };
@@ -124,11 +122,8 @@ where
     let mut cols = projected.into_prod("corgi join projection");
     let nv = cols.pop().unwrap();
     let nk = cols.pop().unwrap();
-    let newkeys = untranscode(nk.clone(), &corgi::shape_of_value(&nk));
-    let newvals = untranscode(nv.clone(), &corgi::shape_of_value(&nv));
-
-    let mut session = output.session_with_builder(&unit.capability);
-    for x in 0..li.len() {
-        session.give(((newkeys[x].clone(), newvals[x].clone()), ot[x].clone(), od[x]));
-    }
+    // Emit the projection's corgi columns directly as a CorgiContainer via `give_container` — no
+    // untranscode-to-rows + re-transcode. The output stream is column-native.
+    let mut container = CorgiContainer { keys: nk, vals: nv, times: ot, diffs: od };
+    output.session_with_builder(&unit.capability).give_container(&mut container);
 }

From 1cf5dff07149c612fa34572ae8791b4d7ea1a5ef Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 20:28:16 -0400
Subject: [PATCH 13/68] interactive: columnar consolidate building block
 (proven, unit-tested)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

columnar_sum_by_key: the monoid Count/consolidate fold as pure corgi ops
(group → map(fold_add) → filter via parse_ml + eval_graph), no Value rows.
Signed diffs passed as raw two's-complement u64 bits; wrapping fold_add gives
the correct i64 sum, `ne 0` the sign-agnostic zero-drop. Unit test:
[(1,+1),(1,-1),(2,5),(3,9),(3,1)] -> [(2,5),(3,10)] (net-zero key dropped).

Groundwork for the wave-based columnar reduce; not yet wired into the live
reduce (which stays row-wise). Depends on corgi dd-arrange-api wrapping-Reduce.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce.rs | 41 +++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/interactive/src/corgi_reduce.rs b/interactive/src/corgi_reduce.rs
index c82a4a8ab..22ae428b1 100644
--- a/interactive/src/corgi_reduce.rs
+++ b/interactive/src/corgi_reduce.rs
@@ -30,12 +30,53 @@ use differential_dataflow::trace::Builder as _;
 use differential_dataflow::trace::Description;
 use differential_dataflow::trace::chunk::ChunkBatch;
 
+use corgi::{eval_graph, parse_ml, Bounds, Value as CValue};
+
 use crate::corgi_chunk::{batch_to_rows, CorgiChunk, CorgiChunkBuilder};
 use crate::ir::{Diff, Value as DValue};
 use crate::parse::Reducer;
 
 type Row = DValue;
 
+/// Columnar per-key sum — the monoid `Count`/consolidate fold as the value building block for a
+/// column-native reduce, driven entirely by corgi ops (`group → map(fold_add) → filter`), touching
+/// no `Value` rows. Diffs are passed as RAW two's-complement `u64` bits so `fold_add`'s wrapping add
+/// is the correct `i64` sum and `ne 0` is the sign-agnostic zero-drop (per the corgi note). Returns
+/// the surviving `(key column, per-key raw-bit sums)`. (Groundwork: the wave loop will call this
+/// across many keys at once; not yet wired into the live reduce.)
+#[allow(dead_code)]
+fn columnar_sum_by_key(keys: CValue, diffs_raw: CValue) -> (CValue, Vec<u64>) {
+    const ML: &str = "let acc = input group map ((k, vs) -> (k, vs fold_add)) in \
+                      let keep = acc map ((k, s) -> s ne 0) in \
+                      (acc, keep) filter";
+    let n = keys.len();
+    if n == 0 {
+        return (CValue::Unit(0), Vec::new());
+    }
+    let input = CValue::List(Bounds::Offsets(vec![n]), Box::new(CValue::Prod(vec![keys, diffs_raw])));
+    let graph = parse_ml(ML).expect("parse consolidate ML");
+    let out = eval_graph(&graph, input);
+    let (_bounds, vals) = out.into_list("consolidate output");
+    let (keys_out, sums) = vals.into_pair("consolidate (key, sum)");
+    (keys_out, sums.into_u64("consolidate sums"))
+}
+
+#[cfg(test)]
+mod consolidate_test {
+    use super::*;
+
+    #[test]
+    fn columnar_consolidate_sums_and_drops_zeros() {
+        // keys 1,1,2,3,3 with raw-bit diffs +1,-1,5,9,1 → key 1 nets 0 (dropped), 2→5, 3→10.
+        let keys = CValue::u64(vec![1, 1, 2, 3, 3]);
+        let diffs = CValue::u64(vec![1u64, (-1i64) as u64, 5, 9, 1]);
+        let (kout, sums) = columnar_sum_by_key(keys, diffs);
+        let ks = kout.into_u64("k");
+        let got: Vec<(u64, i64)> = ks.iter().zip(&sums).map(|(&k, &s)| (k, s as i64)).collect();
+        assert_eq!(got, vec![(2, 5), (3, 10)]);
+    }
+}
+
 /// Determines the active times for an interval `[lower, upper)` (Frank's definition).
 ///
 /// Active times are joins of input times (`novel` + `prior`) that are `>= lower` but not `>= upper`;

From 776d0a8cc457a44c7918559a12232c385a1dbd73 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 20:34:09 -0400
Subject: [PATCH 14/68] =?UTF-8?q?interactive:=20Count=20reduce=20fast-path?=
 =?UTF-8?q?=20=E2=80=94=20skip=20the=20unnecessary=20per-value=20consolida?=
 =?UTF-8?q?tion?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Count = Σ diffs ≤ t, and summing the consolidated per-value diffs equals summing
the raw diffs — so for Count the consolidate_vals (a Value sort + clones) is pure
waste. Sum diffs directly; no Value churn. reduce_count 1.39x→1.30x, all 6
programs match vec.

Distinct/Min still consolidate per value (they reason about individual values) —
that's the corgi two-level group→fold→filter path next; Collect stays row-wise.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce.rs | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/interactive/src/corgi_reduce.rs b/interactive/src/corgi_reduce.rs
index 22ae428b1..87739b302 100644
--- a/interactive/src/corgi_reduce.rs
+++ b/interactive/src/corgi_reduce.rs
@@ -263,16 +263,23 @@ where
             // Running output (committed output + deltas emitted this pass), accumulated as-of each t.
             let mut emitted: Vec<(Row, T, Diff)> = Vec::new();
             for t in active {
-                let in_acc = consolidate_vals(
-                    in_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect(),
-                );
+                // Count = Σ diffs ≤ t: summing the consolidated per-value diffs equals summing the raw
+                // diffs, so skip the per-value consolidation (and its Value sort/clones) entirely.
+                let desired = if matches!(self.reducer, Reducer::Count) {
+                    let c: Diff = in_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(_, _, d)| *d).sum();
+                    if c > 0 { vec![(DValue::Tuple(vec![DValue::Int(c)]), 1)] } else { Vec::new() }
+                } else {
+                    let in_acc = consolidate_vals(
+                        in_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect(),
+                    );
+                    reduce_logic(&self.reducer, &in_acc)
+                };
+
                 let mut cur: Vec<(Row, Diff)> =
                     out_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect();
                 cur.extend(emitted.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)));
                 let cur = consolidate_vals(cur);
 
-                let desired = reduce_logic(&self.reducer, &in_acc);
-
                 let mut delta: HashMap<Row, Diff> = HashMap::new();
                 for (v, d) in desired {
                     *delta.entry(v).or_insert(0) += d;

From 76b10200e7350caf62a5f410a47d23c883aa18e4 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 20:43:35 -0400
Subject: [PATCH 15/68] interactive: columnar Distinct consolidate building
 block (two-level, tested)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

columnar_distinct_keys: the keys with a present value (net diff != 0, the
nonzero simplification) as pure corgi ops — group by the (key,val) composite,
fold_add raw diffs, drop net-zero, distinct keys of survivors. group-by-(key,val)
is just group-by a projected composite; the nonzero test keeps everything on the
raw-bit `ne 0` path (no signed encoding needed yet). Unit test:
(1,10):+1,-1 → absent; (2,20),(2,21),(3,30) → present → keys [2,3].

Both monoid consolidate blocks now proven (sum for Count, two-level for
Distinct). Remaining: the wave integration (feed many keys per wave, driven by
the Rust time logic; reuse the existing delta/emit loop).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce.rs | 35 +++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/interactive/src/corgi_reduce.rs b/interactive/src/corgi_reduce.rs
index 87739b302..ebf575afc 100644
--- a/interactive/src/corgi_reduce.rs
+++ b/interactive/src/corgi_reduce.rs
@@ -61,10 +61,45 @@ fn columnar_sum_by_key(keys: CValue, diffs_raw: CValue) -> (CValue, Vec<u64>) {
     (keys_out, sums.into_u64("consolidate sums"))
 }
 
+/// Columnar `Distinct`: the keys with at least one **present** value, where "present" = net diff ≠ 0
+/// (the nonzero simplification — ignores the signed sign of the accumulation for now). Two-level
+/// consolidate over `(key, val)`: group by the `(key,val)` composite, `fold_add` the raw diffs, keep
+/// the nonzero, then take the distinct keys of the survivors. Returns the surviving key column.
+#[allow(dead_code)]
+fn columnar_distinct_keys(keys: CValue, vals: CValue, diffs_raw: CValue) -> CValue {
+    // input : List<((key,val), diff)> — group by the (key,val) composite, sum diffs, drop net-zero,
+    // re-key to (key, _), group by key → distinct present keys.
+    const ML: &str = "let net = input group map ((kv, ds) -> (kv, ds fold_add)) in \
+                      let keep = net map ((kv, s) -> s ne 0) in \
+                      let present = (net, keep) filter in \
+                      let rekey = present map ((kv, s) -> (kv.0, s)) in \
+                      rekey group map ((k, ss) -> k)";
+    let n = keys.len();
+    if n == 0 {
+        return CValue::Unit(0);
+    }
+    let composite = CValue::Prod(vec![keys, vals]);
+    let input = CValue::List(Bounds::Offsets(vec![n]), Box::new(CValue::Prod(vec![composite, diffs_raw])));
+    let out = eval_graph(&parse_ml(ML).expect("parse distinct ML"), input);
+    // out : List<key> — one row of the surviving keys.
+    let (_bounds, keys_out) = out.into_list("distinct output");
+    keys_out
+}
+
 #[cfg(test)]
 mod consolidate_test {
     use super::*;
 
+    #[test]
+    fn columnar_distinct_keeps_present_keys() {
+        // (1,10):+1,-1 → net 0 (absent); (2,20):+1, (2,21):+1 (present); (3,30):+1 (present).
+        let keys = CValue::u64(vec![1, 1, 2, 2, 3]);
+        let vals = CValue::u64(vec![10, 10, 20, 21, 30]);
+        let diffs = CValue::u64(vec![1u64, (-1i64) as u64, 1, 1, 1]);
+        let present = columnar_distinct_keys(keys, vals, diffs);
+        assert_eq!(present.into_u64("present"), vec![2, 3]);
+    }
+
     #[test]
     fn columnar_consolidate_sums_and_drops_zeros() {
         // keys 1,1,2,3,3 with raw-bit diffs +1,-1,5,9,1 → key 1 nets 0 (dropped), 2→5, 3→10.

From c64676a7b5fdbafdb2b4d1db3732f8aa9bc54262 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 20:56:05 -0400
Subject: [PATCH 16/68] =?UTF-8?q?interactive:=20group=5Foffsets=20?=
 =?UTF-8?q?=E2=80=94=20the=20integers-only=20Rust<->corgi=20boundary=20pri?=
 =?UTF-8?q?mitive?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Group a key column by identity, returning only integers: `perm` (row indices in
group order) + `ends` (per-group exclusive end within perm). DD walks groups by
index — group g is perm[ends[g-1]..ends[g]] — and drives its time/diff logic
without ever seeing a key Value; keys and payloads stay columnar in corgi. This
is the boundary model (corgi presents abstract int ids tied to times/diffs DD
sees; DD hands back indices to include). Built on sort_perm + one batched
compare_idx. Tested.

Foundation for the path-2 columnar reduce (wave loop over group ranges). Note:
cross-retire `pending` needs a STABLE key id (a u64 hash), since group indices
are per-retire — converges with hashed-keys-as-u64.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_chunk.rs | 44 ++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index bbc348056..7cf3866de 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -629,6 +629,34 @@ where
     Some(SortedRun { keys, vals, times, diffs })
 }
 
+/// Group a key column by identity, returning integers only — the Rust↔corgi boundary primitive.
+/// `perm` lists row indices in group order; `ends[g]` is the exclusive end of group `g` within `perm`
+/// (so group `g`'s member rows are `perm[ends[g-1]..ends[g]]`, with `ends[-1] = 0`). DD orchestrates
+/// per group by index — it never sees a key `Value`; keys and payloads stay columnar in corgi. Built
+/// on the columnar discrimination sort + one batched adjacent-compare (no per-pair `compare_at`).
+pub fn group_offsets(col: &CValue) -> (Vec<usize>, Vec<usize>) {
+    let n = col.len();
+    if n == 0 {
+        return (Vec::new(), Vec::new());
+    }
+    let perm = sort_perm(col);
+    let sorted = gather(col, &perm);
+    let mut ends = Vec::new();
+    if n > 1 {
+        let left: Vec<usize> = (0..n - 1).collect();
+        let right: Vec<usize> = (1..n).collect();
+        // adj[i] == 0 iff sorted[i] == sorted[i+1] — a group boundary is where adj[i] != 0.
+        let adj = compare_idx(&sorted, &sorted, &left, &right);
+        for (i, &a) in adj.iter().enumerate() {
+            if a != 0 {
+                ends.push(i + 1);
+            }
+        }
+    }
+    ends.push(n);
+    (perm, ends)
+}
+
 /// Semijoin: for each key in `needle_keys` (a set of DDIR keys), gather its `(val, time, diff)`
 /// history from `batches` via a batched `find` probe over the flattened, sorted source — untranscoding
 /// only the matched rows, never the whole trace. Returns a `key -> history` map (only matched keys
@@ -699,6 +727,22 @@ mod test {
 
     fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
 
+    #[test]
+    fn group_offsets_partitions_by_key() {
+        // keys 3,1,1,2,3 → groups key1={rows 1,2}, key2={row 3}, key3={rows 0,4}.
+        let col = CValue::u64(vec![3, 1, 1, 2, 3]);
+        let (perm, ends) = group_offsets(&col);
+        let mut groups: Vec<Vec<usize>> = Vec::new();
+        let mut start = 0;
+        for &e in &ends {
+            let mut g = perm[start..e].to_vec();
+            g.sort();
+            groups.push(g);
+            start = e;
+        }
+        assert_eq!(groups, vec![vec![1, 2], vec![3], vec![0, 4]]);
+    }
+
     /// Build a single sorted+consolidated CorgiChunk from u64 (key,val,time,diff) rows.
     fn chunk(rows: &[((u64, u64), u64, i64)]) -> CorgiChunk<u64, i64> {
         // Sort + consolidate by ((k,v),t) so a chunk is a legal sorted run.

From 87d3be02034f579d5c4a6eb76458070908a6ce18 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Thu, 2 Jul 2026 21:01:21 -0400
Subject: [PATCH 17/68] =?UTF-8?q?SPIKE.md:=202026-07-02=20checkpoint=20?=
 =?UTF-8?q?=E2=80=94=20Chunk=20backend,=20transcode=20removal,=20boundary?=
 =?UTF-8?q?=20model?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Records: arrange & join now BEAT vec (transcode boundaries removed); multi-record
primitives exposed; reduce consolidate blocks + group_offsets proven; and the
design capture for a data-blind reduce tactic (framework presents as int-id/
time/diff, owns time navigation; backend supplies id-mapping + value callback;
output ids are hashes — mint = hash the new value).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 SPIKE.md | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/SPIKE.md b/SPIKE.md
index 6e9d5de99..42e44d8ca 100644
--- a/SPIKE.md
+++ b/SPIKE.md
@@ -576,3 +576,78 @@ corgi-data CHUNK/container once the scalar-logic path exists.
 3. How rich a `Term` subset for real programs (datalog/eqsat need Variant/List/Fold/Hash)? (OPEN)
 4. Does it run inside a real DD dataflow, and does corgi-columnar storage actually remove the
    transcode in that setting? (rung 2 → rung 4)
+
+---
+
+## ★ CHUNK BACKEND + TRANSCODE REMOVAL + BOUNDARY MODEL (2026-07-02)
+
+Branch `corgi-chunk` off `master-next` (has #778 Chunk/NavigableChunk split). corgi on
+`dd-arrange-api`. Both pushed to frankmcsherry forks. Correctness gate: `corgi_progs` (all 6
+canonical programs vs `vec`) after EVERY change; `corgi_scorecard` = per-operator triage.
+
+### Result — measured, per operator (corgi/vec, scorecard)
+`CorgiChunk: Chunk` (cursor-less) is the arrangement; the fueled `ChunkBatchMerger` comes free.
+Removing the columns↔rows transcode boundaries (they were self-inflicted, not inherent):
+- `as_collection` reads chunk columns straight into a CorgiContainer (no untranscode).
+- join emits corgi columns via `give_container` into a `CapacityContainerBuilder<CorgiContainer>`
+  (no untranscode + per-row give + re-transcode; no `JoinToCorgi` unary).
+- arrange ingest: `CorgiChunker` sort-consolidates each input container's columns directly into
+  CorgiChunks (replacing `ContainerChunker`'s drain-to-rows), ACCUMULATING to TARGET so it emits
+  few large chunks (else columnar per-chunk set-up dominates on many small batches).
+
+| operator | before | after |
+|---|---|---|
+| map8 / filter (no arrange) | 0.30x / 0.75x | unchanged — columnar eval wins |
+| arrange | 1.5x | 0.90x (BEATS vec) |
+| join | 1.5x | 0.70x (BEATS vec) |
+| reduce_distinct/count | 2.0x | 1.30-1.35x (reduce still row-wise) |
+| reach | 1.9x | 1.45x |
+
+Thesis validated: vec spends ~22% of reach in `Value::cmp`/`partial_cmp` (pointer-chasing nested
+enums); corgi ~5% (columnar `compare_idx`). corgi beats vec wherever it stays columnar; it only
+loses where it drops back to `Value` rows — now just the reduce.
+
+### Multi-record primitives exposed in corgi `arrange` (dd-arrange-api)
+`sort_perm` (discrimination argsort), `compare_idx` (batched compare), `find_ranges` (single-row
+`find` = equal-range probe → multi-record merge-join/semijoin). Fixed a real corgi bug:
+`Reduce(Red::Add)` used checked `.sum()` while its Scan sibling wraps — made it wrapping so raw
+two's-complement diff sums are correct.
+
+### Reduce: proven building blocks, NOT yet wired (row-wise reduce still runs)
+- `columnar_sum_by_key` (Count) and `columnar_distinct_keys` (two-level (key,val) consolidate) —
+  pure corgi ML (`group -> map(fold_add) -> filter`) via `parse_ml`+`eval_graph`, tested.
+- Count fast-path landed (skip needless per-value consolidation): reduce_count 1.39x->1.30x.
+- Diffs cross as RAW two's-complement u64 bits (`ne 0` drop = sign-agnostic). "present" simplified
+  to net!=0 (ignore signed sign) -> keeps everything on the raw-bit path, no signed encoding yet.
+- `group_offsets(key_col) -> (perm, ends)` — integers-only boundary primitive, tested.
+
+### ★ DESIGN CAPTURE — a data-blind reduce tactic (the reusable DD asset)
+A framework that presents outward as (int-id, time, diff) can supply a reduce tactic that owns ALL
+the time navigation, backend-agnostic. Only integers cross the boundary; the value never becomes a
+`Value` in DD.
+
+Tactic (DD) owns — the hard part, written once: interesting-times (`active_times`), wave/interval
+navigation, per-(key,interesting-time) delta (desired vs current output), `pending`, held
+capabilities, output-trace maintenance — all over `(key-id: u64, val-id: u64, time: T, diff: R)`.
+
+Backend (corgi) supplies:
+1. present-as-ints (input): each record -> (key-id, val-id) as u64 hashes; times/diffs DD-native.
+2. value callback (consolidate): given input record indices (a key's rows <= t), return reduced
+   output as `[(out-val-id, diff)]` — backend runs its columnar value logic. Reducer semantics live
+   here. (`group_offsets` + `gather` + the consolidate blocks are the pieces.)
+3. mint output ids: Min/Distinct REUSE ids (min = an input val-id; distinct = the unit-id) — easy.
+   Count/Collect create NEW objects -> mint an id. HASHING is the id function: same output value ->
+   same id, globally consistent across the output->input boundary (a reduce output is a downstream
+   input). Collisions = accepted risk. This is why ids should be HASHES not per-batch indices —
+   indices are stable only within a batch; hashes are stable everywhere without a registry.
+4. materialize (egress): id -> value to build the output arrangement (or build it columnar by id).
+
+The one structural cost: cross-retire `pending` must be keyed by the stable hash-id, not a
+per-retire group index — this ripples through the delta logic, so the columnar reduce is a REDESIGN
+of `retire` into id/hash space, not a patch. Also carries the workload trade-off: columnar
+consolidate wins on wide/batch reduction but must PRESERVE the changed-key restriction (columnar
+semijoin) so small-delta recursion (reach) doesn't regress to O(accumulated x rounds).
+
+Next effort (well-scoped, primitives ready): rewrite `retire` in id/hash space — read changed keys'
+input as columns, `group_offsets` -> per-group `active_times` -> per (group,wave-time) hand corgi
+the include-index list -> consolidate -> delta/emit keyed by hash -> columnar output.

From f203d65da51bdb6760ba696ce61663b036f5da34 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 03:55:59 -0400
Subject: [PATCH 18/68] =?UTF-8?q?SPIKE.md:=20corgi-backend=20hand-off=20?=
 =?UTF-8?q?=E2=80=94=20int=5Fproxy=20framework=20(PR=20#781)=20consumption?=
 =?UTF-8?q?=20plan?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Branch rebased onto int-proxy: the framework the SPIKE's boundary model
called for now exists upstream (renamed ids -> int_proxy in review);
the old in-branch copy is dropped. The hand-off section documents the
current interfaces, the one-crossing-per-retire reduce_many contract,
the assessment harness to replicate, the reduce-first plan, the traps
already hit once (scan-presents, capacity leaks, giant-chunk settle),
and the suitability questions the corgi agent should answer.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 SPIKE.md | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/SPIKE.md b/SPIKE.md
index 42e44d8ca..194d21571 100644
--- a/SPIKE.md
+++ b/SPIKE.md
@@ -651,3 +651,77 @@ semijoin) so small-delta recursion (reach) doesn't regress to O(accumulated x ro
 Next effort (well-scoped, primitives ready): rewrite `retire` in id/hash space — read changed keys'
 input as columns, `group_offsets` -> per-group `active_times` -> per (group,wave-time) hand corgi
 the include-index list -> consolidate -> delta/emit keyed by hash -> columnar output.
+
+## ★ INT-PROXY FRAMEWORK LANDED UPSTREAM; CORGI-BACKEND HAND-OFF (2026-07-03)
+
+The boundary model above is now a complete, tested framework in the DD crate — PR #781
+(`frankmcsherry/differential-dataflow@int-proxy`, ~3k lines, unmerged/settling; this branch is
+rebased onto it). It is corgi-free by construction; corgi is its first real backend. READ ORDER:
+`operators/int_proxy/mod.rs` (the boundary contract + design notes), then `reduce.rs` / `join.rs`
+(backend traits + tactics), `reference.rs` (the in-memory backend to mimic), `trace/chunk/
+int_proxy.rs` (ProxyChunk), `tests/int_proxy.rs` (the assessment harness).
+
+### What the framework is (names changed from the earlier note: ids -> int_proxy, Id* -> Proxy*)
+- `ProxyChunk<T,R>`: sorted, consolidated `((key_hash, value_id), time, diff)` columns; a #778
+  `Chunk` (not Navigable). `from_unsorted` = int sort+consolidate returning REPRESENTATIVE
+  PROVENANCE (sorted-run index -> original record) — the alignment a backend keeps.
+- `ProxyReduceBackend` (reduce.rs): `key_hashes` (delta scan), `present_input(history, novel,
+  changed-keys filter)`, `present_output(batches, filter)`, `reduce`/`reduce_many`, `materialize`.
+  The tactic makes ONE `reduce_many` crossing PER RETIRE: every `(key, interesting time)` moment is
+  a bracket (group_offsets-shaped `ends`; keys repeat, one bracket per moment; brackets non-empty).
+  Desired outputs depend only on input accumulations, so no time ordering constrains the batch —
+  the order-sensitive delta bookkeeping stays in the tactic. THIS is corgi's crossing: override
+  `reduce_many`, run the columnar consolidate blocks over all brackets at once.
+- `ProxyJoinBackend` (join.rs): `present0/present1(batches, filter)` + `cross(matched index
+  lists, times, diffs)`. The tactic presents the FRESH side first and passes its key hashes as the
+  accumulated side's filter — the join analogue of the changed-key restriction (interface-level;
+  without it any backend is forced O(trace) per fresh batch).
+- Contracts: `key_hash` = stable pure function of the key, backend-wide (pending + changed-key
+  filter + join sides rely on it). `value_id` = per-computation bijection with value equality ONLY
+  (never outlives a join unit / one retire; `materialize` resolves ids before anything escapes).
+  Hashing is one scheme, not a requirement — exact per-retire registries are collision-free and
+  valid. corgi: `corgi::hash` (#6, on master; WIDTH-BLIND unsigned — keep signed/float widths
+  consistent across join inputs and output→input) serves both, or exact ids via `group_offsets`.
+- The tactics carry the row operators' history-replay machinery in id space (`history.rs`:
+  IdHistory = ValueHistory with u64 values; reduce discovery ports `history_replay::compute`;
+  join ports `JoinThinker::think`) — the row suite's `reduce_scaling`/`join_scaling` shapes are
+  linear (tests `proxy_*_scaling` pin it). Interesting-time discovery is LAZY now (no explicit
+  `active_times` closure).
+
+### Assessment harness to reuse (tests/int_proxy.rs) — corgi should replicate the middle layer
+1. Tactic alone: identity backend + 300-case Product-grid brute-force oracle (no values, no hash).
+2. Backend contract: reference backend vs the ROW operators (join; count/distinct/min reduces;
+   scripted Product-time pending test) — the corgi backend replaces this layer 1:1.
+3. Asymptotics: counting-wrapper gates (presented records must be delta-proportional; single-key
+   rounds vs a 20k-key trace) + scaling shapes + the `--ignored` wall-clock bench (steady state:
+   reduce ~1.4x row, join ~1.0x; bulk load 2-4.5x = the per-row presentation constants corgi's
+   columnar primitives exist to beat).
+
+### The corgi backend plan (reduce first; keep CorgiJoinTactic — it already beats vec)
+- `present_input/present_output`: flatten via existing `merge_chains`/`flatten_batches` machinery
+  restricted to changed keys by `find_ranges` SEMIJOIN (never scan-and-filter: the reference
+  backend's seek-based presents are the model; a scan re-imports O(trace) per retire), then
+  `corgi::hash` the key/val columns, `ProxyChunk::from_unsorted`, keep the reps vec + gathered
+  real columns as alignment.
+- `reduce_many` override: ONE crossing — gather the brackets' value rows by rep index
+  (`gather_lanes`), run the columnar consolidate/Count/Distinct blocks across all brackets
+  (`group_offsets` shape matches `ends` by design), mint output ids by `corgi::hash` of the
+  produced column, record id→value.
+- `materialize`: build output key/val columns from id→value, order by corgi structural order
+  (`sort_perm`), emit CorgiChunk batches in TARGET-SIZED chunks (a single giant chunk makes
+  `settle`'s split path quadratic — reference.rs learned this the hard way; also consider fixing
+  `VecChunk::settle`'s split upstream).
+- Swap `CorgiReduceTactic` -> `ProxyReduceTactic<corgi backend>`; delete the row-wise retire.
+- Traps already hit once, don't repeat: capacity leaks in per-retire maps (shrink or rebuild —
+  `retain`/`clear` keep the table); presenting by scan instead of seek; giant-chunk settle.
+- Gate `cargo run --release -p interactive --example corgi_progs` after EVERY change (scc is the
+  sharp case; the empty-frontier downgrade is already in the tactic). `corgi_scorecard` for the
+  perf verdict: the target is closing reduce's 1.3x vs vec.
+
+### Suitability review (the point of the hand-off): confirm or disconfirm, from corgi's seat
+- Does `present` map cheaply onto corgi columns (hash op + find_ranges + gather + from_unsorted)?
+- Does the `reduce_many` bracket shape line up with `group_offsets`/the consolidate ML blocks?
+- Is the per-record `(rep, diff)` entry list the right currency, or does corgi want columnar
+  (vid-run) brackets? Interface pressure flows back to #781 as evidence, not as corgi types.
+- Diffs cross as DD-native `R` here (not raw u64 bits) — reconcile with the raw-bits convention
+  inside corgi's blocks at corgi's own boundary.

From 2937da36bc73453f8d29a36d3ca78a7c62843db9 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 06:34:25 -0400
Subject: [PATCH 19/68] corgi ProxyReduceBackend: columnar reduce over int
 proxies

Implement ProxyReduceBackend for corgi and swap CorgiReduceTactic ->
ProxyReduceTactic. The DD tactic owns all time/lattice logic over
(key_hash, value_id, time, diff); the corgi backend supplies only:
 - hashing: key_hash/value_id via corgi::arrange::hash_rows over the corgi
   key/val COLUMNS (columnar, content-addressed; DD never hashes).
 - reduce_many: ONE crossing per retire over every (key,time) bracket.
   Count/Distinct are integer-only (no value untranscode); Min/Collect
   gather+untranscode the bracket values once, never per key. Output ids
   minted by hashing the produced value column (agrees with present_output).
 - present_input/present_output: read arrangement chunks, restrict to changed
   keys by columnar semijoin (novel whole, history filtered); delta-proportional.
 - materialize: resolve ids -> real (key,val) rows, seal a CorgiChunk batch.

corgi_progs: all 6 match vec (scc min/recursion + unnest collect included).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs        |   5 +-
 interactive/src/corgi_reduce_backend.rs | 282 ++++++++++++++++++++++++
 interactive/src/lib.rs                  |   1 +
 3 files changed, 286 insertions(+), 2 deletions(-)
 create mode 100644 interactive/src/corgi_reduce_backend.rs

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index 7fe5c738c..82d40e1df 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -26,7 +26,8 @@ use crate::backend::Backend;
 use crate::corgi_chunk::{chunks_to_columns, CorgiChunk, CorgiChunker};
 use crate::corgi_backend::CorgiContainer;
 use crate::corgi_join::CorgiJoinTactic;
-use crate::corgi_reduce::CorgiReduceTactic;
+use crate::corgi_reduce_backend::CorgiReduceBackend;
+use differential_dataflow::operators::int_proxy::ProxyReduceTactic;
 use crate::corgi_logic::{compilable, compile_predicate, compile_projection};
 use crate::ir::{Diff, LinearOp, Time, Value as DValue};
 use crate::parse::{Projection, Reducer};
@@ -215,7 +216,7 @@ impl Backend for CorgiBackend {
     }
 
     fn reduce<'s>(a: Self::Arr<'s>, reducer: &Reducer) -> Self::Arr<'s> {
-        reduce_with_tactic::<_, CTrace, _>(a, "CorgiReduce", CorgiReduceTactic::new(reducer.clone()))
+        reduce_with_tactic::<_, CTrace, _>(a, "CorgiReduce", ProxyReduceTactic::new(CorgiReduceBackend::new(reducer.clone())))
     }
 
     fn inspect<'s>(c: Collection<'s, Time, CC>, label: String) -> Collection<'s, Time, CC> {
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
new file mode 100644
index 000000000..5c97f8443
--- /dev/null
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -0,0 +1,282 @@
+//! The corgi `ProxyReduceBackend`: the value semantics for the DD `ProxyReduceTactic`.
+//!
+//! The tactic (differential's `operators::int_proxy::reduce`) owns ALL time/lattice logic over
+//! integer proxies `(key_hash, value_id, time, diff)`; this backend supplies only:
+//!
+//!   * hashing — `key_hash`/`value_id` are corgi `hash_rows` over the corgi key/val COLUMNS
+//!     (columnar, content-addressed, so ids coincide across the output→input boundary); DD never
+//!     hashes.
+//!   * the value callback — `reduce_many` runs ONE crossing per retire over every `(key, time)`
+//!     bracket (Count/Distinct are integer-only; Min/Collect gather+untranscode the needed values
+//!     once, never once per key), then mints output ids by hashing the produced value column.
+//!   * materialize — resolve ids back to real `(key, val)` rows and seal a `CorgiChunk` batch.
+//!
+//! The changed-key restriction is honored by presenting only the changed keys: novel batches are
+//! read whole (delta-sized), the accumulated history is scanned and filtered to the changed hashes
+//! (a columnar semijoin — matching the row-wise tactic's read; a `find`-seek was measured slower).
+
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use timely::progress::Timestamp;
+
+use differential_dataflow::lattice::Lattice;
+use differential_dataflow::trace::Builder as _;
+use differential_dataflow::trace::Description;
+use differential_dataflow::trace::chunk::ChunkBatch;
+use differential_dataflow::trace::chunk::int_proxy::ProxyChunk;
+use differential_dataflow::operators::int_proxy::ProxyReduceBackend;
+
+use corgi::arrange::{gather, gather_lanes, hash_rows};
+use corgi::Value as CValue;
+
+use crate::corgi_chunk::{CorgiChunk, CorgiChunkBuilder};
+use crate::corgi_logic::{infer_shape_cols, transcode, untranscode};
+use crate::ir::{Diff, Value as DValue};
+use crate::parse::Reducer;
+
+type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
+
+/// A corgi reduce backend for a single `Reducer`. Per-retire scratch (`in_vals`, `out_vals`) is set
+/// by the presentations and read by `reduce_many`/`materialize`; `keys` persists changed keys'
+/// `key_hash → key` across retires (so pending keys survive without touching backend state).
+pub struct CorgiReduceBackend<T> {
+    reducer: Reducer,
+    /// `key_hash → key row` for the changed keys: primed from each retire's novel batches, pruned to
+    /// the changed set on entry (so pending keys survive between retires and nothing else accretes).
+    keys: HashMap<u64, DValue>,
+    /// Val column aligned with the current input presentation's records (rep rows), for Min/Collect.
+    in_vals: CValue,
+    /// `value_id → output value` for the current retire: primed by `present_output`, extended by
+    /// minting in `reduce_many`; rebuilt fresh each retire.
+    out_vals: HashMap<u64, DValue>,
+    _t: std::marker::PhantomData<T>,
+}
+
+impl<T> CorgiReduceBackend<T> {
+    pub fn new(reducer: Reducer) -> Self {
+        CorgiReduceBackend {
+            reducer,
+            keys: HashMap::new(),
+            in_vals: CValue::Unit(0),
+            out_vals: HashMap::new(),
+            _t: std::marker::PhantomData,
+        }
+    }
+}
+
+/// Concatenate selected records across a run of chunks into parallel `(keys_col, vals_col)` corgi
+/// columns plus per-record `(key_hash, time, diff)`. `keep(kh)` decides inclusion by key hash.
+fn collect_present<T, F>(chunks: &[&CorgiChunk<T, Diff>], mut keep: F) -> (CValue, CValue, Vec<u64>, Vec<T>, Vec<Diff>)
+where
+    T: Timestamp + Lattice,
+    F: FnMut(u64) -> bool,
+{
+    let key_srcs: Vec<Option<&CValue>> = chunks.iter().map(|c| Some(c.keys())).collect();
+    let val_srcs: Vec<Option<&CValue>> = chunks.iter().map(|c| Some(c.vals())).collect();
+    let (mut tags, mut offs) = (Vec::new(), Vec::new());
+    let (mut khs, mut times, mut diffs) = (Vec::new(), Vec::new(), Vec::new());
+    for (ci, ch) in chunks.iter().enumerate() {
+        let kh = hash_rows(ch.keys());
+        for i in 0..kh.len() {
+            if keep(kh[i]) {
+                tags.push(ci);
+                offs.push(i);
+                khs.push(kh[i]);
+                times.push(ch.times()[i].clone());
+                diffs.push(ch.diffs()[i]);
+            }
+        }
+    }
+    if tags.is_empty() {
+        return (CValue::Unit(0), CValue::Unit(0), khs, times, diffs);
+    }
+    let keys_col = gather_lanes(&key_srcs, &tags, &offs);
+    let vals_col = gather_lanes(&val_srcs, &tags, &offs);
+    (keys_col, vals_col, khs, times, diffs)
+}
+
+/// All chunks of a batch list, flattened (empty chunks included — `hash_rows` yields nothing for them).
+fn chunks_of<T>(batches: &[CBatch<T>]) -> Vec<&CorgiChunk<T, Diff>>
+where
+    T: Timestamp + Lattice,
+{
+    batches.iter().flat_map(|b| b.chunks.iter()).collect()
+}
+
+impl<T> CorgiReduceBackend<T>
+where
+    T: Timestamp + Lattice + Ord,
+{
+    /// The one value crossing for a retire: every `(key, time)` bracket at once. Count/Distinct read
+    /// only diffs; Min/Collect gather+untranscode the bracket values ONCE (not per key). Output ids
+    /// are minted by hashing the produced value column (one `hash_rows`), agreeing with
+    /// `present_output` on equal values.
+    fn reduce_brackets(&mut self, ends: &[usize], input: &[(usize, Diff)]) -> (Vec<(u64, Diff)>, Vec<usize>) {
+        // Values are only needed for the order/content-sensitive reducers.
+        let need_vals = matches!(self.reducer, Reducer::Min | Reducer::Collect);
+        let vals_rows: Vec<DValue> = if need_vals && !input.is_empty() {
+            let idx: Vec<usize> = input.iter().map(|&(i, _)| i).collect();
+            let g = gather(&self.in_vals, &idx);
+            untranscode(g.clone(), &corgi::shape_of_value(&g))
+        } else {
+            Vec::new()
+        };
+
+        let mut produced: Vec<(DValue, Diff)> = Vec::new();
+        let mut out_ends = Vec::with_capacity(ends.len());
+        let mut start = 0;
+        for &end in ends {
+            match self.reducer {
+                Reducer::Count => {
+                    let c: Diff = input[start..end].iter().map(|&(_, d)| d).sum();
+                    if c > 0 {
+                        produced.push((DValue::Tuple(vec![DValue::Int(c)]), 1));
+                    }
+                }
+                Reducer::Distinct => {
+                    if input[start..end].iter().any(|&(_, d)| d > 0) {
+                        produced.push((DValue::unit(), 1));
+                    }
+                }
+                Reducer::Min => {
+                    let m = (start..end)
+                        .filter(|&k| input[k].1 > 0)
+                        .map(|k| &vals_rows[k])
+                        .min();
+                    if let Some(m) = m {
+                        produced.push((m.clone(), 1));
+                    }
+                }
+                Reducer::Collect => {
+                    // The reducer contract presents values in `Ord` order; the bracket is in
+                    // value-id (hash) order, so sort by value first — the List's element order
+                    // is value-significant (unlike Min/Count/Distinct).
+                    let mut order: Vec<usize> = (start..end).collect();
+                    order.sort_by(|&a, &b| vals_rows[a].cmp(&vals_rows[b]));
+                    let mut items = Vec::new();
+                    for k in order {
+                        for _ in 0..input[k].1.max(0) {
+                            items.push(vals_rows[k].clone());
+                        }
+                    }
+                    produced.push((DValue::List(items), 1));
+                }
+            }
+            out_ends.push(produced.len());
+            start = end;
+        }
+
+        // Mint output ids: hash the produced value column columnar, and record id → value.
+        if produced.is_empty() {
+            return (Vec::new(), out_ends);
+        }
+        let vrows: Vec<DValue> = produced.iter().map(|(v, _)| v.clone()).collect();
+        let col = transcode(&vrows, &infer_shape_cols(&vrows));
+        let ids = hash_rows(&col);
+        for (&id, (v, _)) in ids.iter().zip(&produced) {
+            self.out_vals.entry(id).or_insert_with(|| v.clone());
+        }
+        let outs = ids.into_iter().zip(produced).map(|(id, (_, d))| (id, d)).collect();
+        (outs, out_ends)
+    }
+}
+
+impl<T> ProxyReduceBackend<CBatch<T>, CBatch<T>> for CorgiReduceBackend<T>
+where
+    T: Timestamp + Lattice + Ord,
+{
+    type RIn = Diff;
+    type ROut = Diff;
+
+    fn key_hashes(&self, batches: &[CBatch<T>]) -> Vec<u64> {
+        let mut hashes = Vec::new();
+        for ch in chunks_of(batches) {
+            hashes.extend(hash_rows(ch.keys()));
+        }
+        hashes.sort_unstable();
+        hashes.dedup();
+        hashes
+    }
+
+    fn present_input(&mut self, history: &[CBatch<T>], novel: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
+        // Prune hash→key to the changed set (what survives = the pending keys), and shrink so a past
+        // big retire's table doesn't tax later walks.
+        self.keys.retain(|h, _| keys.binary_search(h).is_ok());
+        self.keys.shrink_to_fit();
+
+        // Prime the map from the novel batches (delta-sized, all keys changed): untranscode their key
+        // columns once and record hash → key.
+        for ch in chunks_of(novel) {
+            if ch.keys().len() == 0 {
+                continue;
+            }
+            let kh = hash_rows(ch.keys());
+            let krows = untranscode(ch.keys().clone(), &corgi::shape_of_value(ch.keys()));
+            for (h, k) in kh.into_iter().zip(krows) {
+                self.keys.entry(h).or_insert(k);
+            }
+        }
+
+        // Read novel whole + history filtered to the changed keys (columnar semijoin).
+        let mut chunks = chunks_of(novel);
+        chunks.extend(chunks_of(history));
+        let novel_len: usize = chunks_of(novel).iter().map(|c| c.keys().len()).sum();
+        let mut seen = 0usize;
+        let (_keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| {
+            let keep = seen < novel_len || keys.binary_search(&h).is_ok();
+            seen += 1;
+            keep
+        });
+        // NB: `seen` advances per candidate record in chunk order; novel chunks come first, so the
+        // first `novel_len` records are the (unfiltered) novel side and the rest is history.
+
+        if khs.is_empty() {
+            self.in_vals = CValue::Unit(0);
+            return ProxyChunk::default();
+        }
+        let vids = hash_rows(&vals_col);
+        let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
+        self.in_vals = gather(&vals_col, &reps);
+        chunk
+    }
+
+    fn present_output(&mut self, batches: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
+        self.out_vals = HashMap::new();
+        let chunks = chunks_of(batches);
+        let (_keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| keys.binary_search(&h).is_ok());
+        if khs.is_empty() {
+            return ProxyChunk::default();
+        }
+        let vids = hash_rows(&vals_col);
+        let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
+        // Record value_id → output value for materialize (representative rows, by the reps).
+        let rep_vals = gather(&vals_col, &reps);
+        let vrows = untranscode(rep_vals, &corgi::shape_of_value(&vals_col));
+        for (i, v) in vrows.into_iter().enumerate() {
+            self.out_vals.entry(chunk.value_ids()[i]).or_insert(v);
+        }
+        chunk
+    }
+
+    fn reduce(&mut self, _key_hash: u64, input: &[(usize, Diff)]) -> Vec<(u64, Diff)> {
+        self.reduce_brackets(&[input.len()], input).0
+    }
+
+    fn reduce_many(&mut self, _keys: &[u64], ends: &[usize], input: &[(usize, Diff)]) -> (Vec<(u64, Diff)>, Vec<usize>) {
+        self.reduce_brackets(ends, input)
+    }
+
+    fn materialize(&mut self, records: ProxyChunk<T, Diff>, description: Description<T>) -> CBatch<T> {
+        let mut rows: Vec<((DValue, DValue), T, Diff)> = (0..records.len())
+            .map(|i| {
+                let k = self.keys.get(&records.key_hashes()[i]).expect("key presented this retire").clone();
+                let v = self.out_vals.get(&records.value_ids()[i]).expect("value presented or minted this retire").clone();
+                ((k, v), records.times()[i].clone(), records.diffs()[i])
+            })
+            .collect();
+        let mut builder = CorgiChunkBuilder::<T, Diff>::with_capacity(0, 0, rows.len());
+        builder.push(&mut rows);
+        Rc::new(builder.done(description))
+    }
+}
diff --git a/interactive/src/lib.rs b/interactive/src/lib.rs
index 8258e932a..4764a17cf 100644
--- a/interactive/src/lib.rs
+++ b/interactive/src/lib.rs
@@ -6,6 +6,7 @@ pub mod corgi_arrange;
 pub mod corgi_chunk;
 pub mod corgi_join;
 pub mod corgi_reduce;
+pub mod corgi_reduce_backend;
 pub mod lower;
 pub mod scope_ir;
 pub mod backend;

From 25b477e18c98a8eaa5b7c8a9e6ee79a4f7bf9433 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 06:49:06 -0400
Subject: [PATCH 20/68] =?UTF-8?q?corgi=20reduce:=20burn=20the=20transcode?=
 =?UTF-8?q?=20=E2=80=94=20fully=20columnar=20id=20resolution?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the DValue resolution maps (HashMap<u64,DValue>) with corgi COLUMN
pools + integer id->row-index maps. The real keys/values never leave corgi
columns:
 - present_input/output register representative key/val columns into per-retire
   pools (key_index/val_index -> offsets into concatenated blocks), no untranscode.
 - reduce_many builds each reducer's output value COLUMN directly: Count -> u64
   prim, Distinct -> Unit, Min -> gathered input rows (id reused from input),
   Collect -> List. Ids minted by hash_rows over the built column. No transcode.
 - materialize resolves proxy ids to columns by gather + columns_to_batch
   (new corgi_chunk helper), column-native egress (no from_rows transcode).

The only residual untranscode is Min/Collect's value ORDERING (the reduction
contract is DDIR Ord, which is not corgi's structural order); the chosen rows
are still taken columnar.

Scorecard corgi/vec: reduce_distinct 1.01x -> 0.92-0.96x (BEATS vec),
reduce_count 1.03x -> 0.90-0.93x (BEATS vec), reach 1.10-1.22x -> 1.06-1.13x.
corgi_progs: all 6 match vec; interactive lib tests green (36).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_chunk.rs          |  21 ++
 interactive/src/corgi_reduce_backend.rs | 311 +++++++++++++++---------
 2 files changed, 221 insertions(+), 111 deletions(-)

diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index 7cf3866de..43bb415e8 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -459,6 +459,27 @@ where
     R: Semigroup + Clone + 'static,
 {
     let chunk = CorgiChunk::from_rows(&rows);
+    settle_one(chunk, description)
+}
+
+/// Build a `ChunkBatch<CorgiChunk>` from corgi key/val COLUMNS directly (no transcode): sort +
+/// consolidate into one chunk, then `settle`. The column-native egress the reduce backend seals its
+/// output with (it resolves proxy ids to real columns by `gather` and hands them here).
+pub fn columns_to_batch<T, R>(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let chunk = CorgiChunk::from_columns(keys, vals, times, diffs);
+    settle_one(chunk, description)
+}
+
+/// Grade one chunk into a `ChunkBatch` (shared tail of `rows_to_batch`/`columns_to_batch`).
+fn settle_one<T, R>(chunk: CorgiChunk<T, R>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
     let mut input = VecDeque::new();
     if chunk.len_() > 0 { input.push_back(chunk); }
     let mut output = VecDeque::new();
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 5c97f8443..36670fc03 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -7,13 +7,21 @@
 //!     (columnar, content-addressed, so ids coincide across the output→input boundary); DD never
 //!     hashes.
 //!   * the value callback — `reduce_many` runs ONE crossing per retire over every `(key, time)`
-//!     bracket (Count/Distinct are integer-only; Min/Collect gather+untranscode the needed values
-//!     once, never once per key), then mints output ids by hashing the produced value column.
-//!   * materialize — resolve ids back to real `(key, val)` rows and seal a `CorgiChunk` batch.
+//!     bracket, building the output value COLUMNS directly (Count → a `u64` prim, Distinct → a
+//!     `Unit`, Min → the chosen input rows, Collect → a `List`), never through DDIR rows.
+//!   * materialize — resolve proxy ids back to real columns by `gather` from per-retire pools and
+//!     seal a `CorgiChunk` batch column-natively.
+//!
+//! Transcode-free: the real keys/values never leave corgi columns. Ids are resolved to rows by
+//! integer index (`key_index`/`val_index` → offsets into the concatenated `key_blocks`/`val_blocks`
+//! pools), not by carrying `DValue`s. The one residual untranscode is Min/Collect's *ordering* of a
+//! bracket's few candidate values — the reduction contract is DDIR `Ord`, which is not corgi's
+//! structural order (unsigned/­kind-blind), so the semantic order is recovered per bracket; the
+//! chosen value ROWS are still taken columnar (`gather`), never rebuilt.
 //!
 //! The changed-key restriction is honored by presenting only the changed keys: novel batches are
 //! read whole (delta-sized), the accumulated history is scanned and filtered to the changed hashes
-//! (a columnar semijoin — matching the row-wise tactic's read; a `find`-seek was measured slower).
+//! (a columnar semijoin — matching the row-wise tactic's read).
 
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -21,35 +29,39 @@ use std::rc::Rc;
 use timely::progress::Timestamp;
 
 use differential_dataflow::lattice::Lattice;
-use differential_dataflow::trace::Builder as _;
 use differential_dataflow::trace::Description;
 use differential_dataflow::trace::chunk::ChunkBatch;
 use differential_dataflow::trace::chunk::int_proxy::ProxyChunk;
 use differential_dataflow::operators::int_proxy::ProxyReduceBackend;
 
 use corgi::arrange::{gather, gather_lanes, hash_rows};
-use corgi::Value as CValue;
+use corgi::{Bounds, Value as CValue};
 
-use crate::corgi_chunk::{CorgiChunk, CorgiChunkBuilder};
-use crate::corgi_logic::{infer_shape_cols, transcode, untranscode};
-use crate::ir::{Diff, Value as DValue};
+use crate::corgi_chunk::{columns_to_batch, CorgiChunk};
+use crate::corgi_logic::untranscode;
+use crate::ir::Diff;
 use crate::parse::Reducer;
 
 type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 
-/// A corgi reduce backend for a single `Reducer`. Per-retire scratch (`in_vals`, `out_vals`) is set
-/// by the presentations and read by `reduce_many`/`materialize`; `keys` persists changed keys'
-/// `key_hash → key` across retires (so pending keys survive without touching backend state).
+/// A corgi reduce backend for a single `Reducer`. All per-retire scratch is corgi columns + integer
+/// id→row-index maps; nothing carries a `DValue`.
 pub struct CorgiReduceBackend<T> {
     reducer: Reducer,
-    /// `key_hash → key row` for the changed keys: primed from each retire's novel batches, pruned to
-    /// the changed set on entry (so pending keys survive between retires and nothing else accretes).
-    keys: HashMap<u64, DValue>,
-    /// Val column aligned with the current input presentation's records (rep rows), for Min/Collect.
+    /// Input value column aligned with the current input presentation's records (for Min/Collect).
     in_vals: CValue,
-    /// `value_id → output value` for the current retire: primed by `present_output`, extended by
-    /// minting in `reduce_many`; rebuilt fresh each retire.
-    out_vals: HashMap<u64, DValue>,
+    /// The input presentation's `value_id` per record (Min reuses an input value's id).
+    in_value_ids: Vec<u64>,
+    /// Key-resolution pool for the current retire: `key_hash → row index` into the concatenation of
+    /// `key_blocks` (representative keys from the input + output presentations).
+    key_index: HashMap<u64, usize>,
+    key_blocks: Vec<CValue>,
+    key_len: usize,
+    /// Value-resolution pool for the current retire: `value_id → row index` into the concatenation of
+    /// `val_blocks` (output-history values + values minted by `reduce_many`).
+    val_index: HashMap<u64, usize>,
+    val_blocks: Vec<CValue>,
+    val_len: usize,
     _t: std::marker::PhantomData<T>,
 }
 
@@ -57,12 +69,66 @@ impl<T> CorgiReduceBackend<T> {
     pub fn new(reducer: Reducer) -> Self {
         CorgiReduceBackend {
             reducer,
-            keys: HashMap::new(),
             in_vals: CValue::Unit(0),
-            out_vals: HashMap::new(),
+            in_value_ids: Vec::new(),
+            key_index: HashMap::new(),
+            key_blocks: Vec::new(),
+            key_len: 0,
+            val_index: HashMap::new(),
+            val_blocks: Vec::new(),
+            val_len: 0,
             _t: std::marker::PhantomData,
         }
     }
+
+    /// Clear the resolution pools at the start of a retire.
+    fn reset_pools(&mut self) {
+        self.key_index.clear();
+        self.key_blocks.clear();
+        self.key_len = 0;
+        self.val_index.clear();
+        self.val_blocks.clear();
+        self.val_len = 0;
+    }
+
+    /// Add representative key rows (aligned with `ids`) to the key pool; first id wins.
+    fn register_keys(&mut self, col: CValue, ids: &[u64]) {
+        for (i, &id) in ids.iter().enumerate() {
+            self.key_index.entry(id).or_insert(self.key_len + i);
+        }
+        self.key_len += col.len();
+        self.key_blocks.push(col);
+    }
+
+    /// Add value rows (aligned with `ids`) to the val pool; first id wins.
+    fn register_vals(&mut self, col: CValue, ids: &[u64]) {
+        for (i, &id) in ids.iter().enumerate() {
+            self.val_index.entry(id).or_insert(self.val_len + i);
+        }
+        self.val_len += col.len();
+        self.val_blocks.push(col);
+    }
+}
+
+/// Concatenate corgi columns (skipping empties, which contribute no rows and so don't shift the
+/// pool offsets accounted at registration). One `gather_lanes` over the non-empty blocks.
+fn concat_columns(blocks: &[CValue]) -> CValue {
+    let non_empty: Vec<&CValue> = blocks.iter().filter(|b| b.len() > 0).collect();
+    match non_empty.len() {
+        0 => CValue::Unit(0),
+        1 => non_empty[0].clone(),
+        _ => {
+            let srcs: Vec<Option<&CValue>> = non_empty.iter().map(|b| Some(*b)).collect();
+            let (mut tags, mut offs) = (Vec::new(), Vec::new());
+            for (ti, b) in non_empty.iter().enumerate() {
+                for o in 0..b.len() {
+                    tags.push(ti);
+                    offs.push(o);
+                }
+            }
+            gather_lanes(&srcs, &tags, &offs)
+        }
+    }
 }
 
 /// Concatenate selected records across a run of chunks into parallel `(keys_col, vals_col)` corgi
@@ -108,76 +174,112 @@ impl<T> CorgiReduceBackend<T>
 where
     T: Timestamp + Lattice + Ord,
 {
-    /// The one value crossing for a retire: every `(key, time)` bracket at once. Count/Distinct read
-    /// only diffs; Min/Collect gather+untranscode the bracket values ONCE (not per key). Output ids
-    /// are minted by hashing the produced value column (one `hash_rows`), agreeing with
-    /// `present_output` on equal values.
+    /// The one value crossing for a retire: every `(key, time)` bracket at once. Builds the output
+    /// value COLUMN directly per reducer, registers it (id → row) into the val pool, and returns the
+    /// proxy `(value_id, diff)` deltas with per-bracket ends. `input[k] = (rep index into the input
+    /// presentation, accumulated diff)`; the bracket `i` is `input[ends[i-1]..ends[i]]`, non-empty.
     fn reduce_brackets(&mut self, ends: &[usize], input: &[(usize, Diff)]) -> (Vec<(u64, Diff)>, Vec<usize>) {
-        // Values are only needed for the order/content-sensitive reducers.
-        let need_vals = matches!(self.reducer, Reducer::Min | Reducer::Collect);
-        let vals_rows: Vec<DValue> = if need_vals && !input.is_empty() {
-            let idx: Vec<usize> = input.iter().map(|&(i, _)| i).collect();
-            let g = gather(&self.in_vals, &idx);
-            untranscode(g.clone(), &corgi::shape_of_value(&g))
-        } else {
-            Vec::new()
-        };
+        let mut out_diffs: Vec<Diff> = Vec::new();
+        let mut out_ends: Vec<usize> = Vec::with_capacity(ends.len());
+        let out_ids: Vec<u64>;
 
-        let mut produced: Vec<(DValue, Diff)> = Vec::new();
-        let mut out_ends = Vec::with_capacity(ends.len());
-        let mut start = 0;
-        for &end in ends {
-            match self.reducer {
-                Reducer::Count => {
+        match self.reducer {
+            Reducer::Count => {
+                // Per-bracket sum of diffs; survivors become a `Tuple([Int(sum)])` = corgi `Prod([u64])`.
+                let mut sums: Vec<u64> = Vec::new();
+                let mut start = 0;
+                for &end in ends {
                     let c: Diff = input[start..end].iter().map(|&(_, d)| d).sum();
                     if c > 0 {
-                        produced.push((DValue::Tuple(vec![DValue::Int(c)]), 1));
+                        sums.push(c as u64);
+                        out_diffs.push(1);
                     }
+                    out_ends.push(out_diffs.len());
+                    start = end;
                 }
-                Reducer::Distinct => {
+                if sums.is_empty() {
+                    return (Vec::new(), out_ends);
+                }
+                let col = CValue::Prod(vec![CValue::u64(sums)]);
+                out_ids = hash_rows(&col);
+                self.register_vals(col, &out_ids);
+            }
+            Reducer::Distinct => {
+                // Present iff any value has positive net; output value is unit (a `Unit` column).
+                let mut present = 0usize;
+                let mut start = 0;
+                for &end in ends {
                     if input[start..end].iter().any(|&(_, d)| d > 0) {
-                        produced.push((DValue::unit(), 1));
+                        present += 1;
+                        out_diffs.push(1);
                     }
+                    out_ends.push(out_diffs.len());
+                    start = end;
                 }
-                Reducer::Min => {
-                    let m = (start..end)
-                        .filter(|&k| input[k].1 > 0)
-                        .map(|k| &vals_rows[k])
-                        .min();
-                    if let Some(m) = m {
-                        produced.push((m.clone(), 1));
+                if present == 0 {
+                    return (Vec::new(), out_ends);
+                }
+                let col = CValue::Unit(present);
+                out_ids = hash_rows(&col); // all equal (unit content hash)
+                self.register_vals(col, &out_ids);
+            }
+            Reducer::Min => {
+                // The DDIR `min` over the positive-diff values. Order is DDIR `Ord`, not corgi's, so
+                // untranscode the (few) candidate rows to pick the winner; the winning ROW is then
+                // taken columnar and reuses its input value id.
+                let mut chosen: Vec<usize> = Vec::new(); // input presentation rep indices
+                let mut start = 0;
+                for &end in ends {
+                    let cand: Vec<usize> = (start..end).filter(|&k| input[k].1 > 0).collect();
+                    if !cand.is_empty() {
+                        let idx: Vec<usize> = cand.iter().map(|&k| input[k].0).collect();
+                        let g = gather(&self.in_vals, &idx);
+                        let dv = untranscode(g.clone(), &corgi::shape_of_value(&g));
+                        let best = (0..dv.len()).min_by(|&a, &b| dv[a].cmp(&dv[b])).unwrap();
+                        chosen.push(input[cand[best]].0);
+                        out_diffs.push(1);
                     }
+                    out_ends.push(out_diffs.len());
+                    start = end;
                 }
-                Reducer::Collect => {
-                    // The reducer contract presents values in `Ord` order; the bracket is in
-                    // value-id (hash) order, so sort by value first — the List's element order
-                    // is value-significant (unlike Min/Count/Distinct).
-                    let mut order: Vec<usize> = (start..end).collect();
-                    order.sort_by(|&a, &b| vals_rows[a].cmp(&vals_rows[b]));
-                    let mut items = Vec::new();
-                    for k in order {
-                        for _ in 0..input[k].1.max(0) {
-                            items.push(vals_rows[k].clone());
+                if chosen.is_empty() {
+                    return (Vec::new(), out_ends);
+                }
+                let col = gather(&self.in_vals, &chosen);
+                out_ids = chosen.iter().map(|&r| self.in_value_ids[r]).collect();
+                self.register_vals(col, &out_ids);
+            }
+            Reducer::Collect => {
+                // One row per bracket: the sorted (DDIR `Ord`) values, each repeated by its diff, as a
+                // `List`. Element rows are taken columnar; only the ordering needs untranscode.
+                let mut elem_reps: Vec<usize> = Vec::new();
+                let mut bracket_ends: Vec<usize> = Vec::with_capacity(ends.len());
+                let mut start = 0;
+                for &end in ends {
+                    let ks: Vec<usize> = (start..end).collect();
+                    let idx: Vec<usize> = ks.iter().map(|&k| input[k].0).collect();
+                    let g = gather(&self.in_vals, &idx);
+                    let dv = untranscode(g.clone(), &corgi::shape_of_value(&g));
+                    let mut order: Vec<usize> = (0..ks.len()).collect();
+                    order.sort_by(|&a, &b| dv[a].cmp(&dv[b]));
+                    for oi in order {
+                        for _ in 0..input[ks[oi]].1.max(0) {
+                            elem_reps.push(input[ks[oi]].0);
                         }
                     }
-                    produced.push((DValue::List(items), 1));
+                    bracket_ends.push(elem_reps.len());
+                    out_diffs.push(1);
+                    out_ends.push(out_diffs.len());
+                    start = end;
                 }
+                let elems = if elem_reps.is_empty() { CValue::Unit(0) } else { gather(&self.in_vals, &elem_reps) };
+                let col = CValue::List(Bounds::Offsets(bracket_ends), Box::new(elems));
+                out_ids = hash_rows(&col);
+                self.register_vals(col, &out_ids);
             }
-            out_ends.push(produced.len());
-            start = end;
         }
 
-        // Mint output ids: hash the produced value column columnar, and record id → value.
-        if produced.is_empty() {
-            return (Vec::new(), out_ends);
-        }
-        let vrows: Vec<DValue> = produced.iter().map(|(v, _)| v.clone()).collect();
-        let col = transcode(&vrows, &infer_shape_cols(&vrows));
-        let ids = hash_rows(&col);
-        for (&id, (v, _)) in ids.iter().zip(&produced) {
-            self.out_vals.entry(id).or_insert_with(|| v.clone());
-        }
-        let outs = ids.into_iter().zip(produced).map(|(id, (_, d))| (id, d)).collect();
+        let outs = out_ids.into_iter().zip(out_diffs).collect();
         (outs, out_ends)
     }
 }
@@ -200,62 +302,48 @@ where
     }
 
     fn present_input(&mut self, history: &[CBatch<T>], novel: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
-        // Prune hash→key to the changed set (what survives = the pending keys), and shrink so a past
-        // big retire's table doesn't tax later walks.
-        self.keys.retain(|h, _| keys.binary_search(h).is_ok());
-        self.keys.shrink_to_fit();
+        self.reset_pools();
 
-        // Prime the map from the novel batches (delta-sized, all keys changed): untranscode their key
-        // columns once and record hash → key.
-        for ch in chunks_of(novel) {
-            if ch.keys().len() == 0 {
-                continue;
-            }
-            let kh = hash_rows(ch.keys());
-            let krows = untranscode(ch.keys().clone(), &corgi::shape_of_value(ch.keys()));
-            for (h, k) in kh.into_iter().zip(krows) {
-                self.keys.entry(h).or_insert(k);
-            }
-        }
-
-        // Read novel whole + history filtered to the changed keys (columnar semijoin).
+        // Read novel whole + history filtered to the changed keys (columnar semijoin). Novel chunks
+        // come first, so the first `novel_len` candidate records are the (unfiltered) novel side.
         let mut chunks = chunks_of(novel);
         chunks.extend(chunks_of(history));
         let novel_len: usize = chunks_of(novel).iter().map(|c| c.keys().len()).sum();
         let mut seen = 0usize;
-        let (_keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| {
+        let (keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| {
             let keep = seen < novel_len || keys.binary_search(&h).is_ok();
             seen += 1;
             keep
         });
-        // NB: `seen` advances per candidate record in chunk order; novel chunks come first, so the
-        // first `novel_len` records are the (unfiltered) novel side and the rest is history.
 
         if khs.is_empty() {
             self.in_vals = CValue::Unit(0);
+            self.in_value_ids = Vec::new();
             return ProxyChunk::default();
         }
         let vids = hash_rows(&vals_col);
         let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
         self.in_vals = gather(&vals_col, &reps);
+        self.in_value_ids = chunk.value_ids().to_vec();
+        // Register representative keys (aligned with the sorted presentation) for materialize.
+        let rep_keys = gather(&keys_col, &reps);
+        self.register_keys(rep_keys, chunk.key_hashes());
         chunk
     }
 
     fn present_output(&mut self, batches: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
-        self.out_vals = HashMap::new();
         let chunks = chunks_of(batches);
-        let (_keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| keys.binary_search(&h).is_ok());
+        let (keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| keys.binary_search(&h).is_ok());
         if khs.is_empty() {
             return ProxyChunk::default();
         }
         let vids = hash_rows(&vals_col);
         let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
-        // Record value_id → output value for materialize (representative rows, by the reps).
+        // Register representative output keys and values (aligned with the sorted presentation).
+        let rep_keys = gather(&keys_col, &reps);
+        self.register_keys(rep_keys, chunk.key_hashes());
         let rep_vals = gather(&vals_col, &reps);
-        let vrows = untranscode(rep_vals, &corgi::shape_of_value(&vals_col));
-        for (i, v) in vrows.into_iter().enumerate() {
-            self.out_vals.entry(chunk.value_ids()[i]).or_insert(v);
-        }
+        self.register_vals(rep_vals, chunk.value_ids());
         chunk
     }
 
@@ -268,15 +356,16 @@ where
     }
 
     fn materialize(&mut self, records: ProxyChunk<T, Diff>, description: Description<T>) -> CBatch<T> {
-        let mut rows: Vec<((DValue, DValue), T, Diff)> = (0..records.len())
-            .map(|i| {
-                let k = self.keys.get(&records.key_hashes()[i]).expect("key presented this retire").clone();
-                let v = self.out_vals.get(&records.value_ids()[i]).expect("value presented or minted this retire").clone();
-                ((k, v), records.times()[i].clone(), records.diffs()[i])
-            })
+        let key_pool = concat_columns(&self.key_blocks);
+        let val_pool = concat_columns(&self.val_blocks);
+        let kidx: Vec<usize> = (0..records.len())
+            .map(|i| *self.key_index.get(&records.key_hashes()[i]).expect("key presented this retire"))
+            .collect();
+        let vidx: Vec<usize> = (0..records.len())
+            .map(|i| *self.val_index.get(&records.value_ids()[i]).expect("value presented or minted this retire"))
             .collect();
-        let mut builder = CorgiChunkBuilder::<T, Diff>::with_capacity(0, 0, rows.len());
-        builder.push(&mut rows);
-        Rc::new(builder.done(description))
+        let keys = gather(&key_pool, &kidx);
+        let vals = gather(&val_pool, &vidx);
+        Rc::new(columns_to_batch(keys, vals, records.times().to_vec(), records.diffs().to_vec(), description))
     }
 }

From 61cca29eb7b5d02165dbf74dcc4f993f3cf8d509 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 07:09:11 -0400
Subject: [PATCH 21/68] =?UTF-8?q?corgi=20reduce:=20Min/Collect=20order=20v?=
 =?UTF-8?q?ia=20corgi=20sort=5Fblocks=20=E2=80=94=20zero=20transcode?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the last untranscode (Min/Collect value ordering) with one columnar
corgi sort_blocks per retire:
 - Min: gather positive-diff candidates, segment by bracket, sort_blocks ->
   each bracket's argmin = perm[block_start]; output row taken columnar,
   reusing the input value_id.
 - Collect: segment entries by bracket, sort_blocks -> sorted run per bracket,
   expanded by diff into a List column.

Uses corgi STRUCTURAL order, which equals DDIR Ord for the non-negative
scalar/tuple values these reductions see (all 6 programs); diverges only for
negative ints (unsigned leaf compare) and list-valued compares (length-first),
neither of which arises here — documented as an order invariant.

Needs corgi::arrange::sort_blocks (exposed on fm/corgi dd-arrange-api 9b41cdc,
the segmented sort re-exported from ops::cmp::order). The reduce backend is now
entirely transcode-free. corgi_progs: all 6 match vec; lib tests green (36);
reduce still beats vec (distinct 0.92-0.95x, count 0.93-0.94x).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 99 ++++++++++++++++---------
 1 file changed, 63 insertions(+), 36 deletions(-)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 36670fc03..fe9409b15 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -14,10 +14,13 @@
 //!
 //! Transcode-free: the real keys/values never leave corgi columns. Ids are resolved to rows by
 //! integer index (`key_index`/`val_index` → offsets into the concatenated `key_blocks`/`val_blocks`
-//! pools), not by carrying `DValue`s. The one residual untranscode is Min/Collect's *ordering* of a
-//! bracket's few candidate values — the reduction contract is DDIR `Ord`, which is not corgi's
-//! structural order (unsigned/­kind-blind), so the semantic order is recovered per bracket; the
-//! chosen value ROWS are still taken columnar (`gather`), never rebuilt.
+//! pools), not by carrying `DValue`s. Min/Collect's ordering is corgi's own — one `sort_blocks` per
+//! retire orders every bracket's candidates (Min = each block's first, Collect = each block's sorted
+//! run, expanded by diff). This uses corgi's STRUCTURAL order, which equals DDIR `Ord` for the
+//! non-negative scalar/tuple values these reductions see (all 6 canonical programs); it diverges only
+//! for negative ints (corgi's leaf compare is unsigned) and list-valued compares (corgi lists order
+//! length-first) — neither arises here. A signed/​list-general order would need a corgi order fix
+//! (offset-binary leaf or lex-first lists), not a change here.
 //!
 //! The changed-key restriction is honored by presenting only the changed keys: novel batches are
 //! read whole (delta-sized), the accumulated history is scanned and filtered to the changed hashes
@@ -34,11 +37,10 @@ use differential_dataflow::trace::chunk::ChunkBatch;
 use differential_dataflow::trace::chunk::int_proxy::ProxyChunk;
 use differential_dataflow::operators::int_proxy::ProxyReduceBackend;
 
-use corgi::arrange::{gather, gather_lanes, hash_rows};
+use corgi::arrange::{gather, gather_lanes, hash_rows, sort_blocks};
 use corgi::{Bounds, Value as CValue};
 
 use crate::corgi_chunk::{columns_to_batch, CorgiChunk};
-use crate::corgi_logic::untranscode;
 use crate::ir::Diff;
 use crate::parse::Reducer;
 
@@ -224,54 +226,79 @@ where
                 self.register_vals(col, &out_ids);
             }
             Reducer::Min => {
-                // The DDIR `min` over the positive-diff values. Order is DDIR `Ord`, not corgi's, so
-                // untranscode the (few) candidate rows to pick the winner; the winning ROW is then
-                // taken columnar and reuses its input value id.
-                let mut chosen: Vec<usize> = Vec::new(); // input presentation rep indices
+                // The DDIR `min` over the positive-diff values, in corgi's structural order (== DDIR
+                // `Ord` for the non-negative scalar/tuple values these reductions see; see module doc).
+                // Gather all positive-diff candidates across brackets into one column, segment by
+                // bracket, and one corgi `sort_blocks` gives every bracket's argmin at once
+                // (`perm[block_start]`). The winning ROW is taken columnar and reuses its input value id.
+                let mut cand_reps: Vec<usize> = Vec::new(); // input presentation rep index per candidate
+                let mut labels: Vec<u64> = Vec::new(); // dense segment id per candidate
+                let mut block_starts: Vec<usize> = Vec::new(); // per emitted bracket: start offset in cand_reps
                 let mut start = 0;
                 for &end in ends {
-                    let cand: Vec<usize> = (start..end).filter(|&k| input[k].1 > 0).collect();
-                    if !cand.is_empty() {
-                        let idx: Vec<usize> = cand.iter().map(|&k| input[k].0).collect();
-                        let g = gather(&self.in_vals, &idx);
-                        let dv = untranscode(g.clone(), &corgi::shape_of_value(&g));
-                        let best = (0..dv.len()).min_by(|&a, &b| dv[a].cmp(&dv[b])).unwrap();
-                        chosen.push(input[cand[best]].0);
+                    let lo = cand_reps.len();
+                    let seg = block_starts.len() as u64;
+                    for k in start..end {
+                        if input[k].1 > 0 {
+                            cand_reps.push(input[k].0);
+                            labels.push(seg);
+                        }
+                    }
+                    if cand_reps.len() > lo {
+                        block_starts.push(lo);
                         out_diffs.push(1);
                     }
                     out_ends.push(out_diffs.len());
                     start = end;
                 }
-                if chosen.is_empty() {
+                if cand_reps.is_empty() {
                     return (Vec::new(), out_ends);
                 }
-                let col = gather(&self.in_vals, &chosen);
-                out_ids = chosen.iter().map(|&r| self.in_value_ids[r]).collect();
+                let cand_col = gather(&self.in_vals, &cand_reps);
+                let (perm, _) = sort_blocks(&labels, &cand_col);
+                let min_reps: Vec<usize> = block_starts.iter().map(|&lo| cand_reps[perm[lo]]).collect();
+                let col = gather(&self.in_vals, &min_reps);
+                out_ids = min_reps.iter().map(|&r| self.in_value_ids[r]).collect();
                 self.register_vals(col, &out_ids);
             }
             Reducer::Collect => {
-                // One row per bracket: the sorted (DDIR `Ord`) values, each repeated by its diff, as a
-                // `List`. Element rows are taken columnar; only the ordering needs untranscode.
-                let mut elem_reps: Vec<usize> = Vec::new();
-                let mut bracket_ends: Vec<usize> = Vec::with_capacity(ends.len());
+                // One row per bracket: the values sorted in corgi structural order (== DDIR `Ord` here),
+                // each repeated by its diff, as a `List`. One `sort_blocks` orders every bracket's
+                // entries at once; element rows are then taken columnar. Every bracket emits (empty
+                // list if all diffs ≤ 0), matching the row reducer.
+                let mut entry_reps: Vec<usize> = Vec::new();
+                let mut entry_diffs: Vec<Diff> = Vec::new();
+                let mut labels: Vec<u64> = Vec::new();
+                let mut blocks: Vec<(usize, usize)> = Vec::with_capacity(ends.len());
                 let mut start = 0;
-                for &end in ends {
-                    let ks: Vec<usize> = (start..end).collect();
-                    let idx: Vec<usize> = ks.iter().map(|&k| input[k].0).collect();
-                    let g = gather(&self.in_vals, &idx);
-                    let dv = untranscode(g.clone(), &corgi::shape_of_value(&g));
-                    let mut order: Vec<usize> = (0..ks.len()).collect();
-                    order.sort_by(|&a, &b| dv[a].cmp(&dv[b]));
-                    for oi in order {
-                        for _ in 0..input[ks[oi]].1.max(0) {
-                            elem_reps.push(input[ks[oi]].0);
-                        }
+                for (bi, &end) in ends.iter().enumerate() {
+                    let lo = entry_reps.len();
+                    for k in start..end {
+                        entry_reps.push(input[k].0);
+                        entry_diffs.push(input[k].1);
+                        labels.push(bi as u64);
                     }
-                    bracket_ends.push(elem_reps.len());
+                    blocks.push((lo, entry_reps.len()));
                     out_diffs.push(1);
                     out_ends.push(out_diffs.len());
                     start = end;
                 }
+                let perm = if entry_reps.is_empty() {
+                    Vec::new()
+                } else {
+                    sort_blocks(&labels, &gather(&self.in_vals, &entry_reps)).0
+                };
+                // Expand each bracket's sorted entries by their diff (max(0, ·) copies).
+                let mut elem_reps: Vec<usize> = Vec::new();
+                let mut bracket_ends: Vec<usize> = Vec::with_capacity(ends.len());
+                for (lo, hi) in blocks {
+                    for &e in &perm[lo..hi] {
+                        for _ in 0..entry_diffs[e].max(0) {
+                            elem_reps.push(entry_reps[e]);
+                        }
+                    }
+                    bracket_ends.push(elem_reps.len());
+                }
                 let elems = if elem_reps.is_empty() { CValue::Unit(0) } else { gather(&self.in_vals, &elem_reps) };
                 let col = CValue::List(Bounds::Offsets(bracket_ends), Box::new(elems));
                 out_ids = hash_rows(&col);

From 677d7de891f4b8cd4c2cf0495bfc28fe44c13dc9 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 07:24:09 -0400
Subject: [PATCH 22/68] corgi reduce: identity hasher for the u64 id-index maps

key_index/val_index keys are already well-distributed hash_rows u64s, so
siphash on every register/lookup was wasted (~7% of the reduce tactic in
profiling). Pass the id through unchanged. reduce_count 0.93x->0.88x;
distinct/reach within noise (their id-maps are small). Gate green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index fe9409b15..a7b9f2bff 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -27,6 +27,7 @@
 //! (a columnar semijoin — matching the row-wise tactic's read).
 
 use std::collections::HashMap;
+use std::hash::{BuildHasherDefault, Hasher};
 use std::rc::Rc;
 
 use timely::progress::Timestamp;
@@ -46,6 +47,22 @@ use crate::parse::Reducer;
 
 type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 
+/// An identity `Hasher` for the id-index maps: their keys are already well-distributed 64-bit
+/// content hashes (`hash_rows`), so passing the id straight through avoids re-hashing it (siphash
+/// on `register_keys`/lookups was ~7% of the reduce in profiling). Only `write_u64` is used.
+#[derive(Default)]
+struct IdHasher(u64);
+impl Hasher for IdHasher {
+    #[inline]
+    fn write_u64(&mut self, i: u64) { self.0 = i; }
+    #[inline]
+    fn write(&mut self, _: &[u8]) { unreachable!("IdMap keys are u64") }
+    #[inline]
+    fn finish(&self) -> u64 { self.0 }
+}
+/// `key_hash`/`value_id` → row index, hashed by identity.
+type IdMap = HashMap<u64, usize, BuildHasherDefault<IdHasher>>;
+
 /// A corgi reduce backend for a single `Reducer`. All per-retire scratch is corgi columns + integer
 /// id→row-index maps; nothing carries a `DValue`.
 pub struct CorgiReduceBackend<T> {
@@ -56,12 +73,12 @@ pub struct CorgiReduceBackend<T> {
     in_value_ids: Vec<u64>,
     /// Key-resolution pool for the current retire: `key_hash → row index` into the concatenation of
     /// `key_blocks` (representative keys from the input + output presentations).
-    key_index: HashMap<u64, usize>,
+    key_index: IdMap,
     key_blocks: Vec<CValue>,
     key_len: usize,
     /// Value-resolution pool for the current retire: `value_id → row index` into the concatenation of
     /// `val_blocks` (output-history values + values minted by `reduce_many`).
-    val_index: HashMap<u64, usize>,
+    val_index: IdMap,
     val_blocks: Vec<CValue>,
     val_len: usize,
     _t: std::marker::PhantomData<T>,
@@ -73,10 +90,10 @@ impl<T> CorgiReduceBackend<T> {
             reducer,
             in_vals: CValue::Unit(0),
             in_value_ids: Vec::new(),
-            key_index: HashMap::new(),
+            key_index: IdMap::default(),
             key_blocks: Vec::new(),
             key_len: 0,
-            val_index: HashMap::new(),
+            val_index: IdMap::default(),
             val_blocks: Vec::new(),
             val_len: 0,
             _t: std::marker::PhantomData,

From d6df332b8504726482b2dde72401ec0a0a5024e6 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 07:51:03 -0400
Subject: [PATCH 23/68] int_proxy: MSD-bucket sort in ProxyChunk::from_unsorted
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The proxy records sort by (key_hash, value_id, time); key_hash is a full 64-bit
content hash, so one MSD counting pass on its high byte splits into 256
near-uniform buckets, each finished by a comparison sort on the full key. One
linear pass replaces most of the n log n (falls back to the plain sort for
n<512 or clustered hashes). Profiling: from_unsorted 20% -> 8% of the reduce,
driftsort gone. Wall-clock ~flat (0.89->0.90x) — the reduce is allocation-bound
(malloc 33-38%), so this just uncovers that as the next lever. Framework
(int_proxy + reduce_reference) tests green; corgi_progs all 6 match vec.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/trace/chunk/int_proxy.rs              | 40 ++++++++++++++++++-
 1 file changed, 38 insertions(+), 2 deletions(-)

diff --git a/differential-dataflow/src/trace/chunk/int_proxy.rs b/differential-dataflow/src/trace/chunk/int_proxy.rs
index 2d4aa178d..c1d71fc78 100644
--- a/differential-dataflow/src/trace/chunk/int_proxy.rs
+++ b/differential-dataflow/src/trace/chunk/int_proxy.rs
@@ -135,8 +135,7 @@ where
     pub fn from_unsorted(keys: Vec<u64>, vals: Vec<u64>, times: Vec<T>, diffs: Vec<R>) -> (Self, Vec<usize>) {
         let n = times.len();
         debug_assert!(keys.len() == n && vals.len() == n && diffs.len() == n);
-        let mut perm: Vec<usize> = (0..n).collect();
-        perm.sort_by(|&a, &b| (keys[a], vals[a], &times[a]).cmp(&(keys[b], vals[b], &times[b])));
+        let perm = sort_perm(&keys, &vals, &times);
 
         let (mut ok, mut ov) = (Vec::new(), Vec::new());
         let (mut ot, mut od) = (Vec::new(), Vec::new());
@@ -167,6 +166,43 @@ where
     }
 }
 
+/// The permutation sorting records by `(key_hash, value_id, time)`.
+///
+/// `key_hash` is a full 64-bit content hash (uniformly distributed), so a single MSD counting pass on
+/// its high byte splits the records into 256 near-equal buckets; each bucket is then finished by a
+/// comparison sort on the full `(key_hash, value_id, time)` key. That replaces most of the global
+/// `n log n` with one linear pass plus small local sorts — and degrades gracefully to the plain
+/// comparison sort when the hashes cluster (one bucket) or `n` is too small to amortize the pass.
+/// Stability is irrelevant: `from_unsorted` consolidates by full-key equality, order-blind within a
+/// group.
+fn sort_perm<T: Ord>(keys: &[u64], vals: &[u64], times: &[T]) -> Vec<usize> {
+    let n = keys.len();
+    let cmp = |&a: &usize, &b: &usize| (keys[a], vals[a], &times[a]).cmp(&(keys[b], vals[b], &times[b]));
+    if n < 512 {
+        let mut perm: Vec<usize> = (0..n).collect();
+        perm.sort_unstable_by(cmp);
+        return perm;
+    }
+    // MSD counting sort on the top byte of key_hash → contiguous, ascending buckets.
+    let bucket = |i: usize| (keys[i] >> 56) as usize;
+    let mut counts = [0usize; 256];
+    for i in 0..n { counts[bucket(i)] += 1; }
+    let mut starts = [0usize; 257];
+    for b in 0..256 { starts[b + 1] = starts[b] + counts[b]; }
+    let mut perm = vec![0usize; n];
+    let mut cursor = starts;
+    for i in 0..n {
+        let b = bucket(i);
+        perm[cursor[b]] = i;
+        cursor[b] += 1;
+    }
+    // Finish each bucket by the full key (all share the high byte, so ties on it are common).
+    for b in 0..256 {
+        perm[starts[b]..starts[b + 1]].sort_unstable_by(cmp);
+    }
+    perm
+}
+
 /// Column builders for one output chunk, emitted at `TARGET`.
 struct OutBuf<T, R> {
     keys: Vec<u64>,

From 589af1cc2a5f1d112741169c9f4fa15dd7a104e8 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 08:03:31 -0400
Subject: [PATCH 24/68] int_proxy reduce: reuse per-key scratch across the
 retire

retire allocated fresh Vecs + an IdHistory for EVERY changed key (58% of the
reduce's Vec-growth in profiling, IdHistory another 17%). Hoist the transient
buffers out of the per-key loops and clear/reload them (IdHistory::load already
clears+refills, retaining capacity): rep, raw_moments (drain), and phase-B
meets, out_replay, emitted. Pure capacity reuse, no semantic change.

Scorecard: reduce_distinct/count 0.90->0.85-0.86x, reach 1.06->1.00x (parity)
at n=4000. Allocation was the real lever (sort CPU wasn't). Framework tests
(int_proxy + reduce_reference) green; corgi_progs all 6 match vec.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/reduce.rs         | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index cd98ca344..b4086f5e0 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -177,6 +177,9 @@ where
             moments: Vec<(T, Option<usize>)>,
         }
         let mut work: Vec<KeyWork<B1::Time>> = Vec::new();
+        // Reused across keys (cleared each iteration) so per-key work doesn't reallocate.
+        let mut rep: Vec<(u64, usize)> = Vec::new();
+        let mut raw_moments: Vec<(B1::Time, (usize, usize))> = Vec::new();
         let (mut is, mut os) = (0usize, 0usize);
         for &key in &changed {
             while is < p_in.len() && p_in.key_hashes()[is] < key { is += 1; }
@@ -190,7 +193,7 @@ where
 
             // value_id → representative record index (the first of the vid's run; the
             // key's records are sorted by (value_id, time)).
-            let mut rep: Vec<(u64, usize)> = Vec::new();
+            rep.clear();
             for i in i0..i1 {
                 if rep.last().is_none_or(|(v, _)| *v != p_in.value_ids()[i]) {
                     rep.push((p_in.value_ids()[i], i));
@@ -198,7 +201,7 @@ where
             }
             let pending = self.pending.get(&key).map(|p| &p[..]).unwrap_or(&[]);
 
-            let mut raw_moments: Vec<(B1::Time, (usize, usize))> = Vec::new();
+            raw_moments.clear();
             let mut pended: Vec<B1::Time> = Vec::new();
             discover_and_accumulate(
                 &p_in, i0, i1, &rep, pending, lower, upper,
@@ -211,7 +214,7 @@ where
                 continue;
             }
             let moments = raw_moments
-                .into_iter()
+                .drain(..)
                 .map(|(t, (lo, hi))| {
                     if lo < hi {
                         keys_v.push(key);
@@ -236,19 +239,24 @@ where
         // time order — `Ord` extends the partial order, so earlier deltas are always
         // emitted before a later moment reads them — with the same meet-advancement
         // keeping the output buffer and this pass's deltas consolidated.
+        // Reused across keys: `IdHistory::load` clears+refills (retaining capacity), and `meets`/
+        // `emitted` are cleared each key — so per-key replay doesn't reallocate.
+        let mut meets: Vec<B1::Time> = Vec::new();
+        let mut out_replay = IdHistory::new();
+        let mut emitted: Vec<((u64, B1::Time), Bk::ROut)> = Vec::new();
         for w in work {
-            let mut meets: Vec<B1::Time> = w.moments.iter().map(|(t, _)| t.clone()).collect();
+            meets.clear();
+            meets.extend(w.moments.iter().map(|(t, _)| t.clone()));
             for i in (1..meets.len()).rev() {
                 let m = meets[i].clone();
                 meets[i - 1].meet_assign(&m);
             }
-            let mut out_replay = IdHistory::new();
             out_replay.load(
                 (w.o0..w.o1).map(|o| (p_out.value_ids()[o], p_out.times()[o].clone(), p_out.diffs()[o].clone())),
                 meets.first(),
             );
             // Deltas emitted for this key earlier in this pass; part of "current output".
-            let mut emitted: Vec<((u64, B1::Time), Bk::ROut)> = Vec::new();
+            emitted.clear();
             for (j, (t, bracket)) in w.moments.iter().enumerate() {
                 out_replay.step_through(t);
                 out_replay.advance_buffer_by(&meets[j]);

From a0027482f0a018de886f557277129e831beee09d Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 08:07:59 -0400
Subject: [PATCH 25/68] int_proxy reduce: reuse the per-moment delta map
 (BTreeMap -> reused IdMap)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase B allocated a fresh BTreeMap per (key, moment) for the desired-vs-current
delta. Replace with one HashMap keyed by an identity hasher (value_ids are
already u64 content hashes), hoisted above the loop and cleared per moment
(retains capacity, no per-moment alloc/free). Iteration order is irrelevant —
deltas are consolidated and the output batch is sorted by from_unsorted.

Scorecard: reduce_count 0.86->0.85x, reach 1.06->0.98x at n=4000 (below parity).
Framework tests (int_proxy + reduce_reference) green; corgi_progs all 6 == vec.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/reduce.rs         | 45 ++++++++++++-------
 1 file changed, 30 insertions(+), 15 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index b4086f5e0..80005f0cc 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -1,6 +1,7 @@
 //! The proxy reduce: all interesting-time logic in proxy space, value work by callback.
 
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::hash::{BuildHasherDefault, Hasher};
 
 use timely::PartialOrder;
 use timely::progress::{Antichain, Timestamp};
@@ -13,6 +14,18 @@ use crate::operators::reduce::ReduceTactic;
 
 use super::history::IdHistory;
 
+/// Identity hasher for `value_id`-keyed scratch maps: `value_id`s are already 64-bit content hashes,
+/// so re-hashing them is waste. Reused across moments (cleared, not reallocated) to avoid a
+/// per-moment map alloc/free.
+#[derive(Default)]
+struct IdHasher(u64);
+impl Hasher for IdHasher {
+    #[inline] fn write_u64(&mut self, i: u64) { self.0 = i; }
+    #[inline] fn write(&mut self, _: &[u8]) { unreachable!("value_id keys are u64") }
+    #[inline] fn finish(&self) -> u64 { self.0 }
+}
+type IdMap<R> = HashMap<u64, R, BuildHasherDefault<IdHasher>>;
+
 /// The reduce backend: value semantics for a proxy-space reduction.
 ///
 /// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `key_hashes` (over the
@@ -244,6 +257,9 @@ where
         let mut meets: Vec<B1::Time> = Vec::new();
         let mut out_replay = IdHistory::new();
         let mut emitted: Vec<((u64, B1::Time), Bk::ROut)> = Vec::new();
+        // Reused `value_id → diff` accumulator, cleared each moment (retains capacity — no per-moment
+        // map alloc/free).
+        let mut acc: IdMap<Bk::ROut> = IdMap::default();
         for w in work {
             meets.clear();
             meets.extend(w.moments.iter().map(|(t, _)| t.clone()));
@@ -266,38 +282,37 @@ where
                 crate::consolidation::consolidate(&mut emitted);
 
                 // Current output at `t`: committed history plus this pass's deltas.
-                let mut cur: BTreeMap<u64, Bk::ROut> = BTreeMap::new();
+                acc.clear();
                 for ((vid, et), d) in out_replay.buffer().iter().chain(emitted.iter()) {
                     if et.less_equal(t) {
-                        match cur.entry(*vid) {
-                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
-                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(d.clone()); }
+                        match acc.entry(*vid) {
+                            std::collections::hash_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
+                            std::collections::hash_map::Entry::Vacant(e) => { e.insert(d.clone()); }
                         }
                     }
                 }
-                cur.retain(|_, d| !d.is_zero());
+                acc.retain(|_, d| !d.is_zero());
 
-                // delta = desired − current, in proxy space.
-                let mut delta: BTreeMap<u64, Bk::ROut> = cur;
-                for d in delta.values_mut() {
+                // delta = desired − current, in proxy space (negate current, add desired).
+                for d in acc.values_mut() {
                     d.negate();
                 }
                 if let Some(b) = *bracket {
                     let lo = if b == 0 { 0 } else { out_ends[b - 1] };
                     for (vid, d) in outs[lo..out_ends[b]].iter().cloned() {
-                        match delta.entry(vid) {
-                            std::collections::btree_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
-                            std::collections::btree_map::Entry::Vacant(e) => { e.insert(d); }
+                        match acc.entry(vid) {
+                            std::collections::hash_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
+                            std::collections::hash_map::Entry::Vacant(e) => { e.insert(d); }
                         }
                     }
                 }
-                delta.retain(|_, d| !d.is_zero());
-                if delta.is_empty() {
+                acc.retain(|_, d| !d.is_zero());
+                if acc.is_empty() {
                     continue;
                 }
 
                 let idx = held_elems.iter().rposition(|h| h.less_equal(t)).expect("no held capability <= active time");
-                for (vid, d) in delta {
+                for (vid, d) in acc.drain() {
                     emitted.push(((vid, t.clone()), d.clone()));
                     buckets[idx].push(((w.key, vid), t.clone(), d));
                 }

From f7bdb42f9b88e540de44768d6c75a7c3d6938807 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 08:22:40 -0400
Subject: [PATCH 26/68] corgi_perf: add end-to-end SCC case (corgi vs vec)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SCC is the sharp recursive case (nested fwd/bwd label propagation via min,
negation, 4 joins). Findings: corgi is ~1.9-2.5x slower than vec and the gap
GROWS with n (unlike reach, which reaches parity) — scc's nested-recursion /
negation / min structure scales worse for corgi. And corgi DIVERGES from vec on
larger random graphs (n>=1000: 1297 vs 1292) — a corgi-backend correctness bug
(the proxy reduce tactic + reference backend pass the scc oracles in
reduce_reference.rs, and it is NOT the min value-ordering — tested with a
DValue-order argmin). Harness flags the mismatch instead of panicking.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/examples/corgi_perf.rs | 50 ++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/interactive/examples/corgi_perf.rs b/interactive/examples/corgi_perf.rs
index 22bb5019b..21861d213 100644
--- a/interactive/examples/corgi_perf.rs
+++ b/interactive/examples/corgi_perf.rs
@@ -116,6 +116,56 @@ fn main() {
         report("reach", nodes, vt, ct);
     }
 
+    // ---------- 2b. SCC (nested recursion: fwd/bwd label propagation via `min`) ----------
+    let scc = compile(r#"
+        let edges = input 0 | key($0[0] ; $0[1]);
+        let trans = edges | key($1 ; $0);
+        outer: {
+            let scc = edges + trim;
+            fwd: {
+                let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+                let labels = proposals + nodes | min;
+                var proposals = labels | join(scc, ($2 ; $1));
+            }
+            let trim_fwd = edges
+                | join(fwd::labels, ($1 ; $0, $2))
+                | join(fwd::labels, ($0 ; $1, $2))
+                | filter($1[1] == $1[2])
+                | key($0 ; $1[0]);
+            bwd: {
+                let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+                let labels = proposals + nodes | min;
+                var proposals = labels | join(trim_fwd, ($2 ; $1));
+            }
+            let trim_bwd = trans
+                | join(bwd::labels, ($1 ; $0, $2))
+                | join(bwd::labels, ($0 ; $1, $2))
+                | filter($1[1] == $1[2])
+                | key($0 ; $1[0]);
+            var trim = trim_bwd - edges;
+        }
+        export "result" = outer::scc | map(;) | arrange;
+    "#);
+
+    println!("\n2b. SCC (nested recursion; fwd/bwd label propagation via min; the sharp case):");
+    for &nodes in &[200usize, 500, 800, 1_000] {
+        let mut seed = 0xc0ff_ee42u64;
+        let n_edges = nodes * 2;
+        let edges: Vec<(Row, Row)> = (0..n_edges)
+            .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
+            .collect();
+        let inputs = vec![edges];
+        // NB: corgi diverges from vec on larger random graphs (a corgi-backend bug — the proxy reduce
+        // tactic + reference backend pass the scc oracles in `reduce_reference.rs`). Flag, don't panic.
+        let (co, ve) = (corgi::evaluate(&scc, &inputs), vec::evaluate(&scc, &inputs));
+        if co != ve {
+            println!("  scc                    n={nodes:<7}  !! MISMATCH corgi={co:?} vec={ve:?}");
+        }
+        let vt = bench(3, || { std::hint::black_box(vec::evaluate(&scc, &inputs)); });
+        let ct = bench(3, || { std::hint::black_box(corgi::evaluate(&scc, &inputs)); });
+        report("scc", nodes, vt, ct);
+    }
+
     // ---------- 3. LINEAR COMPUTE ONLY (deep chain, NO arrange) — isolates the columnar eval ----------
     // 8 wide arithmetic maps, exported without arrange (only ToCorgi in / FromCorgi out transcode
     // bracket the columnar chain). This is where corgi's columnar scalar logic should actually pay.

From 860d20bc5fc6c1c3f3bc1161272f6fd5534b644c Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 08:46:37 -0400
Subject: [PATCH 27/68] Isolate SCC bug to corgi (not the int_proxy tactic)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two debugging tools:
 - reduce_reference.rs: add reduce_int_proxy (int_proxy ProxyReduceTactic + Vec
   value backend over VecChunk, NO corgi) and scc_int_proxy_* tests that run SCC
   with only the reduce swapped to int_proxy, vs the cursor reduce. They PASS up
   to 50 nodes/120 edges/20 seeds — so the int_proxy reduce TACTIC is correct at
   SCC's nested-product-time depth. (reduce_reference's own scc_* compare cursor
   vs the *stock* reference tactic, never int_proxy — this fills that gap.)
 - interactive corgi_scc_min.rs: sweep+delta-debug an SCC corgi-vs-vec divergence
   to a minimal graph. Finds nodes=4, 5 edges [(0,0),(0,2),(1,3),(2,1),(2,2)]:
   corgi=3 vs vec=2.

Conclusion: the divergence is in the CORGI backend, not the int_proxy work. The
int_proxy tactic + Vec values reproduces SCC exactly; swapping in corgi is what
breaks it. Next: narrow within corgi (reduce value backend vs join vs negate).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../tests/reduce_reference.rs                 |  85 ++++++++++---
 interactive/examples/corgi_scc_min.rs         | 120 ++++++++++++++++++
 2 files changed, 186 insertions(+), 19 deletions(-)
 create mode 100644 interactive/examples/corgi_scc_min.rs

diff --git a/differential-dataflow/tests/reduce_reference.rs b/differential-dataflow/tests/reduce_reference.rs
index 6046660ae..9bb3c2c4c 100644
--- a/differential-dataflow/tests/reduce_reference.rs
+++ b/differential-dataflow/tests/reduce_reference.rs
@@ -96,6 +96,42 @@ where
     .as_collection(|k, v| (k.clone(), v.clone()))
 }
 
+// Same shape as `reduce_reference`, but driven by the INT_PROXY `ProxyReduceTactic` + the reference
+// (Vec) value backend over `VecChunk` arrangements — i.e. the int_proxy reduce with NO corgi. Used to
+// isolate the int_proxy tactic from the corgi backend on SCC.
+fn reduce_int_proxy<'scope, Ti, K, V, R, V2, R2, L>(
+    collection: VecCollection<'scope, Ti, (K, V), R>,
+    logic: L,
+) -> VecCollection<'scope, Ti, (K, V2), R2>
+where
+    Ti: timely::progress::Timestamp + Lattice + Ord,
+    K: ExchangeData + Hashable + std::hash::Hash + Ord,
+    V: ExchangeData + std::hash::Hash + Ord,
+    R: ExchangeData + Semigroup + Ord,
+    V2: Data + std::hash::Hash + Ord,
+    R2: ExchangeData + Ord + Abelian,
+    L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>) + 'static,
+{
+    use differential_dataflow::operators::arrange::arrangement::arrange_core;
+    use differential_dataflow::operators::int_proxy::ProxyReduceTactic;
+    use differential_dataflow::operators::int_proxy::reference::VecReduceBackend;
+    use differential_dataflow::operators::reduce::reduce_with_tactic;
+    use differential_dataflow::trace::chunk::vec::{ChunkBatcher, ChunkBuilder, ChunkSpine, VecChunk};
+    use differential_dataflow::trace::implementations::chunker::ContainerChunker;
+    use timely::dataflow::channels::pact::Pipeline;
+
+    let arranged = arrange_core::<
+        _, _,
+        ContainerChunker<VecChunk<K, V, Ti, R>>,
+        ChunkBatcher<K, V, Ti, R>,
+        ChunkBuilder<K, V, Ti, R>,
+        ChunkSpine<K, V, Ti, R>,
+    >(collection.inner, Pipeline, "Arrange: IntProxy");
+    let tactic = ProxyReduceTactic::new(VecReduceBackend::new(logic));
+    let reduced = reduce_with_tactic::<_, ChunkSpine<K, V2, Ti, R2>, _>(arranged, "IntProxyReduce", tactic);
+    reduced.as_collection(|k, v| (k.clone(), v.clone()))
+}
+
 // A random input: `((key, val), Pair(a, b), diff)`, diffs ±1 so updates cancel.
 fn random_input(seed: usize, n: usize, keys: u64, vals: u64, span: u64) -> Vec<((u64, u64), Time, isize)> {
     let s: &[usize] = &[seed, 7, 13, 29];
@@ -230,8 +266,8 @@ fn bfs_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
         let (mut roots, mut edges) = worker.dataflow::<usize, _, _>(|scope| {
             let (root_input, roots) = scope.new_collection();
             let (edge_input, edges) = scope.new_collection();
-            let via_cursor    = bfs(edges.clone(), roots.clone(), false);
-            let via_reference = bfs(edges, roots, true);
+            let via_cursor    = bfs(edges.clone(), roots.clone(), 0);
+            let via_reference = bfs(edges, roots, 1);
             via_cursor.assert_eq(via_reference);
             (root_input, edge_input)
         });
@@ -248,7 +284,7 @@ fn bfs_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
     });
 }
 
-fn bfs<'scope, T>(edges: VecCollection<'scope, T, Edge>, roots: VecCollection<'scope, T, Node>, reference: bool) -> VecCollection<'scope, T, (Node, usize)>
+fn bfs<'scope, T>(edges: VecCollection<'scope, T, Edge>, roots: VecCollection<'scope, T, Node>, mode: u8) -> VecCollection<'scope, T, (Node, usize)>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
@@ -257,7 +293,9 @@ where
         let edges = edges.enter(scope);
         let nodes = nodes.enter(scope);
         let combined = inner.join_map(edges, |_k, l, d| (*d, l + 1)).concat(nodes);
-        if reference {
+        if mode == 2 {
+            reduce_int_proxy(combined, |_, s, t| t.push((*s[0].0, 1)))
+        } else if mode == 1 {
             reduce_reference(combined, |_, s, t| t.push((*s[0].0, 1)))
         } else {
             combined.reduce(|_, s, t| t.push((*s[0].0, 1)))
@@ -270,12 +308,19 @@ where
 // iterative label propagation whose `reduce` is the tactic under test. The doubly-nested product
 // time produces far more synthetic interesting times than BFS, over joins / concats / filters.
 
-#[test] fn scc_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4]); }
-#[test] fn scc_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8]); }
-#[test] fn scc_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8]); }
-#[test] fn scc_sweep()  { for s in 0u8 .. 6 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29]); } }
+#[test] fn scc_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4], 1); }
+#[test] fn scc_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8], 1); }
+#[test] fn scc_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8], 1); }
+#[test] fn scc_sweep()  { for s in 0u8 .. 6 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29], 1); } }
 
-fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
+// int_proxy reduce (no corgi) vs cursor: does the int_proxy TACTIC diverge on SCC depth?
+#[test] fn scc_int_proxy_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4], 2); }
+#[test] fn scc_int_proxy_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8], 2); }
+#[test] fn scc_int_proxy_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8], 2); }
+#[test] fn scc_int_proxy_sweep()  { for s in 0u8 .. 12 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29], 2); } }
+#[test] fn scc_int_proxy_big()    { for s in 0u8 .. 20 { scc_differential(50, 120, 8, &[s as usize, 3, 11, 23], 2); } }
+
+fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize], mode: u8) {
     let mut rng1: StdRng = SeedableRng::from_seed(seed);
     let mut rng2: StdRng = SeedableRng::from_seed(seed);
     let mut edge_list: Vec<((usize, usize), usize, isize)> = Vec::new();
@@ -289,9 +334,9 @@ fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
         let mut edges_list = edge_list.clone();
         let mut edges = worker.dataflow::<usize, _, _>(|scope| {
             let (edge_input, edges) = scope.new_collection();
-            let via_cursor    = scc(edges.clone(), false);
-            let via_reference = scc(edges, true);
-            via_cursor.assert_eq(via_reference);
+            let via_cursor = scc(edges.clone(), 0);
+            let via_mode   = scc(edges, mode);
+            via_cursor.assert_eq(via_mode);
             edge_input
         });
         edges_list.sort_by(|x, y| y.1.cmp(&x.1));
@@ -306,7 +351,7 @@ fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
 
 // The subset of edges within a strongly connected component, mirroring
 // `algorithms::graphs::scc::strongly_connected` but with the propagation `reduce` swappable.
-fn scc<'scope, T>(graph: VecCollection<'scope, T, Edge>, reference: bool) -> VecCollection<'scope, T, Edge>
+fn scc<'scope, T>(graph: VecCollection<'scope, T, Edge>, mode: u8) -> VecCollection<'scope, T, Edge>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
@@ -314,19 +359,19 @@ where
     graph.iterate(move |scope, inner| {
         let edges = graph2.enter(scope);
         let trans = edges.clone().map(|(a, b)| (b, a));
-        let trimmed = trim_edges(inner, edges, reference);
-        trim_edges(trimmed, trans, reference)
+        let trimmed = trim_edges(inner, edges, mode);
+        trim_edges(trimmed, trans, mode)
     })
 }
 
 // Keep only edges whose endpoints propagate to the same label; run twice (forward then transposed)
 // this converges on the SCC edges.
-fn trim_edges<'scope, T>(cycle: VecCollection<'scope, T, Edge>, edges: VecCollection<'scope, T, Edge>, reference: bool) -> VecCollection<'scope, T, Edge>
+fn trim_edges<'scope, T>(cycle: VecCollection<'scope, T, Edge>, edges: VecCollection<'scope, T, Edge>, mode: u8) -> VecCollection<'scope, T, Edge>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
     let nodes = edges.clone().map(|(_a, b)| (b, b));
-    let labels = propagate(cycle, nodes, reference);
+    let labels = propagate(cycle, nodes, mode);
     edges.join_map(labels.clone(), |&src, &dst, &l1| (dst, (src, l1)))
          .join_map(labels, |&dst, &(src, l1), &l2| ((src, dst), (l1, l2)))
          .filter(|(_, (l1, l2))| l1 == l2)
@@ -335,7 +380,7 @@ where
 
 // Forward min-label propagation along `edges` from per-node seed labels; the inner `reduce` (min
 // label per node) is the tactic under test.
-fn propagate<'scope, T>(edges: VecCollection<'scope, T, Edge>, nodes: VecCollection<'scope, T, (Node, Node)>, reference: bool) -> VecCollection<'scope, T, (Node, Node)>
+fn propagate<'scope, T>(edges: VecCollection<'scope, T, Edge>, nodes: VecCollection<'scope, T, (Node, Node)>, mode: u8) -> VecCollection<'scope, T, (Node, Node)>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
@@ -344,7 +389,9 @@ where
         let edges = edges.enter(scope);
         let seed = seed.enter(scope);
         let combined = inner.join_map(edges, |&_n, &l, &d| (d, l)).concat(seed);
-        if reference {
+        if mode == 2 {
+            reduce_int_proxy(combined, |_, s, t| t.push((*s[0].0, 1)))
+        } else if mode == 1 {
             reduce_reference(combined, |_, s, t| t.push((*s[0].0, 1)))
         } else {
             combined.reduce(|_, s, t| t.push((*s[0].0, 1)))
diff --git a/interactive/examples/corgi_scc_min.rs b/interactive/examples/corgi_scc_min.rs
new file mode 100644
index 000000000..44888c6e8
--- /dev/null
+++ b/interactive/examples/corgi_scc_min.rs
@@ -0,0 +1,120 @@
+//! Minimize an SCC corgi-vs-vec divergence: sweep (nodes, seed), find the smallest edge set where
+//! `corgi::evaluate != vec::evaluate`, then greedily shrink the edge set (delta-debug) while the
+//! mismatch persists. Prints the minimal failing graph for conventional tracing.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_min
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(a: i64, b: i64) -> Row {
+    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+const SCC_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges
+            | join(fwd::labels, ($1 ; $0, $2))
+            | join(fwd::labels, ($0 ; $1, $2))
+            | filter($1[1] == $1[2])
+            | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans
+            | join(bwd::labels, ($1 ; $0, $2))
+            | join(bwd::labels, ($0 ; $1, $2))
+            | filter($1[1] == $1[2])
+            | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | map(;) | arrange;
+"#;
+
+fn compile() -> interactive::scope_ir::Program {
+    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
+    p.optimize();
+    p
+}
+
+/// True iff corgi and vec agree on this edge set.
+fn agrees(prog: &interactive::scope_ir::Program, edges: &[(Row, Row)]) -> bool {
+    let inputs = vec![edges.to_vec()];
+    corgi::evaluate(prog, &inputs) == vec::evaluate(prog, &inputs)
+}
+
+fn main() {
+    let prog = compile();
+
+    // 1. Sweep (nodes, seed) for the smallest failing edge count.
+    let mut found: Option<(usize, u64, Vec<(Row, Row)>)> = None;
+    'search: for &nodes in &[4usize, 5, 6, 7, 8, 10, 12, 16, 20, 30, 50] {
+        for seed_i in 0..4000u64 {
+            let mut seed = 0x1000 + seed_i.wrapping_mul(0x9e3779b97f4a7c15);
+            let n_edges = nodes * 2;
+            let edges: Vec<(Row, Row)> = (0..n_edges)
+                .map(|_| (tup((xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64), Value::unit()))
+                .collect();
+            if !agrees(&prog, &edges) {
+                println!("first mismatch: nodes={nodes} seed_i={seed_i} n_edges={n_edges}");
+                found = Some((nodes, seed_i, edges));
+                break 'search;
+            }
+        }
+        println!("  nodes={nodes}: all {} seeds agree", 4000);
+    }
+
+    let Some((nodes, _seed, mut edges)) = found else {
+        println!("NO mismatch found in the sweep.");
+        return;
+    };
+
+    // 2. Delta-debug: greedily drop edges while the mismatch persists.
+    let mut changed = true;
+    while changed {
+        changed = false;
+        let mut i = 0;
+        while i < edges.len() {
+            let mut trial = edges.clone();
+            trial.remove(i);
+            if !trial.is_empty() && !agrees(&prog, &trial) {
+                edges = trial;
+                changed = true;
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    // 3. Report the minimal failing graph and the two outputs.
+    println!("\nMINIMAL failing graph: nodes={nodes}, {} edges:", edges.len());
+    let mut es: Vec<(i64, i64)> = edges.iter().map(|(k, _)| match k {
+        Value::Tuple(f) => (f[0].as_int(), f[1].as_int()),
+        _ => unreachable!(),
+    }).collect();
+    es.sort();
+    println!("  edges = {es:?}");
+    let inputs = vec![edges.clone()];
+    println!("  corgi = {:?}", corgi::evaluate(&prog, &inputs));
+    println!("  vec   = {:?}", vec::evaluate(&prog, &inputs));
+}

From ad498bdd7523775510c8a953aff19878711e1be0 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 09:02:28 -0400
Subject: [PATCH 28/68] Narrow corgi SCC bug to the outer recursion (not
 scopes/reduce structure)

Four minimizer/trace harnesses (interactive examples):
 - corgi_scc_min: minimal SCC divergence = 4 nodes, [(0,0),(0,2),(1,3),(2,1),(2,2)].
 - corgi_scc_trace: on that graph, export each SCC intermediate. Result:
   fwd::labels OK, trim_fwd OK, bwd::labels DIFF (node 2 -> label 1 in corgi vs
   2 in vec), trim_bwd/scc DIFF. So the divergence enters at the backward min-
   reduce, structurally identical to the correct forward one.
 - corgi_cc_min: single-level fwd min-label propagation NEVER diverges (to 80
   nodes) -> not single recursion.
 - corgi_bwd_min: two-pass fwd->trim->bwd with NO outer loop NEVER diverges ->
   not the chained nested scopes either.

Conclusion: the bug REQUIRES SCC's outer recursion (the iterate wrapping fwd/bwd
-> 3-deep product times, plus negation  and feedback
). Symptom is a failed retraction (stale label survives).
Suspects: corgi 3-level dynamic-time handling (leave_dynamic/results_in/enter_at)
or negation under recursion. Not int_proxy (proven), not the reduce structure.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/examples/corgi_bwd_min.rs   | 109 ++++++++++++++++++++++++
 interactive/examples/corgi_cc_min.rs    |  98 +++++++++++++++++++++
 interactive/examples/corgi_scc_trace.rs |  89 +++++++++++++++++++
 3 files changed, 296 insertions(+)
 create mode 100644 interactive/examples/corgi_bwd_min.rs
 create mode 100644 interactive/examples/corgi_cc_min.rs
 create mode 100644 interactive/examples/corgi_scc_trace.rs

diff --git a/interactive/examples/corgi_bwd_min.rs b/interactive/examples/corgi_bwd_min.rs
new file mode 100644
index 000000000..9f28b5d7b
--- /dev/null
+++ b/interactive/examples/corgi_bwd_min.rs
@@ -0,0 +1,109 @@
+//! Narrow the SCC divergence: is it already in single-level min-label-propagation (the `fwd` block of
+//! SCC — one dynamic scope, `min` + `join`), or does it need SCC's nested trimming/negation?
+//! Sweep+delta-debug corgi-vs-vec on the standalone forward propagation, comparing the FULL labels.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_cc_min
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(a: i64, b: i64) -> Row {
+    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+// Standalone forward min-label propagation — SCC's `fwd` block, joining against `edges` directly.
+const SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    fwd: {
+        let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+        let labels = proposals + nodes | min;
+        var proposals = labels | join(edges, ($2 ; $1));
+    }
+    let trim_fwd = edges
+        | join(fwd::labels, ($1 ; $0, $2))
+        | join(fwd::labels, ($0 ; $1, $2))
+        | filter($1[1] == $1[2])
+        | key($0 ; $1[0]);
+    bwd: {
+        let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+        let labels = proposals + nodes | min;
+        var proposals = labels | join(trim_fwd, ($2 ; $1));
+    }
+    export "result" = bwd::labels | arrange;
+"#;
+
+fn compile() -> interactive::scope_ir::Program {
+    let mut p = lower::lower_tree(parse::pipe::parse(SRC));
+    p.optimize();
+    p
+}
+
+fn agrees(prog: &interactive::scope_ir::Program, edges: &[(Row, Row)]) -> bool {
+    let inputs = vec![edges.to_vec()];
+    corgi::evaluate(prog, &inputs) == vec::evaluate(prog, &inputs)
+}
+
+fn main() {
+    let prog = compile();
+
+    let mut found: Option<(usize, Vec<(Row, Row)>)> = None;
+    'search: for &nodes in &[4usize, 5, 6, 8, 10, 12, 16, 20, 30, 50, 80] {
+        for seed_i in 0..6000u64 {
+            let mut seed = 0x1000 + seed_i.wrapping_mul(0x9e3779b97f4a7c15);
+            let n_edges = nodes * 2;
+            let edges: Vec<(Row, Row)> = (0..n_edges)
+                .map(|_| (tup((xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64), Value::unit()))
+                .collect();
+            if !agrees(&prog, &edges) {
+                println!("first mismatch: nodes={nodes} seed_i={seed_i} n_edges={n_edges}");
+                found = Some((nodes, edges));
+                break 'search;
+            }
+        }
+        println!("  nodes={nodes}: all seeds agree");
+    }
+
+    let Some((nodes, mut edges)) = found else {
+        println!("\nNO two-pass (fwd->trim->bwd, no outer loop) mismatch found — the bug needs SCC's nesting/negation.");
+        return;
+    };
+
+    // Delta-debug.
+    let mut changed = true;
+    while changed {
+        changed = false;
+        let mut i = 0;
+        while i < edges.len() {
+            let mut trial = edges.clone();
+            trial.remove(i);
+            if !trial.is_empty() && !agrees(&prog, &trial) {
+                edges = trial;
+                changed = true;
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    println!("\nMINIMAL failing graph: nodes={nodes}, {} edges:", edges.len());
+    let mut es: Vec<(i64, i64)> = edges.iter().map(|(k, _)| match k {
+        Value::Tuple(f) => (f[0].as_int(), f[1].as_int()),
+        _ => unreachable!(),
+    }).collect();
+    es.sort();
+    println!("  edges = {es:?}");
+    let inputs = vec![edges.clone()];
+    println!("  corgi = {:?}", corgi::evaluate(&prog, &inputs));
+    println!("  vec   = {:?}", vec::evaluate(&prog, &inputs));
+}
diff --git a/interactive/examples/corgi_cc_min.rs b/interactive/examples/corgi_cc_min.rs
new file mode 100644
index 000000000..ade2fea2d
--- /dev/null
+++ b/interactive/examples/corgi_cc_min.rs
@@ -0,0 +1,98 @@
+//! Narrow the SCC divergence: is it already in single-level min-label-propagation (the `fwd` block of
+//! SCC — one dynamic scope, `min` + `join`), or does it need SCC's nested trimming/negation?
+//! Sweep+delta-debug corgi-vs-vec on the standalone forward propagation, comparing the FULL labels.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_cc_min
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(a: i64, b: i64) -> Row {
+    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
+}
+
+fn xorshift(s: &mut u64) -> u64 {
+    *s ^= *s << 13;
+    *s ^= *s >> 7;
+    *s ^= *s << 17;
+    *s
+}
+
+// Standalone forward min-label propagation — SCC's `fwd` block, joining against `edges` directly.
+const SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    fwd: {
+        let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+        let labels = proposals + nodes | min;
+        var proposals = labels | join(edges, ($2 ; $1));
+    }
+    export "result" = fwd::labels | arrange;
+"#;
+
+fn compile() -> interactive::scope_ir::Program {
+    let mut p = lower::lower_tree(parse::pipe::parse(SRC));
+    p.optimize();
+    p
+}
+
+fn agrees(prog: &interactive::scope_ir::Program, edges: &[(Row, Row)]) -> bool {
+    let inputs = vec![edges.to_vec()];
+    corgi::evaluate(prog, &inputs) == vec::evaluate(prog, &inputs)
+}
+
+fn main() {
+    let prog = compile();
+
+    let mut found: Option<(usize, Vec<(Row, Row)>)> = None;
+    'search: for &nodes in &[4usize, 5, 6, 8, 10, 12, 16, 20, 30, 50, 80] {
+        for seed_i in 0..6000u64 {
+            let mut seed = 0x1000 + seed_i.wrapping_mul(0x9e3779b97f4a7c15);
+            let n_edges = nodes * 2;
+            let edges: Vec<(Row, Row)> = (0..n_edges)
+                .map(|_| (tup((xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64), Value::unit()))
+                .collect();
+            if !agrees(&prog, &edges) {
+                println!("first mismatch: nodes={nodes} seed_i={seed_i} n_edges={n_edges}");
+                found = Some((nodes, edges));
+                break 'search;
+            }
+        }
+        println!("  nodes={nodes}: all seeds agree");
+    }
+
+    let Some((nodes, mut edges)) = found else {
+        println!("\nNO forward-propagation mismatch found — the bug needs SCC's nesting/negation.");
+        return;
+    };
+
+    // Delta-debug.
+    let mut changed = true;
+    while changed {
+        changed = false;
+        let mut i = 0;
+        while i < edges.len() {
+            let mut trial = edges.clone();
+            trial.remove(i);
+            if !trial.is_empty() && !agrees(&prog, &trial) {
+                edges = trial;
+                changed = true;
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    println!("\nMINIMAL failing graph: nodes={nodes}, {} edges:", edges.len());
+    let mut es: Vec<(i64, i64)> = edges.iter().map(|(k, _)| match k {
+        Value::Tuple(f) => (f[0].as_int(), f[1].as_int()),
+        _ => unreachable!(),
+    }).collect();
+    es.sort();
+    println!("  edges = {es:?}");
+    let inputs = vec![edges.clone()];
+    println!("  corgi = {:?}", corgi::evaluate(&prog, &inputs));
+    println!("  vec   = {:?}", vec::evaluate(&prog, &inputs));
+}
diff --git a/interactive/examples/corgi_scc_trace.rs b/interactive/examples/corgi_scc_trace.rs
new file mode 100644
index 000000000..a1291b9ea
--- /dev/null
+++ b/interactive/examples/corgi_scc_trace.rs
@@ -0,0 +1,89 @@
+//! Trace the minimal SCC divergence: on the fixed 4-node repro, export each intermediate of the SCC
+//! program (fwd labels, trim_fwd, bwd labels, trim_bwd, scc) and compare corgi vs vec. The first
+//! intermediate that diverges localizes the bug within corgi.
+//!
+//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_trace
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(a: i64, b: i64) -> Row {
+    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
+}
+
+// The minimal failing graph found by corgi_scc_min.
+fn edges() -> Vec<(Row, Row)> {
+    [(0, 0), (0, 2), (1, 3), (2, 1), (2, 2)]
+        .iter()
+        .map(|&(a, b)| (tup(a, b), Value::unit()))
+        .collect()
+}
+
+// The SCC body, with a parameterized export target.
+fn src(export: &str) -> String {
+    format!(r#"
+        let edges = input 0 | key($0[0] ; $0[1]);
+        let trans = edges | key($1 ; $0);
+        outer: {{
+            let scc = edges + trim;
+            fwd: {{
+                let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+                let labels = proposals + nodes | min;
+                var proposals = labels | join(scc, ($2 ; $1));
+            }}
+            let trim_fwd = edges
+                | join(fwd::labels, ($1 ; $0, $2))
+                | join(fwd::labels, ($0 ; $1, $2))
+                | filter($1[1] == $1[2])
+                | key($0 ; $1[0]);
+            bwd: {{
+                let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+                let labels = proposals + nodes | min;
+                var proposals = labels | join(trim_fwd, ($2 ; $1));
+            }}
+            let trim_bwd = trans
+                | join(bwd::labels, ($1 ; $0, $2))
+                | join(bwd::labels, ($0 ; $1, $2))
+                | filter($1[1] == $1[2])
+                | key($0 ; $1[0]);
+            let fl = fwd::labels;
+            let bl = bwd::labels;
+            var trim = trim_bwd - edges;
+        }}
+        export "result" = {export} | arrange;
+    "#)
+}
+
+fn compile(export: &str) -> interactive::scope_ir::Program {
+    let mut p = lower::lower_tree(parse::pipe::parse(&src(export)));
+    p.optimize();
+    p
+}
+
+fn main() {
+    let inputs = vec![edges()];
+    // From the inside out: labels feed trims feed the next scope feed scc.
+    for target in ["outer::fl", "outer::trim_fwd", "outer::bl", "outer::trim_bwd", "outer::scc"] {
+        // Some intermediates may not be exportable across scopes; skip on compile/eval panic.
+        let res = std::panic::catch_unwind(|| {
+            let prog = compile(target);
+            let co = corgi::evaluate(&prog, &inputs);
+            let ve = vec::evaluate(&prog, &inputs);
+            (co, ve)
+        });
+        match res {
+            Ok((co, ve)) => {
+                let tag = if co == ve { "OK  " } else { "DIFF" };
+                println!("[{tag}] {target}");
+                if co != ve {
+                    println!("       corgi = {co:?}");
+                    println!("       vec   = {ve:?}");
+                }
+            }
+            Err(_) => println!("[skip] {target} (not exportable)"),
+        }
+    }
+}

From 31ff53580086ea6aa8d1cf9875e485cee7aacd38 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 09:12:19 -0400
Subject: [PATCH 29/68] Pin corgi SCC bug to the reduce via update-stream diff
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

corgi_scc_stream: emit the full (data,time,diff) stream of SCC intermediates via
inspect, per backend; diff consolidated by (data,time) to find the first moment
of divergence (DD is deterministic at all times).

Result on the minimal 4-node graph: fwd::labels and trim_fwd streams AGREE
exactly (the 16-vs-10 raw counts were +1/-1 that consolidate away). The bwd
min-reduce: its INPUT (proposals+nodes) diverges only at inner-times 258/513,
but its OUTPUT diverges at 257/512 — one tick earlier. So at time (0,[1,257])
the reduce input agrees while the output diverges (vec retracts node2->1, corgi
does not). By the inputs-agree-output-differs test, the bug is IN the corgi
min-reduce. The int_proxy tactic is proven on SCC (scc_int_proxy), so it's the
CorgiReduceBackend (present/materialize/changed-key), not the tactic. The
forward min-reduce (same code) is correct -> a data-specific edge case.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/examples/corgi_scc_stream.rs | 69 ++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 interactive/examples/corgi_scc_stream.rs

diff --git a/interactive/examples/corgi_scc_stream.rs b/interactive/examples/corgi_scc_stream.rs
new file mode 100644
index 000000000..b2e6d12aa
--- /dev/null
+++ b/interactive/examples/corgi_scc_stream.rs
@@ -0,0 +1,69 @@
+//! Emit the full (data, time, diff) update STREAM of SCC intermediates on the minimal 4-node repro,
+//! via `inspect`, for one backend (BACKEND=corgi|vec). Diff the two streams offline (consolidated by
+//! (data, time)) to find the FIRST moment of divergence — the operator whose inputs agree but output
+//! does not is the bug.
+//!
+//!   BACKEND=corgi ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_stream 2>c.txt
+//!   BACKEND=vec   ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_stream 2>v.txt
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+type Row = Value;
+
+fn tup(a: i64, b: i64) -> Row {
+    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
+}
+
+fn edges() -> Vec<(Row, Row)> {
+    [(0, 0), (0, 2), (1, 3), (2, 1), (2, 2)]
+        .iter()
+        .map(|&(a, b)| (tup(a, b), Value::unit()))
+        .collect()
+}
+
+// SCC with `inspect` taps on fwd::labels, trim_fwd, bwd::labels (each lifted to the outer scope).
+const SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges
+            | join(fwd::labels, ($1 ; $0, $2))
+            | join(fwd::labels, ($0 ; $1, $2))
+            | filter($1[1] == $1[2])
+            | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let bin = proposals + nodes | inspect(bwdin);
+            let labels = bin | min | inspect(bwdout);
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans
+            | join(bwd::labels, ($1 ; $0, $2))
+            | join(bwd::labels, ($0 ; $1, $2))
+            | filter($1[1] == $1[2])
+            | key($0 ; $1[0]);
+        let fl = fwd::labels | inspect(fl);
+        let tf = trim_fwd | inspect(tf);
+        let bl = bwd::labels | inspect(bl);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | arrange;
+"#;
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(SRC));
+    p.optimize();
+    let inputs = vec![edges()];
+    match std::env::var("BACKEND").as_deref() {
+        Ok("vec") => { vec::evaluate(&p, &inputs); }
+        _ => { corgi::evaluate(&p, &inputs); }
+    }
+}

From 6aa4bf2f28ded6b79c06239aa6cfc136541b7c43 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 09:20:00 -0400
Subject: [PATCH 30/68] Pin corgi SCC bug: reduce-input present/arrange LOSES a
 record

Instrumented CorgiReduceBackend::present_input (env CORGI_DBG) to dump node-2's
presented input on the minimal repro, and compared to vec's true input stream:
for (node2, label1), vec has [0,257]+1 [0,258]+1 then [1,257]-1 [1,258]-1
(added round 0, retracted round 1 -> gone); corgi's present has [0,257]+1
[0,258]+1 [1,258]+1 -- the round-1 retractions are MISSING (plus a spurious +1).
And corgi's input STREAM (bwdin) agrees with vec at [1,257] (both -1), so the
retraction enters the arrange but present_input never returns it. => corgi loses
a reduce-input update when arranging/presenting under nested times; the min then
reads a non-retracted label1 and stays stale = 1. Not the min logic, not the
int_proxy tactic (proven) -- the reduce-input arrangement (CorgiChunk) or
present_input's changed-key/novel-history read.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index a7b9f2bff..149352289 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -369,6 +369,16 @@ where
         let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
         self.in_vals = gather(&vals_col, &reps);
         self.in_value_ids = chunk.value_ids().to_vec();
+        if std::env::var("CORGI_DBG").is_ok() {
+            let kcol = gather(&keys_col, &reps);
+            let krows = crate::corgi_logic::untranscode(kcol.clone(), &corgi::shape_of_value(&kcol));
+            let vrows = crate::corgi_logic::untranscode(self.in_vals.clone(), &corgi::shape_of_value(&self.in_vals));
+            for i in 0..chunk.len() {
+                if format!("{:?}", krows[i]).contains("Int(2)") {
+                    eprintln!("  [PIN] key={:?} val={:?} t={:?} d={}", krows[i], vrows[i], chunk.times()[i], chunk.diffs()[i]);
+                }
+            }
+        }
         // Register representative keys (aligned with the sorted presentation) for materialize.
         let rep_keys = gather(&keys_col, &reps);
         self.register_keys(rep_keys, chunk.key_hashes());

From 8a92391d5f1a9e75438c08e027ba3cf3c72a0738 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 09:32:53 -0400
Subject: [PATCH 31/68] Complete SCC diagnosis: compaction cancels a novel
 retraction, erasing an interesting time

Full per-retire dump (CORGI_DBG in present_input/present_output/materialize) on
the 4-node repro nails the mechanism:
 1. corgi's reduce-input TRACE compacts the round-0 add (node2,label1)[0,257]+1
    (present in the input stream) forward to [1,257]+1.
 2. the novel retraction (node2,label1)[1,257]-1 then EXACTLY CANCELS it inside
    present_input's consolidation (from_unsorted drops the net-0 record) -> the
    (node2,label1) record at time [1,257] DISAPPEARS from the presentation.
 3. the int_proxy tactic seeds interesting times from the presentation, so with
    [1,257] erased it never re-evaluates node2's min there and never emits the
    retraction of node2->1 (materialize shows label1 only ever emitted +1, never
    -1) -> node2->1 is stuck -> wrong SCC.
The reference (VecChunk) passes SCC because it doesn't compact that record onto
[1,257] at that retire, so the novel retraction stays a distinct interesting
time. Root: trace compaction advancing a history record onto the same time as an
incoming novel retraction cancels it in present, erasing an interesting time the
reduce needed. Not the min logic, not the int_proxy tactic. Debug taps are
CORGI_DBG-gated. gate green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 36 ++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 149352289..188bd3700 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -370,6 +370,22 @@ where
         self.in_vals = gather(&vals_col, &reps);
         self.in_value_ids = chunk.value_ids().to_vec();
         if std::env::var("CORGI_DBG").is_ok() {
+            eprintln!("  [RETIRE] changed_has_node2_hash? novel_chunks={} hist_chunks={}", chunks_of(novel).len(), chunks_of(history).len());
+            // RAW: every node-2 record in the incoming arrangement batches (novel + history), BEFORE
+            // present's changed-key filter — i.e. what the CorgiChunk arrange actually produced.
+            for (tag, chs) in [("novel", chunks_of(novel)), ("hist", chunks_of(history))] {
+                for ch in &chs {
+                    if ch.keys().len() == 0 { continue; }
+                    let kr = crate::corgi_logic::untranscode(ch.keys().clone(), &corgi::shape_of_value(ch.keys()));
+                    let vr = crate::corgi_logic::untranscode(ch.vals().clone(), &corgi::shape_of_value(ch.vals()));
+                    for i in 0..kr.len() {
+                        if format!("{:?}", kr[i]).contains("Int(2)") {
+                            eprintln!("  [RAW-{tag}] key={:?} val={:?} t={:?} d={}", kr[i], vr[i], ch.times()[i], ch.diffs()[i]);
+                        }
+                    }
+                }
+            }
+            // PIN: what present actually returns to the tactic (after filter + consolidate).
             let kcol = gather(&keys_col, &reps);
             let krows = crate::corgi_logic::untranscode(kcol.clone(), &corgi::shape_of_value(&kcol));
             let vrows = crate::corgi_logic::untranscode(self.in_vals.clone(), &corgi::shape_of_value(&self.in_vals));
@@ -395,8 +411,17 @@ where
         let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
         // Register representative output keys and values (aligned with the sorted presentation).
         let rep_keys = gather(&keys_col, &reps);
-        self.register_keys(rep_keys, chunk.key_hashes());
         let rep_vals = gather(&vals_col, &reps);
+        if std::env::var("CORGI_DBG").is_ok() {
+            let kr = crate::corgi_logic::untranscode(rep_keys.clone(), &corgi::shape_of_value(&rep_keys));
+            let vr = crate::corgi_logic::untranscode(rep_vals.clone(), &corgi::shape_of_value(&rep_vals));
+            for i in 0..chunk.len() {
+                if format!("{:?}", kr[i]).contains("Int(2)") {
+                    eprintln!("  [POUT-current] key={:?} val={:?} t={:?} d={}", kr[i], vr[i], chunk.times()[i], chunk.diffs()[i]);
+                }
+            }
+        }
+        self.register_keys(rep_keys, chunk.key_hashes());
         self.register_vals(rep_vals, chunk.value_ids());
         chunk
     }
@@ -420,6 +445,15 @@ where
             .collect();
         let keys = gather(&key_pool, &kidx);
         let vals = gather(&val_pool, &vidx);
+        if std::env::var("CORGI_DBG").is_ok() {
+            let kr = crate::corgi_logic::untranscode(keys.clone(), &corgi::shape_of_value(&keys));
+            let vr = crate::corgi_logic::untranscode(vals.clone(), &corgi::shape_of_value(&vals));
+            for i in 0..records.len() {
+                if format!("{:?}", kr[i]).contains("Int(2)") {
+                    eprintln!("  [MAT-emit] key={:?} val={:?} t={:?} d={}", kr[i], vr[i], records.times()[i], records.diffs()[i]);
+                }
+            }
+        }
         Rc::new(columns_to_batch(keys, vals, records.times().to_vec(), records.diffs().to_vec(), description))
     }
 }

From 64ea35c02cb8df53c4ae53c8b56f16746b2b8dd3 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 10:35:48 -0400
Subject: [PATCH 32/68] Adopt int_proxy seed fix (fm/int-proxy 960a6ec4) +
 implement present_novel in corgi
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Framework (cherry-pick of the model-prescribed fix): ProxyReduceBackend::key_hashes
-> present_novel(novel) -> ProxyChunk. The tactic now seeds interesting times and
the synthetic-join closure from the BATCH's own support (present_novel = the novel
batches presented ALONE), matching Model.lean's `seedSet = b.support ∪ pending`,
instead of time-filtering the merged present_input. This fixes the SCC divergence
(scenario1_cancels): a legally-compacted stored record could cancel a novel
retraction out of the merged view, silently dropping a seed while a retraction was
still owed. Kept my churn-reduce edits (buffer reuse, IdMap, radix from_unsorted).

Corgi backend: CorgiReduceBackend implements present_novel (read novel chunks alone,
unfiltered -> from_unsorted), drops key_hashes; present_input simplified (novel keys
are all in `keys`, so one binary_search filter — dropped the seen<novel_len hack).
Removed the CORGI_DBG diagnostic taps.

Verification: corgi_scc_min sweep NO mismatch (was 4-node divergence); corgi_progs
all 6 == vec; DD int_proxy (11, incl. new seed/cancellation + compaction-adversary
fuzz) + reduce_reference (21) green. Scorecard: reduce ~parity (present_novel adds
a per-retire present pass, same cost the reference backend accepts); reach ~parity;
scc now CORRECT end-to-end (still ~2x slower — the sharp recursive case).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/reduce.rs         |  74 ++++++++----
 .../src/operators/int_proxy/reference.rs      |  18 +--
 differential-dataflow/tests/int_proxy.rs      | 109 ++++++++++++++++--
 interactive/src/corgi_reduce_backend.rs       |  76 +++---------
 4 files changed, 171 insertions(+), 106 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index 80005f0cc..31ac9902b 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -41,12 +41,23 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// Diff type of the output; the desired-vs-current delta needs negation.
     type ROut: Abelian + 'static;
 
-    /// The `key_hash`es appearing in `batches`, sorted and deduplicated. Used by the
-    /// tactic to find the keys whose output can change this interval.
-    fn key_hashes(&self, batches: &[B1]) -> Vec<u64>;
+    /// (read) Present the freshly arrived batches ALONE as a sorted, consolidated proxy
+    /// run: the batch's own support, before any merge with stored history. Unfiltered —
+    /// the batches are the delta — and also how the tactic learns the changed keys.
+    ///
+    /// Seeding interesting times from this run (rather than from a time-filter over the
+    /// merged presentation) is load-bearing for CORRECTNESS, not just structure: legal
+    /// compaction may advance a stored record onto a novel record's exact
+    /// `(value, time)`, cancelling it out of the merged view while the batch still owes
+    /// output changes at that time. The formal model pins this: seeds are
+    /// `b.support ∪ pending` (`Model.lean`'s `seedSet`; its `scenario1_cancels` is
+    /// exactly the compaction-cancellation case).
+    fn present_novel(&mut self, novel: &[B1]) -> ProxyChunk<B1::Time, Self::RIn>;
     /// (read) Flatten the input history (`history` ∪ `novel`, the accumulated trace and
     /// the freshly arrived batches) into one sorted, consolidated proxy run, restricted to
-    /// the sorted `keys`. The restriction is load-bearing: presenting only changed keys is
+    /// the sorted `keys` — the ACCUMULATION run (consolidation across history and novel
+    /// is fine here: compaction is accumulation-preserving; only seeding must not read
+    /// this view). The restriction is load-bearing: presenting only changed keys is
     /// what keeps small-delta recursion from re-reading the accumulated trace each round.
     fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, Self::RIn>;
     /// (read) As `present_input`, for the operator's own output trace. The `value_id`s
@@ -146,7 +157,8 @@ where
         // Only keys touched by the new input delta or carrying pending times can change
         // output in [lower, upper); everything else is untouched. This restriction keeps
         // per-retire cost proportional to the delta, not the accumulation.
-        let mut changed: BTreeSet<u64> = self.backend.key_hashes(&input_batches).into_iter().collect();
+        let p_novel = self.backend.present_novel(&input_batches);
+        let mut changed: BTreeSet<u64> = p_novel.key_hashes().iter().copied().collect();
         changed.extend(self.pending.keys().copied());
         if changed.is_empty() {
             // No input delta and no carried pending: no key's output can change, and
@@ -193,7 +205,7 @@ where
         // Reused across keys (cleared each iteration) so per-key work doesn't reallocate.
         let mut rep: Vec<(u64, usize)> = Vec::new();
         let mut raw_moments: Vec<(B1::Time, (usize, usize))> = Vec::new();
-        let (mut is, mut os) = (0usize, 0usize);
+        let (mut is, mut os, mut ns) = (0usize, 0usize, 0usize);
         for &key in &changed {
             while is < p_in.len() && p_in.key_hashes()[is] < key { is += 1; }
             let i0 = is;
@@ -203,6 +215,10 @@ where
             let o0 = os;
             while os < p_out.len() && p_out.key_hashes()[os] == key { os += 1; }
             let o1 = os;
+            while ns < p_novel.len() && p_novel.key_hashes()[ns] < key { ns += 1; }
+            let n0 = ns;
+            while ns < p_novel.len() && p_novel.key_hashes()[ns] == key { ns += 1; }
+            let n1 = ns;
 
             // value_id → representative record index (the first of the vid's run; the
             // key's records are sorted by (value_id, time)).
@@ -217,7 +233,7 @@ where
             raw_moments.clear();
             let mut pended: Vec<B1::Time> = Vec::new();
             discover_and_accumulate(
-                &p_in, i0, i1, &rep, pending, lower, upper,
+                &p_in, i0, i1, &p_novel, n0, n1, &rep, pending, upper,
                 &mut raw_moments, &mut entries, &mut pended,
             );
             if !pended.is_empty() {
@@ -361,14 +377,21 @@ where
 /// Phase A of one key's retire: the time-replay loop of the cursor tactic
 /// (`history_replay::compute`), ported to proxy space with the value callback deferred.
 ///
-/// It replays the key's input records — split into `prior` (before `lower`, the
-/// accumulated history) and the novel interval — together with the carried `pending`
+/// It replays the key's NOVEL batch records (`p_novel[n0..n1]` — the batch's own
+/// support, presented apart from the stored history) together with the carried `pending`
 /// times, in ascending time order, discovering the interesting times: those carrying
-/// novel or pending updates, and joins thereof (synthesized as replay proceeds). At each
-/// interesting time within `[lower, upper)` it assembles the consolidated input
-/// accumulation as a bracket appended to `entries` (recorded in `moments` with its entry
-/// range; an empty range marks a moment whose accumulation vanished but whose current
-/// output may need retracting). Times at or beyond `upper` are `pended`.
+/// novel or pending updates, and joins thereof (synthesized as replay proceeds). The
+/// merged input presentation (`p_in[i0..i1]`, which already contains the novel records)
+/// is replayed alongside purely for ACCUMULATION: at each interesting time within the
+/// interval its buffer supplies the consolidated input, appended to `entries` as a
+/// bracket (recorded in `moments` with its entry range; an empty range marks a moment
+/// whose accumulation vanished but whose current output may need retracting). Times at
+/// or beyond `upper` are `pended`.
+///
+/// Seeding from the batch's own support — never from a time-filter over the merged
+/// presentation — is the formal model's `seedSet = b.support ∪ pending`: compaction can
+/// legally advance a stored record onto a novel one and cancel it out of the MERGED
+/// view, but it still owes changes at that time (`scenario1_cancels`).
 ///
 /// The replay buffers are repeatedly advanced by the meet of the times still to come and
 /// consolidated — the collapse that keeps a key with many distinct times linear rather
@@ -378,9 +401,11 @@ fn discover_and_accumulate<T, RIn>(
     p_in: &ProxyChunk<T, RIn>,
     i0: usize,
     i1: usize,
+    p_novel: &ProxyChunk<T, RIn>,
+    n0: usize,
+    n1: usize,
     rep: &[(u64, usize)],
     pending: &[T],
-    lower: &Antichain<T>,
     upper: &Antichain<T>,
     moments: &mut Vec<(T, (usize, usize))>,
     entries: &mut Vec<(usize, RIn)>,
@@ -389,12 +414,11 @@ fn discover_and_accumulate<T, RIn>(
     T: Timestamp + Lattice,
     RIn: Semigroup + Clone,
 {
-    // The novel interval's records seed interestingness; prior records are join partners.
+    // The batch's support seeds interestingness (and its buffered times generate joins);
+    // its diffs do NOT feed accumulation — the merged run below already contains them.
     let mut batch_replay = IdHistory::new();
     batch_replay.load(
-        (i0..i1)
-            .filter(|&i| lower.less_equal(&p_in.times()[i]))
-            .map(|i| (p_in.value_ids()[i], p_in.times()[i].clone(), p_in.diffs()[i].clone())),
+        (n0..n1).map(|i| (p_novel.value_ids()[i], p_novel.times()[i].clone(), p_novel.diffs()[i].clone())),
         None,
     );
 
@@ -409,11 +433,10 @@ fn discover_and_accumulate<T, RIn>(
     update_meet(&mut meet, meets.first());
     update_meet(&mut meet, batch_replay.meet());
 
+    // The merged (history ⊎ novel, consolidated) run: the accumulation source.
     let mut input_replay = IdHistory::new();
     input_replay.load(
-        (i0..i1)
-            .filter(|&i| !lower.less_equal(&p_in.times()[i]))
-            .map(|i| (p_in.value_ids()[i], p_in.times()[i].clone(), p_in.diffs()[i].clone())),
+        (i0..i1).map(|i| (p_in.value_ids()[i], p_in.times()[i].clone(), p_in.diffs()[i].clone())),
         meet.as_ref(),
     );
 
@@ -454,10 +477,11 @@ fn discover_and_accumulate<T, RIn>(
                 if let Some(m) = meet.as_ref() {
                     input_replay.advance_buffer_by(m);
                 }
-                // Assemble the accumulation at `next_time` from both buffers; buffered
-                // times beyond it contribute synthetic joins.
+                // Assemble the accumulation at `next_time` from the merged run's buffer
+                // (the batch's records are already in it — the batch buffer must not
+                // contribute diffs twice); buffered times beyond it contribute joins.
                 let mut acc: Vec<(u64, RIn)> = Vec::new();
-                for ((vid, t), d) in input_replay.buffer().iter().chain(batch_replay.buffer().iter()) {
+                for ((vid, t), d) in input_replay.buffer().iter() {
                     if t.less_equal(&next_time) {
                         acc.push((*vid, d.clone()));
                     } else {
diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
index 8fd31d329..b32f74e3d 100644
--- a/differential-dataflow/src/operators/int_proxy/reference.rs
+++ b/differential-dataflow/src/operators/int_proxy/reference.rs
@@ -250,18 +250,12 @@ where
     type RIn = RIn;
     type ROut = ROut;
 
-    fn key_hashes(&self, batches: &[RefBatch<K, V, T, RIn>]) -> Vec<u64> {
-        let mut hashes = Vec::new();
-        for batch in batches {
-            let mut cursor = batch.cursor();
-            while let Some(k) = cursor.get_key(batch) {
-                hashes.push(stable_hash(k));
-                cursor.step_key(batch);
-            }
-        }
-        hashes.sort_unstable();
-        hashes.dedup();
-        hashes
+    fn present_novel(&mut self, novel: &[RefBatch<K, V, T, RIn>]) -> ProxyChunk<T, RIn> {
+        // The batch's own support: read the (delta-sized) novel batches alone, never
+        // merged with stored history, so no compacted record can cancel a seed.
+        let mut rows = Rows::new();
+        rows.scan(novel);
+        rows.present().0
     }
 
     fn present_input(&mut self, history: &[RefBatch<K, V, T, RIn>], novel: &[RefBatch<K, V, T, RIn>], keys: &[u64]) -> ProxyChunk<T, RIn> {
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index b02054be6..4f9763618 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -375,8 +375,10 @@ where
     type RIn = B::RIn;
     type ROut = B::ROut;
 
-    fn key_hashes(&self, batches: &[B1]) -> Vec<u64> {
-        self.inner.key_hashes(batches)
+    fn present_novel(&mut self, novel: &[B1]) -> ProxyChunk<B1::Time, B::RIn> {
+        let chunk = self.inner.present_novel(novel);
+        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
+        chunk
     }
     fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, B::RIn> {
         let chunk = self.inner.present_input(history, novel, keys);
@@ -616,11 +618,9 @@ mod identity {
         type RIn = isize;
         type ROut = isize;
 
-        fn key_hashes(&self, batches: &[Batch<T>]) -> Vec<u64> {
-            let (mut ks, _, _, _) = records(batches, None);
-            ks.sort_unstable();
-            ks.dedup();
-            ks
+        fn present_novel(&mut self, novel: &[Batch<T>]) -> ProxyChunk<T, isize> {
+            let (ks, vs, ts, ds) = records(novel, None);
+            ProxyChunk::from_unsorted(ks, vs, ts, ds).0
         }
 
         fn present_input(&mut self, history: &[Batch<T>], novel: &[Batch<T>], keys: &[u64]) -> ProxyChunk<T, isize> {
@@ -678,9 +678,16 @@ mod identity {
 /// emulating the driver protocol: `lower` chases `upper`, `held` is the previous
 /// returned frontier joined with the round's input times (the batch capabilities),
 /// and source/output batch lists accumulate.
-fn drive_identity_reduce<L>(
+/// Drive `ProxyReduceTactic` over the identity backend through a sequence of retires,
+/// emulating the driver protocol. With `compact`, plays the COMPACTION ADVERSARY: before
+/// each retire, every accumulated source and output batch has its times advanced to the
+/// interval's lower bound and is re-consolidated — accumulation-preserving (the model's
+/// `acc_mapDomain`), and exactly the move that can cancel a stored record against a
+/// novel one in a merged view. A correct tactic's output must not change.
+fn drive_identity_reduce_compacting<L>(
     rounds: &[(Antichain<PT>, Vec<((u64, u64), PT, isize)>)],
     logic: L,
+    compact: bool,
 ) -> Vec<((u64, u64), PT, isize)>
 where
     L: FnMut(&[(u64, isize)]) -> Vec<(u64, isize)>,
@@ -688,6 +695,9 @@ where
     use differential_dataflow::operators::int_proxy::ProxyChunk;
     use differential_dataflow::trace::chunk::ChunkBatch;
 
+    #[allow(unused_imports)]
+    use differential_dataflow::trace::BatchReader as _;
+
     let mut tactic = ProxyReduceTactic::new(identity::IdentityReduce::new(logic));
     let mut lower = Antichain::from_elem(pt(0, 0));
     let mut frontier: Antichain<PT> = Antichain::new();
@@ -715,6 +725,31 @@ where
             held.insert(t.clone());
         }
 
+        if compact {
+            use differential_dataflow::lattice::Lattice;
+            let advance = |batches: &mut Vec<identity::Batch<PT>>| {
+                for batch in batches.iter_mut() {
+                    let (mut ks, mut vs) = (Vec::new(), Vec::new());
+                    let (mut ts, mut ds) = (Vec::new(), Vec::new());
+                    for chunk in &batch.chunks {
+                        for i in 0..chunk.len() {
+                            ks.push(chunk.key_hashes()[i]);
+                            vs.push(chunk.value_ids()[i]);
+                            let mut t = chunk.times()[i].clone();
+                            t.advance_by(lower.borrow());
+                            ts.push(t);
+                            ds.push(chunk.diffs()[i]);
+                        }
+                    }
+                    let (chunk, _) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
+                    let chunks = if chunk.is_empty() { Vec::new() } else { vec![chunk] };
+                    *batch = std::rc::Rc::new(ChunkBatch::new(chunks, batch.description().clone()));
+                }
+            };
+            advance(&mut source);
+            advance(&mut outputs);
+        }
+
         let (produced, new_frontier) = tactic.retire(source.clone(), outputs.clone(), input.clone(), &lower, upper, &held);
         for (_, batch) in produced {
             for chunk in &batch.chunks {
@@ -798,7 +833,8 @@ fn proxy_reduce_identity_fuzz_matches_grid_oracle() {
         let tail = updates.iter().filter(|(_, t, _)| t.outer + t.inner >= prev).cloned().collect();
         rounds.push((Antichain::new(), tail));
 
-        let produced = drive_identity_reduce(&rounds, logic);
+        let compact = iteration % 2 == 1;
+        let produced = drive_identity_reduce_compacting(&rounds, logic, compact);
 
         // The oracle: at every grid point, per key, the accumulated output equals the
         // reduction of the accumulated input.
@@ -1047,3 +1083,58 @@ fn proxy_join_scaling() {
         .sum();
     assert_eq!(total, 0);
 }
+
+/// The formal model's `scenario1_cancels`, realized against a compacted trace (the SCC
+/// field bug): compaction legally advances a stored `+1` onto a novel `−1`'s exact
+/// `(value, time)`, so the two cancel in the merged input presentation — but the batch
+/// still owes a change there (the standing output must be retracted). Interesting-time
+/// seeds must come from the batch's own support (`seedSet = b.support ∪ pending`), never
+/// from a time-filter over the merged view.
+#[test]
+fn proxy_reduce_seeds_survive_compaction_cancellation() {
+    let count = |_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
+        let c: isize = input.iter().map(|(_, d)| *d).sum();
+        if c > 0 {
+            output.push((c, 1));
+        }
+    };
+    let mut tactic = ProxyReduceTactic::new(VecReduceBackend::new(count));
+
+    // Retire 1: (key 1, value 10) +1 at (0,1); interval [(0,0), {(1,1)}).
+    let batch1 = pbatch(vec![((1u64, 10u64), pt(0, 1), 1)], vec![pt(0, 0)], vec![pt(1, 1)]);
+    let lower1 = Antichain::from_elem(pt(0, 0));
+    let upper1 = Antichain::from_elem(pt(1, 1));
+    let held1 = Antichain::from_elem(pt(0, 1));
+    let (produced1, _) = tactic.retire(vec![], vec![], vec![batch1], &lower1, &upper1, &held1);
+    assert_eq!(produced1.len(), 1);
+    assert_eq!(pbatch_rows(&produced1[0].1), vec![((1, 1isize), pt(0, 1), 1)]);
+
+    // Between retires the trace compacts to since = {(1,1)} — legal, since every later
+    // evaluation time is at or beyond it. advance_by maps (0,1) → (1,1) in both the
+    // source and the output trace.
+    let source_compacted = pbatch(vec![((1u64, 10u64), pt(1, 1), 1)], vec![pt(0, 0)], vec![pt(1, 1)]);
+    let output_compacted = pbatch(vec![((1u64, 1isize), pt(1, 1), 1)], vec![pt(0, 0)], vec![pt(1, 1)]);
+
+    // Retire 2: the novel batch retracts the input at exactly (1,1) — the time the
+    // compacted stored record now occupies. Merged and consolidated, they cancel; the
+    // batch support still holds (1,1), and the owed output retraction hangs on it.
+    let batch2 = pbatch(vec![((1u64, 10u64), pt(1, 1), -1)], vec![pt(1, 1)], vec![]);
+    let lower2 = upper1.clone();
+    let upper2 = Antichain::new();
+    let held2 = Antichain::from_elem(pt(1, 1));
+    let (produced2, frontier2) = tactic.retire(
+        vec![source_compacted],
+        vec![output_compacted],
+        vec![batch2],
+        &lower2,
+        &upper2,
+        &held2,
+    );
+    let rows: Vec<_> = produced2.iter().flat_map(|(_, b)| pbatch_rows(b)).collect();
+    assert_eq!(
+        rows,
+        vec![((1, 1isize), pt(1, 1), -1)],
+        "the standing count must be retracted at (1,1); an empty result means the seed was cancelled out of the merged presentation"
+    );
+    assert!(frontier2.is_empty());
+}
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 188bd3700..22cd31946 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -335,30 +335,30 @@ where
     type RIn = Diff;
     type ROut = Diff;
 
-    fn key_hashes(&self, batches: &[CBatch<T>]) -> Vec<u64> {
-        let mut hashes = Vec::new();
-        for ch in chunks_of(batches) {
-            hashes.extend(hash_rows(ch.keys()));
+    fn present_novel(&mut self, novel: &[CBatch<T>]) -> ProxyChunk<T, Diff> {
+        // The batch's own support: read the (delta-sized) novel batches ALONE, unfiltered and never
+        // merged with stored history, so no compacted history record can cancel a seed. Also how the
+        // tactic learns the changed keys (its key set is the delta's keys).
+        let chunks = chunks_of(novel);
+        let (_keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |_| true);
+        if khs.is_empty() {
+            return ProxyChunk::default();
         }
-        hashes.sort_unstable();
-        hashes.dedup();
-        hashes
+        let vids = hash_rows(&vals_col);
+        let (chunk, _reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
+        chunk
     }
 
     fn present_input(&mut self, history: &[CBatch<T>], novel: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
         self.reset_pools();
 
-        // Read novel whole + history filtered to the changed keys (columnar semijoin). Novel chunks
-        // come first, so the first `novel_len` candidate records are the (unfiltered) novel side.
+        // History ∪ novel, restricted to the changed keys (a columnar semijoin). Novel keys are all in
+        // `keys` (the delta's keys, as `present_novel` reports them), so this keeps the novel side whole
+        // and filters the accumulated history to the changed keys. The seeds come from `present_novel`;
+        // this merged run is used only for accumulation (compaction here is accumulation-preserving).
         let mut chunks = chunks_of(novel);
         chunks.extend(chunks_of(history));
-        let novel_len: usize = chunks_of(novel).iter().map(|c| c.keys().len()).sum();
-        let mut seen = 0usize;
-        let (keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| {
-            let keep = seen < novel_len || keys.binary_search(&h).is_ok();
-            seen += 1;
-            keep
-        });
+        let (keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| keys.binary_search(&h).is_ok());
 
         if khs.is_empty() {
             self.in_vals = CValue::Unit(0);
@@ -369,32 +369,6 @@ where
         let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
         self.in_vals = gather(&vals_col, &reps);
         self.in_value_ids = chunk.value_ids().to_vec();
-        if std::env::var("CORGI_DBG").is_ok() {
-            eprintln!("  [RETIRE] changed_has_node2_hash? novel_chunks={} hist_chunks={}", chunks_of(novel).len(), chunks_of(history).len());
-            // RAW: every node-2 record in the incoming arrangement batches (novel + history), BEFORE
-            // present's changed-key filter — i.e. what the CorgiChunk arrange actually produced.
-            for (tag, chs) in [("novel", chunks_of(novel)), ("hist", chunks_of(history))] {
-                for ch in &chs {
-                    if ch.keys().len() == 0 { continue; }
-                    let kr = crate::corgi_logic::untranscode(ch.keys().clone(), &corgi::shape_of_value(ch.keys()));
-                    let vr = crate::corgi_logic::untranscode(ch.vals().clone(), &corgi::shape_of_value(ch.vals()));
-                    for i in 0..kr.len() {
-                        if format!("{:?}", kr[i]).contains("Int(2)") {
-                            eprintln!("  [RAW-{tag}] key={:?} val={:?} t={:?} d={}", kr[i], vr[i], ch.times()[i], ch.diffs()[i]);
-                        }
-                    }
-                }
-            }
-            // PIN: what present actually returns to the tactic (after filter + consolidate).
-            let kcol = gather(&keys_col, &reps);
-            let krows = crate::corgi_logic::untranscode(kcol.clone(), &corgi::shape_of_value(&kcol));
-            let vrows = crate::corgi_logic::untranscode(self.in_vals.clone(), &corgi::shape_of_value(&self.in_vals));
-            for i in 0..chunk.len() {
-                if format!("{:?}", krows[i]).contains("Int(2)") {
-                    eprintln!("  [PIN] key={:?} val={:?} t={:?} d={}", krows[i], vrows[i], chunk.times()[i], chunk.diffs()[i]);
-                }
-            }
-        }
         // Register representative keys (aligned with the sorted presentation) for materialize.
         let rep_keys = gather(&keys_col, &reps);
         self.register_keys(rep_keys, chunk.key_hashes());
@@ -412,15 +386,6 @@ where
         // Register representative output keys and values (aligned with the sorted presentation).
         let rep_keys = gather(&keys_col, &reps);
         let rep_vals = gather(&vals_col, &reps);
-        if std::env::var("CORGI_DBG").is_ok() {
-            let kr = crate::corgi_logic::untranscode(rep_keys.clone(), &corgi::shape_of_value(&rep_keys));
-            let vr = crate::corgi_logic::untranscode(rep_vals.clone(), &corgi::shape_of_value(&rep_vals));
-            for i in 0..chunk.len() {
-                if format!("{:?}", kr[i]).contains("Int(2)") {
-                    eprintln!("  [POUT-current] key={:?} val={:?} t={:?} d={}", kr[i], vr[i], chunk.times()[i], chunk.diffs()[i]);
-                }
-            }
-        }
         self.register_keys(rep_keys, chunk.key_hashes());
         self.register_vals(rep_vals, chunk.value_ids());
         chunk
@@ -445,15 +410,6 @@ where
             .collect();
         let keys = gather(&key_pool, &kidx);
         let vals = gather(&val_pool, &vidx);
-        if std::env::var("CORGI_DBG").is_ok() {
-            let kr = crate::corgi_logic::untranscode(keys.clone(), &corgi::shape_of_value(&keys));
-            let vr = crate::corgi_logic::untranscode(vals.clone(), &corgi::shape_of_value(&vals));
-            for i in 0..records.len() {
-                if format!("{:?}", kr[i]).contains("Int(2)") {
-                    eprintln!("  [MAT-emit] key={:?} val={:?} t={:?} d={}", kr[i], vr[i], records.times()[i], records.diffs()[i]);
-                }
-            }
-        }
         Rc::new(columns_to_batch(keys, vals, records.times().to_vec(), records.diffs().to_vec(), description))
     }
 }

From c5fbb6285a5b847150b3c5cdc504c89ee2d85df2 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 11:07:06 -0400
Subject: [PATCH 33/68] Adopt seed_times refinement (fm/int-proxy 34cc815) +
 implement it for corgi
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The other agent's slimmer fix: seeds need only the batch's (key_hash, time)
support, not a value-present. Interesting-time over-derivation is sound (a
non-changing seed yields a zero delta), and the tactic reads only TIMES from the
seed source — so no value hashing, value_ids, sort-by-value, or consolidation.
Trait: present_novel(&mut self) -> ProxyChunk  =>  seed_times(&self) -> Vec<(u64,T)>
(stateless — seeds never refer back to real values). history.rs gains TimeHistory
(times-only replay, same meet-advancement, keeps the scaling shapes linear). This
also sidesteps the value_id=0 trap (a ProxyChunk would re-consolidate distinct
values at one time into a dropped zero, reintroducing the cancellation bug).

Corgi: CorgiReduceBackend::seed_times = hash_rows(novel key columns) zipped with
the Rust-side times, sorted by key_hash — no from_unsorted, no value hashing on
the seed path. The expensive half of the per-retire double-present is gone; only
a delta-sized second key-hash remains (noise). This matters most on the common
SNAPSHOT-then-increment load, where present_novel had been ~doubling the present
work on the big first batch.

Verify: corgi_scc_min NO mismatch; corgi_progs all 6 == vec; DD int_proxy (11) +
reduce_reference (21) green. Scorecard reduce back to ~parity (distinct 0.99-1.01x,
count 0.98-1.00x — was 1.01-1.04x under present_novel), reach 0.97-1.08x.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/operators/int_proxy/history.rs        | 78 ++++++++++++++++++
 .../src/operators/int_proxy/reduce.rs         | 80 ++++++++++---------
 .../src/operators/int_proxy/reference.rs      | 24 ++++--
 differential-dataflow/tests/int_proxy.rs      | 17 ++--
 interactive/src/corgi_reduce_backend.rs       | 24 +++---
 5 files changed, 161 insertions(+), 62 deletions(-)

diff --git a/differential-dataflow/src/operators/int_proxy/history.rs b/differential-dataflow/src/operators/int_proxy/history.rs
index 2636d3371..84edcc1c0 100644
--- a/differential-dataflow/src/operators/int_proxy/history.rs
+++ b/differential-dataflow/src/operators/int_proxy/history.rs
@@ -97,3 +97,81 @@ impl<T: Lattice + Clone + Ord, R: Semigroup + Clone> IdHistory<T, R> {
     }
 
 }
+
+/// A replayable history of interesting *times* — the seed source, ported from the same
+/// [`ValueHistory`] machinery but carrying no values or diffs.
+///
+/// The reduce tactic seeds from the batch's `(key, time)` support and never reads the
+/// batch's values or diffs (only its times drive interestingness and the synthetic-join
+/// closure). Seeds may over-approximate `b.support` — a spurious interesting time yields
+/// a zero delta and is discarded — so the times are taken raw, unconsolidated. Meet-
+/// advancement still collapses the buffer, keeping a key with many distinct batch times
+/// linear (the `*_scaling` shapes) rather than quadratic.
+///
+/// [`ValueHistory`]: crate::operators::ValueHistory (private; see `operators/mod.rs`)
+pub(crate) struct TimeHistory<T> {
+    /// Un-replayed `(time, meet)`, sorted descending by time so popping replays ascending;
+    /// `meet` is the meet of this time with all times later in the replay.
+    history: Vec<(T, T)>,
+    /// Stepped-in times, advanced and deduplicated, sorted ascending.
+    buffer: Vec<T>,
+}
+
+impl<T: Lattice + Clone + Ord> TimeHistory<T> {
+    pub fn new() -> Self {
+        TimeHistory { history: Vec::new(), buffer: Vec::new() }
+    }
+
+    /// Load `times`, advancing each by `advance_by` if supplied, and organize the replay
+    /// (sort + suffix meets).
+    pub fn load(&mut self, times: impl Iterator<Item = T>, advance_by: Option<&T>) {
+        self.history.clear();
+        self.buffer.clear();
+        for mut time in times {
+            if let Some(m) = advance_by {
+                time = time.join(m);
+            }
+            self.history.push((time.clone(), time));
+        }
+        self.history.sort_by(|x, y| y.0.cmp(&x.0));
+        self.history.iter_mut().reduce(|prev, cur| {
+            cur.1.meet_assign(&prev.1);
+            cur
+        });
+    }
+
+    /// The next (least) un-replayed time.
+    pub fn time(&self) -> Option<&T> {
+        self.history.last().map(|x| &x.0)
+    }
+    /// The meet of all un-replayed times.
+    pub fn meet(&self) -> Option<&T> {
+        self.history.last().map(|x| &x.1)
+    }
+
+    /// Step times while the next equals `time`; true iff any did.
+    pub fn step_while_time_is(&mut self, time: &T) -> bool {
+        let mut found = false;
+        while self.time() == Some(time) {
+            found = true;
+            let (t, _) = self.history.pop().unwrap();
+            self.buffer.push(t);
+        }
+        found
+    }
+
+    /// Advance buffered times by `meet` and deduplicate — the collapse that keeps replay
+    /// linear.
+    pub fn advance_buffer_by(&mut self, meet: &T) {
+        for time in self.buffer.iter_mut() {
+            *time = time.join(meet);
+        }
+        self.buffer.sort();
+        self.buffer.dedup();
+    }
+
+    /// The buffered (stepped-in, advanced) times.
+    pub fn buffer(&self) -> &[T] {
+        &self.buffer
+    }
+}
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index 31ac9902b..8169718c6 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -12,7 +12,7 @@ use crate::trace::{BatchReader, Description};
 use crate::trace::chunk::int_proxy::ProxyChunk;
 use crate::operators::reduce::ReduceTactic;
 
-use super::history::IdHistory;
+use super::history::{IdHistory, TimeHistory};
 
 /// Identity hasher for `value_id`-keyed scratch maps: `value_id`s are already 64-bit content hashes,
 /// so re-hashing them is waste. Reused across moments (cleared, not reallocated) to avoid a
@@ -28,11 +28,11 @@ type IdMap<R> = HashMap<u64, R, BuildHasherDefault<IdHasher>>;
 
 /// The reduce backend: value semantics for a proxy-space reduction.
 ///
-/// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `key_hashes` (over the
-/// new input batches), one `present_input`, one `present_output`, ONE batched
-/// `reduce_many` call carrying every `(key, interesting time)` moment of the retire —
-/// with indices referring to the input presentation — then one `materialize` per output
-/// batch. Within
+/// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `seed_times` (over the
+/// new input batches — the batch's `(key, time)` support and the changed keys), one
+/// `present_input`, one `present_output`, ONE batched `reduce_many` call carrying every
+/// `(key, interesting time)` moment of the retire — with indices referring to the input
+/// presentation — then one `materialize` per output batch. Within
 /// one retire the backend must be able to resolve every presented `key_hash` to its key
 /// and every presented or minted `value_id` to its value.
 pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
@@ -41,18 +41,24 @@ pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>>
     /// Diff type of the output; the desired-vs-current delta needs negation.
     type ROut: Abelian + 'static;
 
-    /// (read) Present the freshly arrived batches ALONE as a sorted, consolidated proxy
-    /// run: the batch's own support, before any merge with stored history. Unfiltered —
-    /// the batches are the delta — and also how the tactic learns the changed keys.
+    /// (read) The freshly arrived batches' `(key_hash, time)` support: one entry per
+    /// novel record, sorted by `key_hash`. RAW — no merge with stored history, no
+    /// consolidation, no value work (no `value_id`, no diffs). Also how the tactic learns
+    /// the changed keys (their distinct `key_hash`es).
     ///
-    /// Seeding interesting times from this run (rather than from a time-filter over the
-    /// merged presentation) is load-bearing for CORRECTNESS, not just structure: legal
-    /// compaction may advance a stored record onto a novel record's exact
-    /// `(value, time)`, cancelling it out of the merged view while the batch still owes
-    /// output changes at that time. The formal model pins this: seeds are
-    /// `b.support ∪ pending` (`Model.lean`'s `seedSet`; its `scenario1_cancels` is
-    /// exactly the compaction-cancellation case).
-    fn present_novel(&mut self, novel: &[B1]) -> ProxyChunk<B1::Time, Self::RIn>;
+    /// Seeding interesting times from the batch's OWN times — never from a time-filter
+    /// over the merged accumulation — is load-bearing for CORRECTNESS: legal compaction
+    /// may advance a stored record onto a novel record's exact `(value, time)`,
+    /// cancelling it out of the merged view while the batch still owes output changes at
+    /// that time. The model pins this: seeds are `b.support ∪ pending` (`Model.lean`'s
+    /// `seedSet`; `scenario1_cancels` is the compaction-cancellation case).
+    ///
+    /// Cheap by design: seeds need only key hashes and times. Interesting-time
+    /// over-derivation is sound (a non-changing seed yields a zero delta), so the raw
+    /// novel times — a superset of `b.support` — suffice, and the tactic reads only times
+    /// from them. So this method does NOT hash values, assign `value_id`s, sort by value,
+    /// or consolidate; a full value-present of the delta happens once, in `present_input`.
+    fn seed_times(&self, novel: &[B1]) -> Vec<(u64, B1::Time)>;
     /// (read) Flatten the input history (`history` ∪ `novel`, the accumulated trace and
     /// the freshly arrived batches) into one sorted, consolidated proxy run, restricted to
     /// the sorted `keys` — the ACCUMULATION run (consolidation across history and novel
@@ -157,8 +163,9 @@ where
         // Only keys touched by the new input delta or carrying pending times can change
         // output in [lower, upper); everything else is untouched. This restriction keeps
         // per-retire cost proportional to the delta, not the accumulation.
-        let p_novel = self.backend.present_novel(&input_batches);
-        let mut changed: BTreeSet<u64> = p_novel.key_hashes().iter().copied().collect();
+        let seeds = self.backend.seed_times(&input_batches);
+        debug_assert!(seeds.windows(2).all(|w| w[0].0 <= w[1].0), "seed_times must be sorted by key_hash");
+        let mut changed: BTreeSet<u64> = seeds.iter().map(|(k, _)| *k).collect();
         changed.extend(self.pending.keys().copied());
         if changed.is_empty() {
             // No input delta and no carried pending: no key's output can change, and
@@ -215,9 +222,9 @@ where
             let o0 = os;
             while os < p_out.len() && p_out.key_hashes()[os] == key { os += 1; }
             let o1 = os;
-            while ns < p_novel.len() && p_novel.key_hashes()[ns] < key { ns += 1; }
+            while ns < seeds.len() && seeds[ns].0 < key { ns += 1; }
             let n0 = ns;
-            while ns < p_novel.len() && p_novel.key_hashes()[ns] == key { ns += 1; }
+            while ns < seeds.len() && seeds[ns].0 == key { ns += 1; }
             let n1 = ns;
 
             // value_id → representative record index (the first of the vid's run; the
@@ -232,8 +239,9 @@ where
 
             raw_moments.clear();
             let mut pended: Vec<B1::Time> = Vec::new();
+            let seed_times = seeds[n0..n1].iter().map(|(_, t)| t.clone());
             discover_and_accumulate(
-                &p_in, i0, i1, &p_novel, n0, n1, &rep, pending, upper,
+                &p_in, i0, i1, seed_times, &rep, pending, upper,
                 &mut raw_moments, &mut entries, &mut pended,
             );
             if !pended.is_empty() {
@@ -377,8 +385,8 @@ where
 /// Phase A of one key's retire: the time-replay loop of the cursor tactic
 /// (`history_replay::compute`), ported to proxy space with the value callback deferred.
 ///
-/// It replays the key's NOVEL batch records (`p_novel[n0..n1]` — the batch's own
-/// support, presented apart from the stored history) together with the carried `pending`
+/// It replays the key's NOVEL batch times (`seed_times` — the batch's own `(key, time)`
+/// support, raw, apart from the stored history) together with the carried `pending`
 /// times, in ascending time order, discovering the interesting times: those carrying
 /// novel or pending updates, and joins thereof (synthesized as replay proceeds). The
 /// merged input presentation (`p_in[i0..i1]`, which already contains the novel records)
@@ -388,10 +396,11 @@ where
 /// whose accumulation vanished but whose current output may need retracting). Times at
 /// or beyond `upper` are `pended`.
 ///
-/// Seeding from the batch's own support — never from a time-filter over the merged
+/// Seeding from the batch's own times — never from a time-filter over the merged
 /// presentation — is the formal model's `seedSet = b.support ∪ pending`: compaction can
 /// legally advance a stored record onto a novel one and cancel it out of the MERGED
-/// view, but it still owes changes at that time (`scenario1_cancels`).
+/// view, but it still owes changes at that time (`scenario1_cancels`). The seed times are
+/// raw (a superset of `b.support`); the spurious extras are sound over-derivation.
 ///
 /// The replay buffers are repeatedly advanced by the meet of the times still to come and
 /// consolidated — the collapse that keeps a key with many distinct times linear rather
@@ -401,9 +410,7 @@ fn discover_and_accumulate<T, RIn>(
     p_in: &ProxyChunk<T, RIn>,
     i0: usize,
     i1: usize,
-    p_novel: &ProxyChunk<T, RIn>,
-    n0: usize,
-    n1: usize,
+    seed_times: impl Iterator<Item = T>,
     rep: &[(u64, usize)],
     pending: &[T],
     upper: &Antichain<T>,
@@ -414,13 +421,10 @@ fn discover_and_accumulate<T, RIn>(
     T: Timestamp + Lattice,
     RIn: Semigroup + Clone,
 {
-    // The batch's support seeds interestingness (and its buffered times generate joins);
-    // its diffs do NOT feed accumulation — the merged run below already contains them.
-    let mut batch_replay = IdHistory::new();
-    batch_replay.load(
-        (n0..n1).map(|i| (p_novel.value_ids()[i], p_novel.times()[i].clone(), p_novel.diffs()[i].clone())),
-        None,
-    );
+    // The batch's times seed interestingness and generate the synthetic joins; the batch
+    // carries no values here — accumulation comes wholly from the merged run below.
+    let mut batch_replay = TimeHistory::new();
+    batch_replay.load(seed_times, None);
 
     // Suffix meets of the carried pending times (ascending, so meets accumulate from the end).
     let mut meets: Vec<T> = pending.to_vec();
@@ -469,7 +473,7 @@ fn discover_and_accumulate<T, RIn>(
             meets_slice = &meets_slice[1..];
             interesting = true;
         }
-        interesting = interesting || batch_replay.buffer().iter().any(|((_, t), _)| t.less_equal(&next_time));
+        interesting = interesting || batch_replay.buffer().iter().any(|t| t.less_equal(&next_time));
         interesting = interesting || times_current.iter().any(|t| t.less_equal(&next_time));
 
         if !upper.less_equal(&next_time) {
@@ -498,7 +502,7 @@ fn discover_and_accumulate<T, RIn>(
             }
             // Synthetic interesting times: joins with the remaining batch times and the
             // times seen so far.
-            temporary.extend(batch_replay.buffer().iter().map(|((_, t), _)| t).filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
+            temporary.extend(batch_replay.buffer().iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
             temporary.extend(times_current.iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
             sort_dedup(&mut temporary);
             let synth_len = synth.len();
diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
index b32f74e3d..a49324b10 100644
--- a/differential-dataflow/src/operators/int_proxy/reference.rs
+++ b/differential-dataflow/src/operators/int_proxy/reference.rs
@@ -250,12 +250,24 @@ where
     type RIn = RIn;
     type ROut = ROut;
 
-    fn present_novel(&mut self, novel: &[RefBatch<K, V, T, RIn>]) -> ProxyChunk<T, RIn> {
-        // The batch's own support: read the (delta-sized) novel batches alone, never
-        // merged with stored history, so no compacted record can cancel a seed.
-        let mut rows = Rows::new();
-        rows.scan(novel);
-        rows.present().0
+    fn seed_times(&self, novel: &[RefBatch<K, V, T, RIn>]) -> Vec<(u64, T)> {
+        // The batch's raw (key_hash, time) support: hash keys only (no value work), one
+        // entry per record, sorted by key_hash. Never merged with stored history, so no
+        // compacted record can cancel a seed.
+        let mut out = Vec::new();
+        for batch in novel {
+            let mut cursor = batch.cursor();
+            while let Some(k) = cursor.get_key(batch) {
+                let kh = stable_hash(k);
+                while cursor.get_val(batch).is_some() {
+                    cursor.map_times(batch, |t, _| out.push((kh, t.clone())));
+                    cursor.step_val(batch);
+                }
+                cursor.step_key(batch);
+            }
+        }
+        out.sort_by_key(|(k, _)| *k);
+        out
     }
 
     fn present_input(&mut self, history: &[RefBatch<K, V, T, RIn>], novel: &[RefBatch<K, V, T, RIn>], keys: &[u64]) -> ProxyChunk<T, RIn> {
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
index 4f9763618..d6cdb3bcd 100644
--- a/differential-dataflow/tests/int_proxy.rs
+++ b/differential-dataflow/tests/int_proxy.rs
@@ -375,10 +375,10 @@ where
     type RIn = B::RIn;
     type ROut = B::ROut;
 
-    fn present_novel(&mut self, novel: &[B1]) -> ProxyChunk<B1::Time, B::RIn> {
-        let chunk = self.inner.present_novel(novel);
-        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
-        chunk
+    fn seed_times(&self, novel: &[B1]) -> Vec<(u64, B1::Time)> {
+        let seeds = self.inner.seed_times(novel);
+        self.presented.fetch_add(seeds.len(), AtomicOrdering::SeqCst);
+        seeds
     }
     fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, B::RIn> {
         let chunk = self.inner.present_input(history, novel, keys);
@@ -618,9 +618,12 @@ mod identity {
         type RIn = isize;
         type ROut = isize;
 
-        fn present_novel(&mut self, novel: &[Batch<T>]) -> ProxyChunk<T, isize> {
-            let (ks, vs, ts, ds) = records(novel, None);
-            ProxyChunk::from_unsorted(ks, vs, ts, ds).0
+        fn seed_times(&self, novel: &[Batch<T>]) -> Vec<(u64, T)> {
+            // Raw (key_hash, time) support, sorted by key_hash — no value work.
+            let (ks, _vs, ts, _ds) = records(novel, None);
+            let mut out: Vec<(u64, T)> = ks.into_iter().zip(ts).collect();
+            out.sort_by_key(|(k, _)| *k);
+            out
         }
 
         fn present_input(&mut self, history: &[Batch<T>], novel: &[Batch<T>], keys: &[u64]) -> ProxyChunk<T, isize> {
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 22cd31946..7bd1e4998 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -335,18 +335,20 @@ where
     type RIn = Diff;
     type ROut = Diff;
 
-    fn present_novel(&mut self, novel: &[CBatch<T>]) -> ProxyChunk<T, Diff> {
-        // The batch's own support: read the (delta-sized) novel batches ALONE, unfiltered and never
-        // merged with stored history, so no compacted history record can cancel a seed. Also how the
-        // tactic learns the changed keys (its key set is the delta's keys).
-        let chunks = chunks_of(novel);
-        let (_keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |_| true);
-        if khs.is_empty() {
-            return ProxyChunk::default();
+    fn seed_times(&self, novel: &[CBatch<T>]) -> Vec<(u64, T)> {
+        // The batch's raw (key_hash, time) support — hash the novel KEY columns only (no value work,
+        // no consolidation), one entry per record, sorted by key_hash. Seeds may over-derive (a
+        // non-changing seed yields a zero delta), so this superset of b.support suffices; the tactic
+        // reads only the times. Never merged with stored history, so no compacted record cancels a seed.
+        let mut out: Vec<(u64, T)> = Vec::new();
+        for ch in chunks_of(novel) {
+            let kh = hash_rows(ch.keys());
+            for (h, t) in kh.into_iter().zip(ch.times()) {
+                out.push((h, t.clone()));
+            }
         }
-        let vids = hash_rows(&vals_col);
-        let (chunk, _reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
-        chunk
+        out.sort_by_key(|(k, _)| *k);
+        out
     }
 
     fn present_input(&mut self, history: &[CBatch<T>], novel: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {

From e7bf2b37ca348ed499ab8ea9224e8764604652cd Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 11:13:18 -0400
Subject: [PATCH 34/68] corgi_perf: add native DD SCC (three-way native vs
 DDIR-vec vs DDIR-corgi)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SCC is now correct in corgi, so the original question is answerable: how does the
hand-written native differential-dataflow strongly_connected compare to the same
SCC run as a DDIR program (vec interpreter vs corgi columnar backend), on the same
random graph, same from-scratch single-worker methodology. native_scc_once drives
algorithms::graphs::scc::strongly_connected. Result: vec-DDIR ~1.2-1.6x native
(the DDIR interpretation tax is small); corgi-DDIR ~2.9-3.8x native / ~1.9-2.7x
vec, gap GROWING with n (SCC is arrangement+recursion-bound — corgi's worst case,
the mirror of the compute-bound linear cases where corgi is ~3x FASTER than vec).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/examples/corgi_perf.rs | 51 ++++++++++++++++++++++++------
 1 file changed, 42 insertions(+), 9 deletions(-)

diff --git a/interactive/examples/corgi_perf.rs b/interactive/examples/corgi_perf.rs
index 21861d213..81c83d47c 100644
--- a/interactive/examples/corgi_perf.rs
+++ b/interactive/examples/corgi_perf.rs
@@ -15,6 +15,33 @@ use interactive::backend::{corgi, vec};
 use interactive::ir::Value;
 use interactive::{lower, parse};
 
+use differential_dataflow::algorithms::graphs::scc::strongly_connected;
+use differential_dataflow::input::Input;
+use timely::dataflow::operators::probe::Handle;
+
+/// One from-scratch run of the HAND-WRITTEN native DD `strongly_connected` on a static graph — the
+/// "SCC in Rust" reference to compare the DDIR-interpreted SCC against. Same shape as `evaluate`:
+/// a full single-worker `execute_directly` (setup + load at t0 + run to fixpoint).
+fn native_scc_once(edges: &[(usize, usize)]) {
+    let edges = edges.to_vec();
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
+            strongly_connected(graph).probe_with(&mut probe);
+            input
+        });
+        for &(s, d) in &edges {
+            input.insert((s, d));
+        }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) {
+            worker.step();
+        }
+    });
+}
+
 type Row = Value;
 
 fn tup(fields: &[i64]) -> Row {
@@ -147,23 +174,29 @@ fn main() {
         export "result" = outer::scc | map(;) | arrange;
     "#);
 
-    println!("\n2b. SCC (nested recursion; fwd/bwd label propagation via min; the sharp case):");
+    println!("\n2b. SCC — hand-written native DD vs DDIR-vec vs DDIR-corgi (the whole point of the exercise):");
     for &nodes in &[200usize, 500, 800, 1_000] {
-        let mut seed = 0xc0ff_ee42u64;
         let n_edges = nodes * 2;
+        // Same random graph fed to all three (identical xorshift seed → identical edge sequence).
+        let mut seed = 0xc0ff_ee42u64;
         let edges: Vec<(Row, Row)> = (0..n_edges)
             .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
             .collect();
+        let mut seed2 = 0xc0ff_ee42u64;
+        let native_edges: Vec<(usize, usize)> = (0..n_edges)
+            .map(|_| ((xorshift(&mut seed2) % nodes as u64) as usize, (xorshift(&mut seed2) % nodes as u64) as usize))
+            .collect();
         let inputs = vec![edges];
-        // NB: corgi diverges from vec on larger random graphs (a corgi-backend bug — the proxy reduce
-        // tactic + reference backend pass the scc oracles in `reduce_reference.rs`). Flag, don't panic.
-        let (co, ve) = (corgi::evaluate(&scc, &inputs), vec::evaluate(&scc, &inputs));
-        if co != ve {
-            println!("  scc                    n={nodes:<7}  !! MISMATCH corgi={co:?} vec={ve:?}");
-        }
+        // SCC is now correct in corgi — pin it.
+        assert_eq!(corgi::evaluate(&scc, &inputs), vec::evaluate(&scc, &inputs), "corgi != vec scc at n={nodes}");
+        let nt = bench(3, || native_scc_once(&native_edges));
         let vt = bench(3, || { std::hint::black_box(vec::evaluate(&scc, &inputs)); });
         let ct = bench(3, || { std::hint::black_box(corgi::evaluate(&scc, &inputs)); });
-        report("scc", nodes, vt, ct);
+        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  scc n={nodes:<5}  native {nt:>9.2?}   vec-DDIR {vt:>9.2?} ({:.1}x native)   corgi-DDIR {ct:>9.2?} ({:.1}x native, {:.2}x vec)",
+            vf / nf, cf / nf, cf / vf,
+        );
     }
 
     // ---------- 3. LINEAR COMPUTE ONLY (deep chain, NO arrange) — isolates the columnar eval ----------

From 217362216e9fac5e38339b022a037dc8334b84bd Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 11:17:46 -0400
Subject: [PATCH 35/68] corgi_scc_prof: loopable SCC profiling target +
 attribution

Profiled corgi SCC (n=500, samply+pollard): the slowness is CORGI's arrangement/
merge layer, not the framework. CorgiChunk::merge = 27% total; 57% of it is the
JOIN re-merging its accumulated trace per work-unit (flatten_batches, O(accumulated)
per round -> the superlinear term, gap grows with n), 26% arrange-ingest batcher,
17% spine maintenance. corgi::compare_idx (structural discrimination compare) drives
another 24%; malloc ~25-30% from corgi rebuilding columns per merge. Framework is
small: ProxyReduceTactic::retire is 24% total but only 3.7% self (rest is corgi
present/materialize); timely scheduling negligible; scalar eval a sliver (CmpOp::eval
3.1%). Levers: cursor/fueled join read instead of re-flatten; merge without whole-
column re-gather; cut per-merge allocation. Not the reduce value logic, not int_proxy.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/examples/corgi_scc_prof.rs | 49 ++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 interactive/examples/corgi_scc_prof.rs

diff --git a/interactive/examples/corgi_scc_prof.rs b/interactive/examples/corgi_scc_prof.rs
new file mode 100644
index 000000000..3a83cc9e3
--- /dev/null
+++ b/interactive/examples/corgi_scc_prof.rs
@@ -0,0 +1,49 @@
+//! Profiling target: loop corgi's SCC at a fixed size for samply. Attribute the slowness to
+//! framework (int_proxy tactic / timely) vs corgi backend (present/materialize/arrange/join/eval).
+//!
+//!   ITERS=300 N=500 samply record -- .../corgi_scc_prof
+
+use interactive::backend::corgi;
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+const SCC_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | map(;) | arrange;
+"#;
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
+    p.optimize();
+    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(500);
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(300);
+    let mut seed = 0xc0ff_ee42u64;
+    let edges: Vec<(Value, Value)> = (0..nodes * 2)
+        .map(|_| (Value::Tuple(vec![Value::Int((xorshift(&mut seed) % nodes) as i64), Value::Int((xorshift(&mut seed) % nodes) as i64)]), Value::unit()))
+        .collect();
+    let inputs = vec![edges];
+    let mut acc = 0usize;
+    for _ in 0..iters {
+        acc += std::hint::black_box(corgi::evaluate(&p, &inputs)).len();
+    }
+    eprintln!("done scc n={nodes} iters={iters} (acc={acc})");
+}

From cb2b9326d08e8f4a71f032bd910e704911f16780 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 3 Jul 2026 11:42:57 -0400
Subject: [PATCH 36/68] corgi join: delta-proportional restriction of the
 accumulated side
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cursor-less corgi join re-flattened the whole accumulated trace per
work-unit (O(trace)/round, superlinear on recursive joins). Restrict the
accumulated side to the fresh side's keys via find_ranges per chunk and
gather only matches — delta-proportional, structural (no hashing), no
full-trace flatten. Gate on acc_len > 2*fresh_len so the non-recursive
one-shot join (comparable sides) keeps the cheaper plain flatten and does
not pay the probe+reconsolidate overhead.

SCC n=1000: 2.84x -> 2.24x vec; non-recursive join unchanged at 0.66x;
corgi_progs 6/6 match vec, SCC corgi==vec at all sizes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_chunk.rs | 38 +++++++++++++++++++++++++++++
 interactive/src/corgi_join.rs  | 44 +++++++++++++++++++++++++++-------
 2 files changed, 73 insertions(+), 9 deletions(-)

diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index 43bb415e8..9e3ba4ef0 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -650,6 +650,44 @@ where
     Some(SortedRun { keys, vals, times, diffs })
 }
 
+/// A DELTA-PROPORTIONAL flatten of the accumulated side of a bilinear join: instead of merging the
+/// whole trace, probe each accumulated chunk with the fresh side's `needle` keys (`find_ranges`, a
+/// batched equal-range seek — each chunk is structurally sorted by key) and gather ONLY the matched
+/// records, then sort+consolidate the (small) matched set into one run. Keys absent from `needles`
+/// can never join, so dropping them is exact. Cost tracks the fresh key set + matches, never the
+/// trace — replacing the O(trace)-per-work-unit `flatten_batches` that dominated recursive joins.
+pub fn flatten_restricted<T, R>(acc: &[Rc<ChunkBatch<CorgiChunk<T, R>>>], needles: &CValue) -> Option<SortedRun<T, R>>
+where
+    T: Timestamp + Lattice,
+    R: Semigroup + Clone + 'static,
+{
+    let (mut kblocks, mut vblocks): (Vec<CValue>, Vec<CValue>) = (Vec::new(), Vec::new());
+    let (mut times, mut diffs): (Vec<T>, Vec<R>) = (Vec::new(), Vec::new());
+    for b in acc {
+        for ch in &b.chunks {
+            if ch.len_() == 0 { continue; }
+            // Per needle key, its equal-range in this chunk's (key-sorted) key column.
+            let (lo, hi) = find_ranges(needles, ch.keys());
+            let mut idx: Vec<usize> = Vec::new();
+            for i in 0..lo.len() { idx.extend(lo[i]..hi[i]); }
+            idx.sort_unstable();
+            idx.dedup();
+            if idx.is_empty() { continue; }
+            kblocks.push(gather(ch.keys(), &idx));
+            vblocks.push(gather(ch.vals(), &idx));
+            for &j in &idx {
+                times.push(ch.times()[j].clone());
+                diffs.push(ch.diffs()[j].clone());
+            }
+        }
+    }
+    if times.is_empty() { return None; }
+    let keys = concat_blocks(&kblocks);
+    let vals = concat_blocks(&vblocks);
+    let (keys, vals, times, diffs) = sort_consolidate(keys, vals, times, diffs);
+    Some(SortedRun { keys, vals, times, diffs })
+}
+
 /// Group a key column by identity, returning integers only — the Rust↔corgi boundary primitive.
 /// `perm` lists row indices in group order; `ends[g]` is the exclusive end of group `g` within `perm`
 /// (so group `g`'s member rows are `perm[ends[g-1]..ends[g]]`, with `ends[-1] = 0`). DD orchestrates
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi_join.rs
index 2f25c6fa6..96dcbbdeb 100644
--- a/interactive/src/corgi_join.rs
+++ b/interactive/src/corgi_join.rs
@@ -23,10 +23,10 @@ use differential_dataflow::operators::join::{EffortBuilder, Fresh, JoinTactic};
 use corgi::arrange::{find_ranges, gather};
 use corgi::Value as CValue;
 
-use differential_dataflow::trace::chunk::ChunkBatch;
+use differential_dataflow::trace::chunk::{Chunk, ChunkBatch};
 
 use crate::corgi_backend::CorgiContainer;
-use crate::corgi_chunk::{flatten_batches, CorgiChunk};
+use crate::corgi_chunk::{flatten_batches, flatten_restricted, CorgiChunk};
 use crate::corgi_logic::compile_join_projection;
 use crate::ir::Diff;
 use crate::parse::Term;
@@ -38,6 +38,9 @@ type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 struct CorgiDeferred<T: Timestamp + Lattice> {
     left: Vec<CBatch<T>>,
     right: Vec<CBatch<T>>,
+    /// Which side carried the fresh batch; the other (accumulated) side is restricted to the fresh
+    /// side's keys rather than fully flattened.
+    fresh: Fresh,
     capability: Capability<T>,
 }
 
@@ -63,11 +66,11 @@ where
     CB: ContainerBuilder<Container = CorgiContainer<T, Diff>>,
 {
     fn defer(&mut self, input0: Vec<CBatch<T>>, input1: Vec<CBatch<T>>, fresh: Fresh, capability: Capability<T>) {
-        let unit = CorgiDeferred { left: input0, right: input1, capability };
-        match fresh {
-            Fresh::Input0 => self.todo0.push_back(unit),
-            Fresh::Input1 => self.todo1.push_back(unit),
-        }
+        let queue = match &fresh {
+            Fresh::Input0 => &mut self.todo0,
+            Fresh::Input1 => &mut self.todo1,
+        };
+        queue.push_back(CorgiDeferred { left: input0, right: input1, fresh, capability });
     }
 
     fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>) {
@@ -90,8 +93,31 @@ where
     T: Timestamp + Lattice,
     CB: ContainerBuilder<Container = CorgiContainer<T, Diff>>,
 {
-    let Some(left) = flatten_batches(&unit.left) else { return };
-    let Some(right) = flatten_batches(&unit.right) else { return };
+    // Materialize the FRESH (delta-sized) side whole; then present the ACCUMULATED side. When it is
+    // meaningfully larger than the fresh delta (recursive joins against a built-up trace), probe it
+    // with the fresh keys and gather only matches (delta-proportional, not O(trace)); otherwise
+    // (non-recursive / comparable sizes) a plain flatten is cheaper than the probe + reconsolidate.
+    // Roles (left/right) are preserved for the projection.
+    let accumulated = |acc: &[CBatch<T>], fresh: &crate::corgi_chunk::SortedRun<T, Diff>| {
+        let acc_len: usize = acc.iter().flat_map(|b| b.chunks.iter()).map(|c| c.len()).sum();
+        if acc_len > 2 * fresh.times.len() {
+            flatten_restricted(acc, &fresh.keys)
+        } else {
+            flatten_batches(acc)
+        }
+    };
+    let (left, right) = match unit.fresh {
+        Fresh::Input0 => {
+            let Some(left) = flatten_batches(&unit.left) else { return };
+            let Some(right) = accumulated(&unit.right, &left) else { return };
+            (left, right)
+        }
+        Fresh::Input1 => {
+            let Some(right) = flatten_batches(&unit.right) else { return };
+            let Some(left) = accumulated(&unit.left, &right) else { return };
+            (left, right)
+        }
+    };
     let nl = left.times.len();
 
     // Multi-record merge-join: one batched `find` gives, per left row, the equal-range of its key in

From 1871845e8cf37c55900d39521b84d093bae86c87 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 4 Jul 2026 09:01:03 -0400
Subject: [PATCH 37/68] Make corgi-chunk shareable: git-dep corgi + field
 report + large-N SCC harness

Swap the corgi path-dep (../../wip/corgi) for a git-dep pinned to
frankmcsherry/wip@9b41cdc (dd-arrange-api), so the branch builds standalone
without a local wip checkout. Add int-proxy-columnar-findings.md (the field
report tying #781 + this branch + the corgi kernel crate, with the SCC numbers
and the columnar-Time gap) and the large-N SCC / vec-profiling harnesses the
report's repro section references.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 int-proxy-columnar-findings.md        | 119 ++++++++++++++++++++++++++
 interactive/Cargo.toml                |   4 +-
 interactive/examples/corgi_scc_big.rs |  99 +++++++++++++++++++++
 interactive/examples/vec_scc_prof.rs  |  49 +++++++++++
 4 files changed, 270 insertions(+), 1 deletion(-)
 create mode 100644 int-proxy-columnar-findings.md
 create mode 100644 interactive/examples/corgi_scc_big.rs
 create mode 100644 interactive/examples/vec_scc_prof.rs

diff --git a/int-proxy-columnar-findings.md b/int-proxy-columnar-findings.md
new file mode 100644
index 000000000..a02d679f4
--- /dev/null
+++ b/int-proxy-columnar-findings.md
@@ -0,0 +1,119 @@
+# A columnar backend on `int_proxy`: validation + gaps
+
+A field report from wiring a **dynamic-shape columnar backend** (corgi) into the `int_proxy`
+reduce/join framework. Two audiences: (1) reviewers of the `int_proxy` PR, who get a second,
+independent consumer that validates the trait surface and drove a correctness fix; (2) anyone
+thinking about columnar / non-`Ord`-keyed storage in differential, who gets a concrete map of
+what the framework already gives and what it's missing.
+
+## The pieces
+
+| Layer | Location |
+|---|---|
+| `int_proxy` framework (reduce/join over `(key_hash, value_id)`) | `TimelyDataflow/differential-dataflow#781` |
+| corgi DDIR backend (the consumer; `interactive` crate, `SPIKE.md`, benches) | `frankmcsherry/differential-dataflow @ corgi-chunk` |
+| corgi kernel crate (the `arrange` API: `find_ranges`, `sort_blocks`, content-hash, …) | `frankmcsherry/wip @ dd-arrange-api` |
+
+The DD tree on `corgi-chunk` is **byte-identical to #781** — there are no differential-dataflow
+edits beyond the PR. Everything stacked on top is the corgi backend in the `interactive` crate.
+
+## Why `int_proxy` is the right (and only) extension point here
+
+DD's native operators (`reduce_abelian`, `join_core`) are monomorphized over **static** key/value
+types: the cursor yields `&K`/`&V`, the reduce closure is `Fn(&K, &[(&V, R)], …)`. corgi has no
+such types — keys and values are `corgi::Value`, a **runtime** shape (`corgi::Shape`) determined
+by the DDIR program, stored columnar (`Prim = Arc<Vec<uN>>`). There is no compile-time `K`/`V`.
+
+`int_proxy` is the bridge: it runs reduce/join over `(key_hash: u64, value_id: u64)` integer
+proxies, so the *framework* never needs the key/value types, and the *backend* owns the
+dynamic-shape materialization behind the proxies. This is the essential **static-vs-dynamic
+columnar-shape divide** — `columnar/`/`ColChunk` serve compile-time shapes; a corgi-style backend
+serves runtime shapes; `int_proxy` connects them. Native cursor tactics are structurally
+unavailable to such a backend, which is exactly the gap `int_proxy` fills.
+
+## What got validated
+
+- All 6 canonical DDIR programs (map/filter/join/reduce/distinct/nested-recursion) match the
+  vec backend exactly, including **SCC** — the sharp case for interesting-times.
+- The corgi backend surfaced and drove the **`seed_times` correctness fix**: seed interesting
+  times from the *batch's own support*, not the consolidated/merged view. Accumulation-preserving
+  compaction can advance a stored record onto a novel retraction's exact time and cancel it in the
+  merged view, erasing a seed the reduce needed. Formalized in Lean (`Model.lean`,
+  `scenario1_cancels`, `seedSet = support ∪ pending`). This is a framework-level result #781 now
+  carries — a second backend independently exercised the interesting-times machinery hard enough
+  to find it.
+
+## Empirical findings (SCC, `e = 2n`, single worker, from-scratch to fixpoint)
+
+Three-way: hand-written native DD `strongly_connected` vs DDIR-vec vs DDIR-corgi (identical graph).
+
+| n | native | DDIR-vec | DDIR-corgi | corgi/vec |
+|---|---|---|---|---|
+| 1,000 | 26 ms | 37 ms | 83 ms | 2.24× |
+| 100,000 | 4.00 s | 2.92 s | 7.18 s | 2.46× |
+| 500,000 | 25.9 s | 20.3 s | 52.5 s | 2.59× |
+| 1,000,000 | 56.2 s | 44.5 s | 112.8 s | 2.54× |
+
+corgi holds a flat ~2.5× vs vec to 1M (no superlinear blow-up). Two apples-to-apples notes:
+
+- **DDIR-vec beats native above ~10k nodes** (0.7–0.8× native). The DDIR SCC uses
+  `enter_at($1[0])` — log-bucketed prioritized iteration (`256·(64−leading_zeros)`); native
+  `strongly_connected` uses plain `propagate` (all labels at inner round 0). So the `native`
+  column runs a *less prioritized algorithm* and is only a loose reference; **corgi-vs-vec is the
+  fair comparison** (identical DDIR program).
+- On linear/map-heavy programs corgi is **3× faster** than vec (columnar `eval_graph` vs per-tuple
+  `ir::eval`). SCC is corgi's *worst* case — control-heavy, compute-light.
+
+### Where the 2.5× goes (self-time, SCC n=800, both backends 200 identical iters → samples comparable)
+
+| bucket | DDIR-vec | DDIR-corgi |
+|---|---|---|
+| comparison / ordering | ~515 samples | ~600 |
+| framework + glue | ~925 | ~1,020 |
+| **allocation** (malloc + SmallVec + raw_vec) | **~700** | **~2,900** |
+| total | 3,703 | 7,923 (2.14×) |
+
+**The entire gap is allocation.** Comparison is a tie (vec's single biggest cost is compiled
+`Value::cmp`, 13%; corgi's structural `compare_idx` is comparable). Framework is a tie —
+`int_proxy` costs corgi nothing over DD's native cursor reduce. corgi's engine kernels are only
+~16% self; the `interactive` glue ~3.4% self.
+
+The allocation is **not** the value columns — those are already columnar (`Prim = Arc<Vec>`,
+refcount clones). It's the **per-row timestamp**: `times: Vec<Product<u64, PointStamp<u64>>>`,
+where `PointStamp` is a per-row heap `SmallVec` (spills under nested scopes), cloned on every merge
+`emit`/`to_vec` and allocated on every lattice `Product::join`.
+
+## What the framework is "missing" for columnar backends
+
+1. **A columnar `Time`/`Diff` container path a dynamic-shape backend can reuse.** DD's own
+   `columnar/` module already has it: `ColChunk`/`UpdatesTyped` store `times: Lists<ContainerOf<Time>>`,
+   and `Time = Product<u64, PointStamp<u64>>` derives `Columnar`, so the time column is SoA (outer
+   `u64` column + inner `Vecs` = flat coords + bounds) — **the per-row `PointStamp` heap object
+   never arises**. The catch: `ColChunk<U>` requires `U: ColumnarUpdate` = *static* `(K,V,T,R)`, so
+   a dynamic-shape backend can't adopt it wholesale for keys/vals. The reusable piece is the
+   `Time`/`Diff` container specifically. Making that path usable independent of static key/value
+   types would delete the single largest cost (the ~37% bucket) for any such backend.
+
+2. **Hash-ordered comparison + O(1) probe (optional).** Since `int_proxy` already keys on
+   `key_hash`, comparisons could be `u64`-hash rather than structural, and a Robin-Hood table
+   sorted by hash with a rank/select side index gives sorted + immutable + mergeable + **O(1)
+   lookup** — attacking both the join probe and the merge-scan compares. Caveat: it's a join/merge
+   win, not a reduce-`min` win (min is over values, not hashes), which is why a naive hash-sort
+   regressed reduce/reach in an earlier experiment.
+
+3. **A general columnar *kernel* surface.** A backend like this wants segmented sort / argmin
+   returning positions, batched range-find (`find_ranges`), and content-hash — not ad-hoc "arrange"
+   helpers. The corgi `arrange` API (`frankmcsherry/wip @ dd-arrange-api`) is a first cut.
+
+## Repro
+
+```
+# corgi backend branch (path-deps the corgi kernel crate at ../../wip/corgi):
+cargo run --release -p interactive --example corgi_progs      # correctness gate (6 programs vs vec)
+cargo run --release -p interactive --example corgi_perf       # linear / reach / three-way SCC
+N=100000,500000,1000000 cargo run --release -p interactive --example corgi_scc_big   # large-N SCC
+```
+
+Net: `int_proxy` is a working, correctness-validated extension point for non-`Ord`-keyed backends;
+the remaining cost for a columnar consumer is timestamp allocation, and DD already contains the
+columnar timestamp representation that fixes it — it just isn't reachable without static K/V today.
diff --git a/interactive/Cargo.toml b/interactive/Cargo.toml
index 1403deb9c..c4c64434d 100644
--- a/interactive/Cargo.toml
+++ b/interactive/Cargo.toml
@@ -13,7 +13,9 @@ workspace = true
 
 [dependencies]
 columnar = { workspace = true }
-corgi = { path = "../../wip/corgi" }
+# Local dev: `path = "../../wip/corgi"`. Pinned to a git rev so the branch builds standalone
+# (frankmcsherry/wip @ dd-arrange-api) — see int-proxy-columnar-findings.md.
+corgi = { git = "https://github.com/frankmcsherry/wip", rev = "9b41cdc4cd070a98f5a82d412cf19ac48f8e88cb" }
 differential-dataflow = { workspace = true }
 mimalloc = "0.1.48"
 serde = { version = "1.0", features = ["derive"] }
diff --git a/interactive/examples/corgi_scc_big.rs b/interactive/examples/corgi_scc_big.rs
new file mode 100644
index 000000000..ec94ad048
--- /dev/null
+++ b/interactive/examples/corgi_scc_big.rs
@@ -0,0 +1,99 @@
+//! Large-N SCC: native DD vs DDIR-vec vs DDIR-corgi at the sizes Frank actually runs
+//! (n = 100k–1m, e = 2n). The small corgi_perf sizes (n<=1000) barely touch the spine
+//! compaction machinery; this is where the arrangement/merge cost shows its true scaling.
+//!
+//!   N=100000,250000,500000,1000000 ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_big
+//!
+//! One run per backend per size (these are seconds-scale; no median). CHECK=1 asserts corgi==vec
+//! (doubles the corgi+vec work at that size) — on by default only for the smallest size.
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+use differential_dataflow::algorithms::graphs::scc::strongly_connected;
+use differential_dataflow::input::Input;
+use timely::dataflow::operators::probe::Handle;
+
+const SCC_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | map(;) | arrange;
+"#;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
+
+fn native_scc_once(edges: &[(usize, usize)]) {
+    let edges = edges.to_vec();
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
+            strongly_connected(graph).probe_with(&mut probe);
+            input
+        });
+        for &(s, d) in &edges { input.insert((s, d)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+}
+
+fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
+    p.optimize();
+    let sizes: Vec<u64> = std::env::var("N").ok()
+        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
+        .unwrap_or_else(|| vec![100_000, 250_000, 500_000, 1_000_000]);
+
+    println!("SCC large-N — native DD vs DDIR-vec vs DDIR-corgi (e = 2n):");
+    for (i, &nodes) in sizes.iter().enumerate() {
+        let n_edges = nodes * 2;
+        let mut seed = 0xc0ff_ee42u64;
+        let edges: Vec<(Value, Value)> = (0..n_edges)
+            .map(|_| (tup(&[(xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
+            .collect();
+        let mut seed2 = 0xc0ff_ee42u64;
+        let native_edges: Vec<(usize, usize)> = (0..n_edges)
+            .map(|_| ((xorshift(&mut seed2) % nodes) as usize, (xorshift(&mut seed2) % nodes) as usize))
+            .collect();
+        let inputs = vec![edges];
+
+        // Correctness check (doubles work): default on for the first/smallest size only.
+        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
+        if check {
+            assert_eq!(corgi::evaluate(&p, &inputs), vec::evaluate(&p, &inputs), "corgi != vec at n={nodes}");
+        }
+
+        let nt = once(|| native_scc_once(&native_edges));
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={nodes:<8} e={n_edges:<9}  native {nt:>9.2?}   vec-DDIR {vt:>9.2?} ({:.1}x nat)   corgi-DDIR {ct:>9.2?} ({:.1}x nat, {:.2}x vec){}",
+            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}
diff --git a/interactive/examples/vec_scc_prof.rs b/interactive/examples/vec_scc_prof.rs
new file mode 100644
index 000000000..f624e1473
--- /dev/null
+++ b/interactive/examples/vec_scc_prof.rs
@@ -0,0 +1,49 @@
+//! Profiling target: loop DDIR-VEC's SCC at a fixed size for samply — the vec-backend twin of
+//! `corgi_scc_prof`, so the self-time attribution can be compared apples-to-apples.
+//!
+//!   ITERS=200 N=800 samply record -- .../vec_scc_prof
+
+use interactive::backend::vec;
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+const SCC_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | map(;) | arrange;
+"#;
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
+    p.optimize();
+    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(800);
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(200);
+    let mut seed = 0xc0ff_ee42u64;
+    let edges: Vec<(Value, Value)> = (0..nodes * 2)
+        .map(|_| (Value::Tuple(vec![Value::Int((xorshift(&mut seed) % nodes) as i64), Value::Int((xorshift(&mut seed) % nodes) as i64)]), Value::unit()))
+        .collect();
+    let inputs = vec![edges];
+    let mut acc = 0usize;
+    for _ in 0..iters {
+        acc += std::hint::black_box(vec::evaluate(&p, &inputs)).len();
+    }
+    eprintln!("done vec scc n={nodes} iters={iters} (acc={acc})");
+}

From a726b3f0860ca07928d31c9532967987ca75f7da Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sun, 5 Jul 2026 12:42:00 -0400
Subject: [PATCH 38/68] Collect dead generations: drop pre-Chunk arrange +
 pre-int_proxy reduce
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the two superseded modules (corgi_arrange.rs pre-Chunk arrangement,
corgi_reduce.rs pre-int_proxy reduce) — nothing in the live path referenced
them — plus the ~150-line dead stratum inside corgi_chunk.rs that only they
used (from_rows/to_rows/batch_to_rows, rows_to_batch, CorgiChunkBuilder,
group_offsets, semijoin_history) and the orphaned imports.

Also delete the examples that only exercised the dead modules (corgi_arrange_smoke,
corgi_join_mechanism/dataflow, corgi_reduce_dataflow/trace) and the SCC
bug-isolation harnesses (corgi_scc_min/trace/stream, corgi_cc_min, corgi_bwd_min)
for the interesting-times bug now fixed and pinned by tests + Lean.

Live path unchanged: build clean (no warnings), corgi_chunk unit tests pass,
corgi_progs matches vec. Net -2157 lines. Git history preserves the journey.

Also correct int-proxy-columnar-findings.md: the DD subtree is NOT byte-identical
to #781 — ~148 lines (MSD-bucket sort, reduce buffer-reuse, tests) sit ahead of
the PR and should be pushed back to int-proxy.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 int-proxy-columnar-findings.md                |   8 +-
 interactive/examples/corgi_arrange_smoke.rs   |  69 ---
 interactive/examples/corgi_bwd_min.rs         | 109 ----
 interactive/examples/corgi_cc_min.rs          |  98 ----
 interactive/examples/corgi_join_dataflow.rs   | 131 -----
 interactive/examples/corgi_join_mechanism.rs  | 133 -----
 interactive/examples/corgi_reduce_dataflow.rs | 221 ---------
 interactive/examples/corgi_reduce_trace.rs    | 103 ----
 interactive/examples/corgi_scc_min.rs         | 120 -----
 interactive/examples/corgi_scc_stream.rs      |  69 ---
 interactive/examples/corgi_scc_trace.rs       |  89 ----
 interactive/src/corgi_arrange.rs              | 465 ------------------
 interactive/src/corgi_chunk.rs                | 190 +------
 interactive/src/corgi_reduce.rs               | 368 --------------
 interactive/src/lib.rs                        |   2 -
 15 files changed, 9 insertions(+), 2166 deletions(-)
 delete mode 100644 interactive/examples/corgi_arrange_smoke.rs
 delete mode 100644 interactive/examples/corgi_bwd_min.rs
 delete mode 100644 interactive/examples/corgi_cc_min.rs
 delete mode 100644 interactive/examples/corgi_join_dataflow.rs
 delete mode 100644 interactive/examples/corgi_join_mechanism.rs
 delete mode 100644 interactive/examples/corgi_reduce_dataflow.rs
 delete mode 100644 interactive/examples/corgi_reduce_trace.rs
 delete mode 100644 interactive/examples/corgi_scc_min.rs
 delete mode 100644 interactive/examples/corgi_scc_stream.rs
 delete mode 100644 interactive/examples/corgi_scc_trace.rs
 delete mode 100644 interactive/src/corgi_arrange.rs
 delete mode 100644 interactive/src/corgi_reduce.rs

diff --git a/int-proxy-columnar-findings.md b/int-proxy-columnar-findings.md
index a02d679f4..f32e85cf8 100644
--- a/int-proxy-columnar-findings.md
+++ b/int-proxy-columnar-findings.md
@@ -14,8 +14,12 @@ what the framework already gives and what it's missing.
 | corgi DDIR backend (the consumer; `interactive` crate, `SPIKE.md`, benches) | `frankmcsherry/differential-dataflow @ corgi-chunk` |
 | corgi kernel crate (the `arrange` API: `find_ranges`, `sort_blocks`, content-hash, …) | `frankmcsherry/wip @ dd-arrange-api` |
 
-The DD tree on `corgi-chunk` is **byte-identical to #781** — there are no differential-dataflow
-edits beyond the PR. Everything stacked on top is the corgi backend in the `interactive` crate.
+The DD-core work is #781; the corgi backend stacked on top lives entirely in the `interactive`
+crate. One caveat for reviewers: `corgi-chunk` currently carries **~148 lines of framework
+improvements ahead of #781** — an MSD-bucket sort in `ProxyChunk::from_unsorted`, reduce
+buffer-reuse, and test extensions — that were developed against the backend and should be pushed
+back onto the `int-proxy` branch so the PR carries its own improvements. So diff `pr781..corgi-chunk`
+for the true backend delta, but don't assume the DD subtree equals the PR verbatim.
 
 ## Why `int_proxy` is the right (and only) extension point here
 
diff --git a/interactive/examples/corgi_arrange_smoke.rs b/interactive/examples/corgi_arrange_smoke.rs
deleted file mode 100644
index f7e6264f4..000000000
--- a/interactive/examples/corgi_arrange_smoke.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//! M2(b) arrange wiring: arrange a corgi-container collection into a `Spine<Rc<CorgiBatch>>` via
-//! `arrange_core`, reusing DD's `MergeBatcher`+`VecMerger` (Batcher) and `ContainerChunker` (the
-//! container drains corgi→rows), with `CorgiBatchBuilder` transcoding the sorted chain → corgi
-//! columns at build. Milestone: it COMPILES and RUNS (content correctness comes with reduce).
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_arrange_smoke
-
-use std::rc::Rc;
-
-use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::*;
-
-use differential_dataflow::input::Input;
-use differential_dataflow::operators::arrange::arrangement::arrange_core;
-use differential_dataflow::trace::implementations::chunker::ContainerChunker;
-use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
-use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
-use differential_dataflow::trace::implementations::spine_fueled::Spine;
-use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
-
-use interactive::corgi_arrange::{CorgiBatch, CorgiBatchBuilder};
-use interactive::corgi_backend::CorgiContainer;
-use interactive::ir::{Diff, Value as DValue};
-
-type Row = DValue;
-type Upd = ((Row, Row), u64, Diff);
-type CC = CorgiContainer<u64, Diff>;
-type Trace = Spine<Rc<CorgiBatch<u64, Diff>>>;
-
-fn main() {
-    // Unique (key,val) so nothing consolidates away; all at time 0.
-    let data: Vec<(Row, Row)> = (0..1000).map(|i| (DValue::Int(i), DValue::Int(i * 2))).collect();
-    let n = data.len();
-
-    timely::execute_directly(move |worker| {
-        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
-            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
-
-            // ingest: rows -> CorgiContainer
-            let corgi_stream = coll.inner.unary(Pipeline, "ToCorgi", |_, _| {
-                |input, output| {
-                    input.for_each(|cap, data| {
-                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
-                        output.session(&cap).give_container(&mut c);
-                    });
-                }
-            });
-
-            // arrange the corgi-container stream into a corgi-columnar trace.
-            let _arranged = arrange_core::<
-                _,
-                CC,
-                ContainerChunker<Vec<Upd>>,
-                MergeBatcher<VecMerger<(Row, Row), u64, Diff>>,
-                RcBuilder<CorgiBatchBuilder<u64, Diff>>,
-                Trace,
-            >(corgi_stream, Pipeline, "CorgiArrange");
-
-            handle
-        });
-        for r in data {
-            handle.update(r, 1);
-        }
-    });
-
-    println!("M2(b) arrange: arrange_core over corgi containers COMPILED and RAN.");
-    println!("  fed {n} unique (key,val) updates → Spine<Rc<CorgiBatch>> (corgi-columnar trace).");
-    println!("  Batcher = reused MergeBatcher<VecMerger>; Builder transcodes rows→corgi at ingest.");
-}
diff --git a/interactive/examples/corgi_bwd_min.rs b/interactive/examples/corgi_bwd_min.rs
deleted file mode 100644
index 9f28b5d7b..000000000
--- a/interactive/examples/corgi_bwd_min.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-//! Narrow the SCC divergence: is it already in single-level min-label-propagation (the `fwd` block of
-//! SCC — one dynamic scope, `min` + `join`), or does it need SCC's nested trimming/negation?
-//! Sweep+delta-debug corgi-vs-vec on the standalone forward propagation, comparing the FULL labels.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_cc_min
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn tup(a: i64, b: i64) -> Row {
-    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-// Standalone forward min-label propagation — SCC's `fwd` block, joining against `edges` directly.
-const SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    fwd: {
-        let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-        let labels = proposals + nodes | min;
-        var proposals = labels | join(edges, ($2 ; $1));
-    }
-    let trim_fwd = edges
-        | join(fwd::labels, ($1 ; $0, $2))
-        | join(fwd::labels, ($0 ; $1, $2))
-        | filter($1[1] == $1[2])
-        | key($0 ; $1[0]);
-    bwd: {
-        let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-        let labels = proposals + nodes | min;
-        var proposals = labels | join(trim_fwd, ($2 ; $1));
-    }
-    export "result" = bwd::labels | arrange;
-"#;
-
-fn compile() -> interactive::scope_ir::Program {
-    let mut p = lower::lower_tree(parse::pipe::parse(SRC));
-    p.optimize();
-    p
-}
-
-fn agrees(prog: &interactive::scope_ir::Program, edges: &[(Row, Row)]) -> bool {
-    let inputs = vec![edges.to_vec()];
-    corgi::evaluate(prog, &inputs) == vec::evaluate(prog, &inputs)
-}
-
-fn main() {
-    let prog = compile();
-
-    let mut found: Option<(usize, Vec<(Row, Row)>)> = None;
-    'search: for &nodes in &[4usize, 5, 6, 8, 10, 12, 16, 20, 30, 50, 80] {
-        for seed_i in 0..6000u64 {
-            let mut seed = 0x1000 + seed_i.wrapping_mul(0x9e3779b97f4a7c15);
-            let n_edges = nodes * 2;
-            let edges: Vec<(Row, Row)> = (0..n_edges)
-                .map(|_| (tup((xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64), Value::unit()))
-                .collect();
-            if !agrees(&prog, &edges) {
-                println!("first mismatch: nodes={nodes} seed_i={seed_i} n_edges={n_edges}");
-                found = Some((nodes, edges));
-                break 'search;
-            }
-        }
-        println!("  nodes={nodes}: all seeds agree");
-    }
-
-    let Some((nodes, mut edges)) = found else {
-        println!("\nNO two-pass (fwd->trim->bwd, no outer loop) mismatch found — the bug needs SCC's nesting/negation.");
-        return;
-    };
-
-    // Delta-debug.
-    let mut changed = true;
-    while changed {
-        changed = false;
-        let mut i = 0;
-        while i < edges.len() {
-            let mut trial = edges.clone();
-            trial.remove(i);
-            if !trial.is_empty() && !agrees(&prog, &trial) {
-                edges = trial;
-                changed = true;
-            } else {
-                i += 1;
-            }
-        }
-    }
-
-    println!("\nMINIMAL failing graph: nodes={nodes}, {} edges:", edges.len());
-    let mut es: Vec<(i64, i64)> = edges.iter().map(|(k, _)| match k {
-        Value::Tuple(f) => (f[0].as_int(), f[1].as_int()),
-        _ => unreachable!(),
-    }).collect();
-    es.sort();
-    println!("  edges = {es:?}");
-    let inputs = vec![edges.clone()];
-    println!("  corgi = {:?}", corgi::evaluate(&prog, &inputs));
-    println!("  vec   = {:?}", vec::evaluate(&prog, &inputs));
-}
diff --git a/interactive/examples/corgi_cc_min.rs b/interactive/examples/corgi_cc_min.rs
deleted file mode 100644
index ade2fea2d..000000000
--- a/interactive/examples/corgi_cc_min.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-//! Narrow the SCC divergence: is it already in single-level min-label-propagation (the `fwd` block of
-//! SCC — one dynamic scope, `min` + `join`), or does it need SCC's nested trimming/negation?
-//! Sweep+delta-debug corgi-vs-vec on the standalone forward propagation, comparing the FULL labels.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_cc_min
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn tup(a: i64, b: i64) -> Row {
-    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-// Standalone forward min-label propagation — SCC's `fwd` block, joining against `edges` directly.
-const SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    fwd: {
-        let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-        let labels = proposals + nodes | min;
-        var proposals = labels | join(edges, ($2 ; $1));
-    }
-    export "result" = fwd::labels | arrange;
-"#;
-
-fn compile() -> interactive::scope_ir::Program {
-    let mut p = lower::lower_tree(parse::pipe::parse(SRC));
-    p.optimize();
-    p
-}
-
-fn agrees(prog: &interactive::scope_ir::Program, edges: &[(Row, Row)]) -> bool {
-    let inputs = vec![edges.to_vec()];
-    corgi::evaluate(prog, &inputs) == vec::evaluate(prog, &inputs)
-}
-
-fn main() {
-    let prog = compile();
-
-    let mut found: Option<(usize, Vec<(Row, Row)>)> = None;
-    'search: for &nodes in &[4usize, 5, 6, 8, 10, 12, 16, 20, 30, 50, 80] {
-        for seed_i in 0..6000u64 {
-            let mut seed = 0x1000 + seed_i.wrapping_mul(0x9e3779b97f4a7c15);
-            let n_edges = nodes * 2;
-            let edges: Vec<(Row, Row)> = (0..n_edges)
-                .map(|_| (tup((xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64), Value::unit()))
-                .collect();
-            if !agrees(&prog, &edges) {
-                println!("first mismatch: nodes={nodes} seed_i={seed_i} n_edges={n_edges}");
-                found = Some((nodes, edges));
-                break 'search;
-            }
-        }
-        println!("  nodes={nodes}: all seeds agree");
-    }
-
-    let Some((nodes, mut edges)) = found else {
-        println!("\nNO forward-propagation mismatch found — the bug needs SCC's nesting/negation.");
-        return;
-    };
-
-    // Delta-debug.
-    let mut changed = true;
-    while changed {
-        changed = false;
-        let mut i = 0;
-        while i < edges.len() {
-            let mut trial = edges.clone();
-            trial.remove(i);
-            if !trial.is_empty() && !agrees(&prog, &trial) {
-                edges = trial;
-                changed = true;
-            } else {
-                i += 1;
-            }
-        }
-    }
-
-    println!("\nMINIMAL failing graph: nodes={nodes}, {} edges:", edges.len());
-    let mut es: Vec<(i64, i64)> = edges.iter().map(|(k, _)| match k {
-        Value::Tuple(f) => (f[0].as_int(), f[1].as_int()),
-        _ => unreachable!(),
-    }).collect();
-    es.sort();
-    println!("  edges = {es:?}");
-    let inputs = vec![edges.clone()];
-    println!("  corgi = {:?}", corgi::evaluate(&prog, &inputs));
-    println!("  vec   = {:?}", vec::evaluate(&prog, &inputs));
-}
diff --git a/interactive/examples/corgi_join_dataflow.rs b/interactive/examples/corgi_join_dataflow.rs
deleted file mode 100644
index 65330ad35..000000000
--- a/interactive/examples/corgi_join_dataflow.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-//! M2(b)-4 (live): corgi JOIN inside a real DD dataflow via the cursor-less tactic seam. Arrange two
-//! corgi-container collections into `Spine<Rc<CorgiBatch>>` traces, then `join_with_tactic` with
-//! `CorgiJoinTactic` (bulk merge-join over corgi columns + corgi projection). Output == reference
-//! hash-join, incl. retractions. Projection: (key, val0, val1) -> (key, val0+val1).
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_join_dataflow
-
-use std::collections::BTreeMap;
-use std::rc::Rc;
-
-use timely::container::CapacityContainerBuilder;
-use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::capture::{Capture, Event};
-use timely::dataflow::operators::*;
-
-use differential_dataflow::input::Input;
-use differential_dataflow::operators::arrange::arrangement::arrange_core;
-use differential_dataflow::operators::join::join_with_tactic;
-use differential_dataflow::trace::implementations::chunker::ContainerChunker;
-use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
-use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
-use differential_dataflow::trace::implementations::spine_fueled::Spine;
-use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
-
-use interactive::corgi_arrange::{CorgiBatch, CorgiBatchBuilder};
-use interactive::corgi_backend::CorgiContainer;
-use interactive::corgi_join::CorgiJoinTactic;
-use interactive::ir::{Diff, Value as DValue};
-use interactive::parse::{BinOp, Term};
-
-type Row = DValue;
-type Upd = ((Row, Row), u64, Diff);
-type CC = CorgiContainer<u64, Diff>;
-type Trace = Spine<Rc<CorgiBatch<u64, Diff>>>;
-type OutCB = CapacityContainerBuilder<Vec<Upd>>;
-
-fn reference(lu: &[((u64, u64), Diff)], ru: &[((u64, u64), Diff)]) -> BTreeMap<(u64, u64), Diff> {
-    // join by key, project (key, val0+val1), sum diffs.
-    let mut lmap: BTreeMap<u64, Vec<(u64, Diff)>> = BTreeMap::new();
-    let mut rmap: BTreeMap<u64, Vec<(u64, Diff)>> = BTreeMap::new();
-    for ((k, v), d) in lu {
-        lmap.entry(*k).or_default().push((*v, *d));
-    }
-    for ((k, v), d) in ru {
-        rmap.entry(*k).or_default().push((*v, *d));
-    }
-    let mut out = BTreeMap::new();
-    for (k, lvs) in &lmap {
-        if let Some(rvs) = rmap.get(k) {
-            for (vl, dl) in lvs {
-                for (vr, dr) in rvs {
-                    *out.entry((*k, vl + vr)).or_insert(0) += dl * dr;
-                }
-            }
-        }
-    }
-    out.retain(|_, d| *d != 0);
-    out
-}
-
-fn main() {
-    let lu: Vec<((u64, u64), Diff)> = vec![((1, 10), 1), ((1, 20), 1), ((2, 5), 1), ((2, 6), 1), ((3, 1), 1), ((2, 6), -1)];
-    let ru: Vec<((u64, u64), Diff)> = vec![((1, 100), 1), ((2, 200), 1), ((2, 300), 1), ((4, 9), 1)];
-
-    let l_rows: Vec<(Row, Row)> = lu.iter().map(|((k, v), _)| (DValue::Int(*k as i64), DValue::Int(*v as i64))).collect();
-    let l_diffs: Vec<Diff> = lu.iter().map(|(_, d)| *d).collect();
-    let r_rows: Vec<(Row, Row)> = ru.iter().map(|((k, v), _)| (DValue::Int(*k as i64), DValue::Int(*v as i64))).collect();
-    let r_diffs: Vec<Diff> = ru.iter().map(|(_, d)| *d).collect();
-
-    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<Upd>>>();
-    timely::execute_directly(move |worker| {
-        let (mut h0, mut h1) = worker.dataflow::<u64, _, _>(|scope| {
-            let (h0, c0) = scope.new_collection::<(Row, Row), Diff>();
-            let (h1, c1) = scope.new_collection::<(Row, Row), Diff>();
-
-            let s0 = c0.inner.unary(Pipeline, "ToCorgi0", |_, _| {
-                |input, output| {
-                    input.for_each(|cap, data| {
-                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
-                        output.session(&cap).give_container(&mut c);
-                    });
-                }
-            });
-            let s1 = c1.inner.unary(Pipeline, "ToCorgi1", |_, _| {
-                |input, output| {
-                    input.for_each(|cap, data| {
-                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
-                        output.session(&cap).give_container(&mut c);
-                    });
-                }
-            });
-
-            let a0 = arrange_core::<_, CC, ContainerChunker<Vec<Upd>>, MergeBatcher<VecMerger<(Row, Row), u64, Diff>>, RcBuilder<CorgiBatchBuilder<u64, Diff>>, Trace>(s0, Pipeline, "CorgiArr0");
-            let a1 = arrange_core::<_, CC, ContainerChunker<Vec<Upd>>, MergeBatcher<VecMerger<(Row, Row), u64, Diff>>, RcBuilder<CorgiBatchBuilder<u64, Diff>>, Trace>(s1, Pipeline, "CorgiArr1");
-
-            // projection: (key, val0, val1) -> (key, val0 + val1); the tactic compiles it per work-unit.
-            let key = Term::Var(0);
-            let val = Term::Binary(BinOp::Add, Box::new(Term::Var(1)), Box::new(Term::Var(2)));
-            let out = join_with_tactic::<_, _, _, OutCB>(a0, a1, CorgiJoinTactic::new(key, val));
-            out.capture_into(tx);
-
-            (h0, h1)
-        });
-        for (r, d) in l_rows.into_iter().zip(l_diffs) {
-            h0.update(r, d);
-        }
-        for (r, d) in r_rows.into_iter().zip(r_diffs) {
-            h1.update(r, d);
-        }
-    });
-
-    let mut got: BTreeMap<(u64, u64), Diff> = BTreeMap::new();
-    for event in rx {
-        if let Event::Messages(_, data) = event {
-            for ((k, v), _, d) in data {
-                if let (DValue::Int(k), DValue::Int(v)) = (k, v) {
-                    *got.entry((k as u64, v as u64)).or_insert(0) += d;
-                }
-            }
-        }
-    }
-    got.retain(|_, d| *d != 0);
-
-    let want = reference(&lu, &ru);
-    assert_eq!(got, want, "corgi join dataflow != reference");
-
-    println!("M2(b)-4 LIVE: corgi JOIN in a real DD dataflow via CorgiJoinTactic");
-    println!("  output rows: {} — matches reference hash-join (incl. retraction)", got.len());
-    println!("  e.g. {:?}", got);
-    println!("\nJoin operator works cursor-less over corgi columns through the #771–773 tactic seam.");
-}
diff --git a/interactive/examples/corgi_join_mechanism.rs b/interactive/examples/corgi_join_mechanism.rs
deleted file mode 100644
index 4efb0c785..000000000
--- a/interactive/examples/corgi_join_mechanism.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//! M2(b)-4 (mechanism): the cursor-less JOIN compute over corgi batches — before the
-//! JoinTactic defer/work/capability plumbing. Merge-join two sorted corgi batches by KEY
-//! (`compare_at`), cross-product the matched val runs (`gather`), multiply diffs (Rust). Verified
-//! vs a reference hash-join, with retractions (negative diffs). Single time (the (time) lattice
-//! join lives in the tactic; here we isolate the columnar match+cross-product+diff algebra).
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_join_mechanism
-
-use std::cmp::Ordering;
-use std::collections::BTreeMap;
-
-use timely::progress::Antichain;
-use differential_dataflow::trace::{BatchReader, Description};
-
-use interactive::corgi_arrange::CorgiBatch;
-
-use corgi::arrange::{compare_at, gather};
-use corgi::Value as CValue;
-
-fn make_batch(updates: &[((u64, u64), i64)]) -> CorgiBatch<u64, i64> {
-    let keys = CValue::u64(updates.iter().map(|u| u.0 .0).collect());
-    let vals = CValue::u64(updates.iter().map(|u| u.0 .1).collect());
-    let times = vec![0u64; updates.len()];
-    let diffs = updates.iter().map(|u| u.1).collect();
-    let desc = Description::new(Antichain::from_elem(0), Antichain::from_elem(1), Antichain::from_elem(0));
-    CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
-}
-
-/// Cursor-less equijoin compute: matched (key, valL, valR) -> summed diff (diffL*diffR).
-fn corgi_join(l: &CorgiBatch<u64, i64>, r: &CorgiBatch<u64, i64>) -> BTreeMap<(u64, u64, u64), i64> {
-    let (nl, nr) = (l.len(), r.len());
-    let (mut i, mut j) = (0, 0);
-    let (mut li, mut ri, mut ds) = (Vec::new(), Vec::new(), Vec::new());
-    while i < nl && j < nr {
-        match compare_at(&l.keys, i, &r.keys, j) {
-            Ordering::Less => i += 1,
-            Ordering::Greater => j += 1,
-            Ordering::Equal => {
-                // runs of this key on each side (batches sorted by (key,val))
-                let mut i2 = i;
-                while i2 < nl && compare_at(&l.keys, i, &l.keys, i2) == Ordering::Equal {
-                    i2 += 1;
-                }
-                let mut j2 = j;
-                while j2 < nr && compare_at(&r.keys, j, &r.keys, j2) == Ordering::Equal {
-                    j2 += 1;
-                }
-                for a in i..i2 {
-                    for b in j..j2 {
-                        li.push(a);
-                        ri.push(b);
-                        ds.push(l.diffs[a] * r.diffs[b]);
-                    }
-                }
-                i = i2;
-                j = j2;
-            }
-        }
-    }
-    // Materialize matched columns in bulk via gather (corgi-native), then fold to a map.
-    let kc = gather(&l.keys, &li).into_u64("k");
-    let lc = gather(&l.vals, &li).into_u64("vl");
-    let rc = gather(&r.vals, &ri).into_u64("vr");
-    let mut m = BTreeMap::new();
-    for x in 0..ds.len() {
-        *m.entry((kc[x], lc[x], rc[x])).or_insert(0) += ds[x];
-    }
-    m.retain(|_, d| *d != 0);
-    m
-}
-
-/// Reference hash-join over the same updates.
-fn reference(lu: &[((u64, u64), i64)], ru: &[((u64, u64), i64)]) -> BTreeMap<(u64, u64, u64), i64> {
-    let mut lmap: BTreeMap<u64, Vec<(u64, i64)>> = BTreeMap::new();
-    let mut rmap: BTreeMap<u64, Vec<(u64, i64)>> = BTreeMap::new();
-    for ((k, v), d) in lu {
-        lmap.entry(*k).or_default().push((*v, *d));
-    }
-    for ((k, v), d) in ru {
-        rmap.entry(*k).or_default().push((*v, *d));
-    }
-    let mut m = BTreeMap::new();
-    for (k, lvs) in &lmap {
-        if let Some(rvs) = rmap.get(k) {
-            for (vl, dl) in lvs {
-                for (vr, dr) in rvs {
-                    *m.entry((*k, *vl, *vr)).or_insert(0) += dl * dr;
-                }
-            }
-        }
-    }
-    m.retain(|_, d| *d != 0);
-    m
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-fn main() {
-    // Directed example incl. multi-val keys and a retraction.
-    let lu = vec![((1, 10), 1), ((1, 11), 1), ((2, 20), 1), ((3, 30), 1)];
-    let ru = vec![((1, 100), 1), ((2, 200), 1), ((2, 201), 1), ((4, 400), 1)];
-    let got = corgi_join(&make_batch(&lu), &make_batch(&ru));
-    let want = reference(&lu, &ru);
-    assert_eq!(got, want, "directed join mismatch");
-    println!("  directed: {} matched rows  OK (e.g. key 2 → 1×2 = 2 pairs)", got.len());
-
-    // Randomized property test incl. negative diffs (retractions → diffL*diffR can be negative).
-    let mut seed = 0xfeed_face_dead_beefu64;
-    for _ in 0..300 {
-        let gen = |s: &mut u64| -> Vec<((u64, u64), i64)> {
-            let n = (xorshift(s) % 20) as usize + 1;
-            (0..n)
-                .map(|_| {
-                    let k = xorshift(s) % 5;
-                    let v = xorshift(s) % 6;
-                    let d = if xorshift(s) % 4 == 0 { -1 } else { 1 };
-                    ((k, v), d)
-                })
-                .collect()
-        };
-        let lu = gen(&mut seed);
-        let ru = gen(&mut seed);
-        assert_eq!(corgi_join(&make_batch(&lu), &make_batch(&ru)), reference(&lu, &ru), "lu={lu:?} ru={ru:?}");
-    }
-    println!("  randomized: 300 joins == reference (incl. retractions / negative product diffs)");
-    println!("\nM2(b)-4 mechanism: cursor-less corgi equijoin (merge-join via compare_at + gather");
-    println!("  cross-product + diff-multiply) verified. Next: wrap in CorgiJoinTactic defer/work.");
-}
diff --git a/interactive/examples/corgi_reduce_dataflow.rs b/interactive/examples/corgi_reduce_dataflow.rs
deleted file mode 100644
index 89b9be703..000000000
--- a/interactive/examples/corgi_reduce_dataflow.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-//! M2(b) reduce LIVE: the cursor-less `CorgiReduceTactic` (built on Frank's `active_times`) driving
-//! a real `reduce_with_tactic` over a corgi-columnar arrangement. Count-per-key, fed across two
-//! times with a retraction-to-zero, read back from the output arrangement's batch stream
-//! (`Vec<Rc<CorgiBatch>>`, cursor-free) and compared to a Rust reference.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reduce_dataflow
-
-use std::collections::BTreeMap;
-use std::rc::Rc;
-
-use timely::order::Product;
-use timely::progress::Timestamp;
-use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::capture::{Capture, Event};
-use timely::dataflow::operators::*;
-
-use differential_dataflow::input::Input;
-use differential_dataflow::operators::arrange::arrangement::arrange_core;
-use differential_dataflow::operators::reduce::reduce_with_tactic;
-use differential_dataflow::trace::implementations::chunker::ContainerChunker;
-use differential_dataflow::trace::implementations::merge_batcher::vec::VecMerger;
-use differential_dataflow::trace::implementations::merge_batcher::MergeBatcher;
-use differential_dataflow::trace::implementations::spine_fueled::Spine;
-use differential_dataflow::trace::rc_blanket_impls::RcBuilder;
-
-use differential_dataflow::operators::reduce::ReduceTactic;
-use differential_dataflow::trace::Description;
-use timely::progress::Antichain;
-
-use interactive::corgi_arrange::{CorgiBatch, CorgiBatchBuilder};
-use interactive::corgi_backend::CorgiContainer;
-use interactive::corgi_logic::{infer_shape, transcode, untranscode};
-use interactive::corgi_reduce::CorgiReduceTactic;
-use interactive::ir::{Diff, Value as DValue};
-use interactive::parse::Reducer;
-
-type Row = DValue;
-
-fn read_batch<T: Clone>(b: &CorgiBatch<T, Diff>) -> Vec<((Row, Row), T, Diff)> {
-    if b.times.is_empty() {
-        return Vec::new();
-    }
-    let keys = untranscode(b.keys.clone(), &corgi::shape_of_value(&b.keys));
-    let vals = untranscode(b.vals.clone(), &corgi::shape_of_value(&b.vals));
-    keys.into_iter()
-        .zip(vals)
-        .zip(&b.times)
-        .zip(&b.diffs)
-        .map(|(((k, v), t), d)| ((k, v), t.clone(), *d))
-        .collect()
-}
-
-/// Run the corgi backend's reduce over `updates`, return final consolidated `(key, reduced_val)`.
-/// Generic over the time `T` so we can test both totally-ordered (`u64`) and partial-order
-/// (`Product<u64,u64>`) times — the latter exercises `active_times`' synthetic-join-time generation.
-fn run_corgi(updates: Vec<((Row, Row), u64, Diff)>, reducer: Reducer) -> BTreeMap<(Row, Row), Diff> {
-    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
-    timely::execute_directly(move |worker| {
-        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
-            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
-            let corgi = coll.inner.unary(Pipeline, "ToCorgi", |_, _| {
-                |input, output| {
-                    input.for_each(|cap, data| {
-                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
-                        output.session(&cap).give_container(&mut c);
-                    });
-                }
-            });
-            let arr = arrange_core::<_, CorgiContainer<u64, Diff>, ContainerChunker<Vec<((Row, Row), u64, Diff)>>, MergeBatcher<VecMerger<(Row, Row), u64, Diff>>, RcBuilder<CorgiBatchBuilder<u64, Diff>>, Spine<Rc<CorgiBatch<u64, Diff>>>>(corgi, Pipeline, "CorgiArrange");
-            let reduced = reduce_with_tactic::<_, Spine<Rc<CorgiBatch<u64, Diff>>>, _>(arr, "CorgiReduce", CorgiReduceTactic::<u64>::new(reducer));
-            reduced
-                .stream
-                .unary(Pipeline, "ReadReduceOut", |_, _| {
-                    |input, output| {
-                        input.for_each(|cap, data| {
-                            let mut rows: Vec<((Row, Row), u64, Diff)> = Vec::new();
-                            for batch in data.iter() {
-                                rows.extend(read_batch(batch));
-                            }
-                            output.session(&cap).give_container(&mut rows);
-                        });
-                    }
-                })
-                .capture_into(tx);
-            handle
-        });
-        for ((k, v), t, d) in updates {
-            handle.update_at((k, v), t, d);
-        }
-    });
-
-    let mut got: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for event in rx {
-        if let Event::Messages(_, rows) = event {
-            for ((k, v), _, d) in rows {
-                *got.entry((k, v)).or_insert(0) += d;
-            }
-        }
-    }
-    got.retain(|_, d| *d != 0);
-    got
-}
-
-/// Rust reference: net input per (key,val), then the reducer per key → final `(key, reduced_val): 1`.
-fn reference<T>(updates: &[((Row, Row), T, Diff)], reducer: &Reducer) -> BTreeMap<(Row, Row), Diff> {
-    let mut net: BTreeMap<(i64, i64), Diff> = BTreeMap::new();
-    for ((k, v), _, d) in updates {
-        if let (DValue::Int(k), DValue::Int(v)) = (k, v) {
-            *net.entry((*k, *v)).or_insert(0) += d;
-        }
-    }
-    let mut by_key: BTreeMap<i64, Vec<(i64, Diff)>> = BTreeMap::new();
-    for ((k, v), d) in net {
-        by_key.entry(k).or_default().push((v, d));
-    }
-    let mut out: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for (k, vals) in by_key {
-        let reduced: Option<Row> = match reducer {
-            Reducer::Count => {
-                let c: Diff = vals.iter().map(|(_, d)| *d).sum();
-                (c > 0).then(|| DValue::Tuple(vec![DValue::Int(c)]))
-            }
-            Reducer::Min => vals.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).min().map(DValue::Int),
-            Reducer::Distinct => vals.iter().any(|(_, d)| *d > 0).then(DValue::unit),
-            Reducer::Collect => unreachable!("not tested here"),
-        };
-        if let Some(r) = reduced {
-            out.insert((DValue::Int(k), r), 1);
-        }
-    }
-    out
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-fn main() {
-    // Directed: Count, 2 rounds incl. retraction-to-zero (key 2 vanishes; key 1 counts down 2→1).
-    let directed: Vec<((Row, Row), u64, Diff)> = vec![
-        ((DValue::Int(1), DValue::Int(10)), 0, 1),
-        ((DValue::Int(1), DValue::Int(20)), 0, 1),
-        ((DValue::Int(2), DValue::Int(30)), 0, 1),
-        ((DValue::Int(1), DValue::Int(10)), 1, -1),
-        ((DValue::Int(2), DValue::Int(30)), 1, -1),
-        ((DValue::Int(3), DValue::Int(40)), 1, 1),
-    ];
-    assert_eq!(run_corgi(directed.clone(), Reducer::Count), reference(&directed, &Reducer::Count), "directed Count");
-    println!("directed Count (retraction-to-zero): OK");
-
-    // Randomized property test: Count over random multi-time ±1 updates (robust to any net diffs).
-    let mut seed = 0x51ed_c0_fefe_beadu64;
-    for it in 0..120 {
-        let n = (xorshift(&mut seed) % 24) as usize + 1;
-        let ups: Vec<((Row, Row), u64, Diff)> = (0..n)
-            .map(|_| {
-                let k = (xorshift(&mut seed) % 5) as i64;
-                let v = (xorshift(&mut seed) % 7) as i64;
-                let t = xorshift(&mut seed) % 3;
-                let d = if xorshift(&mut seed) % 4 == 0 { -1 } else { 1 };
-                ((DValue::Int(k), DValue::Int(v)), t, d)
-            })
-            .collect();
-        let got = run_corgi(ups.clone(), Reducer::Count);
-        let want = reference(&ups, &Reducer::Count);
-        assert_eq!(got, want, "randomized Count iter {it}: {ups:?}");
-    }
-    println!("randomized Count: 120 cases == reference (random keys/vals/times/retractions)");
-
-    // Directed well-formed Min & Distinct (set semantics, no over-retraction).
-    let setlike: Vec<((Row, Row), u64, Diff)> = vec![
-        ((DValue::Int(1), DValue::Int(50)), 0, 1),
-        ((DValue::Int(1), DValue::Int(30)), 0, 1),
-        ((DValue::Int(1), DValue::Int(70)), 1, 1),
-        ((DValue::Int(1), DValue::Int(30)), 2, -1), // remove the current min at t2
-        ((DValue::Int(2), DValue::Int(9)), 0, 1),
-    ];
-    assert_eq!(run_corgi(setlike.clone(), Reducer::Min), reference(&setlike, &Reducer::Min), "Min");
-    assert_eq!(run_corgi(setlike.clone(), Reducer::Distinct), reference(&setlike, &Reducer::Distinct), "Distinct");
-    println!("directed Min & Distinct (min changes under retraction): OK");
-
-    // PARTIAL-ORDER test: the crux of `active_times`. Two updates for key 1 at incomparable times
-    // (0,1) and (1,0); the count is 1 at each, but must become 2 at the synthetic join time (1,1) —
-    // a time present in NEITHER input. If `active_times` failed to derive (1,1), the final count
-    // would be wrong (Tuple[1]:2 instead of Tuple[2]:1).
-    // (Partial-order times can't use `new_collection` [needs TotalOrder], so drive `retire` directly
-    // over one interval covering everything — this is also the most direct test of `active_times`.)
-    type PT = Product<u64, u64>;
-    let key_rows = vec![DValue::Int(1), DValue::Int(1), DValue::Int(2)];
-    let val_rows = vec![DValue::Int(10), DValue::Int(20), DValue::Int(5)];
-    let times: Vec<PT> = vec![Product::new(0, 1), Product::new(1, 0), Product::new(0, 0)];
-    let keys = transcode(&key_rows, &infer_shape(&key_rows[0]));
-    let vals = transcode(&val_rows, &infer_shape(&val_rows[0]));
-    let min = Antichain::from_elem(PT::minimum());
-    let batch = Rc::new(CorgiBatch::from_unsorted(keys, vals, times, vec![1, 1, 1], Description::new(min.clone(), Antichain::new(), min.clone())));
-
-    let mut tactic = CorgiReduceTactic::<PT>::new(Reducer::Count);
-    let (produced, _frontier) = tactic.retire(vec![], vec![], vec![batch], &min, &Antichain::new(), &min);
-
-    let mut got: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for (_ship, b) in &produced {
-        for ((k, v), _t, d) in read_batch(b) {
-            *got.entry((k, v)).or_insert(0) += d;
-        }
-    }
-    got.retain(|_, d| *d != 0);
-    // key1 sees vals 10 and 20 (at incomparable times) → count 2 at the synthetic join (1,1); key2 → 1.
-    let want: BTreeMap<(Row, Row), Diff> = [
-        ((DValue::Int(1), DValue::Tuple(vec![DValue::Int(2)])), 1),
-        ((DValue::Int(2), DValue::Tuple(vec![DValue::Int(1)])), 1),
-    ]
-    .into_iter()
-    .collect();
-    assert_eq!(got, want, "partial-order Count via direct retire (synthetic join time)");
-    println!("partial-order Count via direct retire (synthetic join (1,1) from (0,1)+(1,0) → count 2): OK  <-- active_times core");
-
-    println!("\nCursor-less corgi REDUCE (active_times) verified live vs reference — the last operator works.");
-}
diff --git a/interactive/examples/corgi_reduce_trace.rs b/interactive/examples/corgi_reduce_trace.rs
deleted file mode 100644
index ee3e8999f..000000000
--- a/interactive/examples/corgi_reduce_trace.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//! M2(b)-3: the Route-B reduce MECHANISM, end-to-end over a manually maintained corgi trace —
-//! before the arrange_core/reduce_with_tactic timely plumbing. A trace is an accumulated
-//! `CorgiBatch` (merged via `merge`, consolidated per (key,val)); the reducer is a corgi program
-//! (Count = GroupKey + fold_add over the diff column, so retractions just subtract). We apply
-//! batches AND retractions and check the corgi-reduced output matches a reference each step.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reduce_trace
-
-use std::collections::BTreeMap;
-
-use timely::progress::Antichain;
-use differential_dataflow::trace::Description;
-
-use interactive::corgi_arrange::{merge, CorgiBatch};
-
-use corgi::{ArithOp, Builder, CmpOp, Graph, NumOp, Op, Red, Value as CValue};
-
-/// Build a single-time (t=0) CorgiBatch from `((key,val), diff)` updates.
-fn make_batch(updates: &[((u64, u64), i64)]) -> CorgiBatch<u64, i64> {
-    let keys = CValue::u64(updates.iter().map(|u| u.0 .0).collect());
-    let vals = CValue::u64(updates.iter().map(|u| u.0 .1).collect());
-    let times = vec![0u64; updates.len()];
-    let diffs = updates.iter().map(|u| u.1).collect();
-    let desc = Description::new(Antichain::from_elem(0), Antichain::from_elem(1), Antichain::from_elem(0));
-    CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
-}
-
-/// corgi Count reducer: `input: List<(key, diff)> -> group -> map((k, ds) -> (k, ds fold_add))`.
-fn count_program() -> Graph<NumOp> {
-    let mut b = Builder::<NumOp>::default();
-    let input = b.input();
-    let grouped = b.add(CmpOp::GroupKey, vec![input]);
-    let body = {
-        let mut bb = Builder::<NumOp>::default();
-        let e = bb.input();
-        let k = bb.add(Op::Field(0), vec![e]);
-        let ds = bb.add(Op::Field(1), vec![e]);
-        let sum = bb.add(ArithOp::Reduce(Red::Add), vec![ds]); // fold_add — u64 add == i64 add on bits
-        let out = bb.tuple(vec![k, sum]);
-        bb.finish(out)
-    };
-    let mapped = b.add(Op::MapList(Box::new(body)), vec![grouped]);
-    b.finish(mapped)
-}
-
-/// Run the corgi Count reducer over the trace; key -> net count (nonzero only).
-fn reduce_count(trace: &CorgiBatch<u64, i64>, g: &Graph<NumOp>) -> BTreeMap<u64, i64> {
-    let n = trace.times.len();
-    if n == 0 {
-        return BTreeMap::new();
-    }
-    let diffcol = CValue::u64(trace.diffs.iter().map(|&d| d as u64).collect());
-    let pairs = CValue::Prod(vec![trace.keys.clone(), diffcol]);
-    let input = CValue::List(vec![n].into(), Box::new(pairs));
-    let out = corgi::eval_graph(g, input);
-    let (_b, inner) = out.into_list("count out");
-    let cols = inner.into_prod("kc");
-    let ks = cols[0].clone().into_u64("k");
-    let cs = cols[1].clone().into_u64("c");
-    ks.into_iter()
-        .zip(cs)
-        .map(|(k, c)| (k, c as i64))
-        .filter(|(_, c)| *c != 0)
-        .collect()
-}
-
-fn main() {
-    let g = count_program();
-    let z = Antichain::from_elem(0u64);
-
-    // A reference: cumulative diff per key over all applied updates.
-    let mut ref_counts: BTreeMap<u64, i64> = BTreeMap::new();
-    let apply_ref = |ups: &[((u64, u64), i64)], r: &mut BTreeMap<u64, i64>| {
-        for ((k, _v), d) in ups {
-            *r.entry(*k).or_insert(0) += d;
-        }
-        r.retain(|_, c| *c != 0);
-    };
-
-    let steps: Vec<Vec<((u64, u64), i64)>> = vec![
-        vec![((1, 10), 1), ((1, 20), 1), ((2, 30), 1)],     // +: {1:2, 2:1}
-        vec![((1, 10), -1), ((3, 40), 1)],                   // retract one of key 1; add key 3 -> {1:1,2:1,3:1}
-        vec![((1, 20), -1)],                                 // key 1 -> 0, disappears -> {2:1,3:1}
-        vec![((2, 30), 2), ((2, 31), 1)],                    // key 2 multi-val -> {2:4,3:1}
-    ];
-
-    let mut trace: Option<CorgiBatch<u64, i64>> = None;
-    for (i, step) in steps.iter().enumerate() {
-        let nb = make_batch(step);
-        trace = Some(match trace.take() {
-            None => nb,
-            Some(t) => merge(&t, &nb, z.borrow()),
-        });
-        let got = reduce_count(trace.as_ref().unwrap(), &g);
-        apply_ref(step, &mut ref_counts);
-        assert_eq!(got, ref_counts, "step {i}: corgi reduce != reference");
-        println!("  step {i}: {:?}  OK", got);
-    }
-
-    println!("\nM2(b)-3: Route-B reduce MECHANISM verified incrementally (adds + retractions).");
-    println!("  trace = accumulated CorgiBatch (merged over corgi columns); reducer = corgi Count");
-    println!("  program; each step's corgi output == reference. Next: wire into reduce_with_tactic.");
-}
diff --git a/interactive/examples/corgi_scc_min.rs b/interactive/examples/corgi_scc_min.rs
deleted file mode 100644
index 44888c6e8..000000000
--- a/interactive/examples/corgi_scc_min.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-//! Minimize an SCC corgi-vs-vec divergence: sweep (nodes, seed), find the smallest edge set where
-//! `corgi::evaluate != vec::evaluate`, then greedily shrink the edge set (delta-debug) while the
-//! mismatch persists. Prints the minimal failing graph for conventional tracing.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_min
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn tup(a: i64, b: i64) -> Row {
-    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-const SCC_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges
-            | join(fwd::labels, ($1 ; $0, $2))
-            | join(fwd::labels, ($0 ; $1, $2))
-            | filter($1[1] == $1[2])
-            | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans
-            | join(bwd::labels, ($1 ; $0, $2))
-            | join(bwd::labels, ($0 ; $1, $2))
-            | filter($1[1] == $1[2])
-            | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | map(;) | arrange;
-"#;
-
-fn compile() -> interactive::scope_ir::Program {
-    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
-    p.optimize();
-    p
-}
-
-/// True iff corgi and vec agree on this edge set.
-fn agrees(prog: &interactive::scope_ir::Program, edges: &[(Row, Row)]) -> bool {
-    let inputs = vec![edges.to_vec()];
-    corgi::evaluate(prog, &inputs) == vec::evaluate(prog, &inputs)
-}
-
-fn main() {
-    let prog = compile();
-
-    // 1. Sweep (nodes, seed) for the smallest failing edge count.
-    let mut found: Option<(usize, u64, Vec<(Row, Row)>)> = None;
-    'search: for &nodes in &[4usize, 5, 6, 7, 8, 10, 12, 16, 20, 30, 50] {
-        for seed_i in 0..4000u64 {
-            let mut seed = 0x1000 + seed_i.wrapping_mul(0x9e3779b97f4a7c15);
-            let n_edges = nodes * 2;
-            let edges: Vec<(Row, Row)> = (0..n_edges)
-                .map(|_| (tup((xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64), Value::unit()))
-                .collect();
-            if !agrees(&prog, &edges) {
-                println!("first mismatch: nodes={nodes} seed_i={seed_i} n_edges={n_edges}");
-                found = Some((nodes, seed_i, edges));
-                break 'search;
-            }
-        }
-        println!("  nodes={nodes}: all {} seeds agree", 4000);
-    }
-
-    let Some((nodes, _seed, mut edges)) = found else {
-        println!("NO mismatch found in the sweep.");
-        return;
-    };
-
-    // 2. Delta-debug: greedily drop edges while the mismatch persists.
-    let mut changed = true;
-    while changed {
-        changed = false;
-        let mut i = 0;
-        while i < edges.len() {
-            let mut trial = edges.clone();
-            trial.remove(i);
-            if !trial.is_empty() && !agrees(&prog, &trial) {
-                edges = trial;
-                changed = true;
-            } else {
-                i += 1;
-            }
-        }
-    }
-
-    // 3. Report the minimal failing graph and the two outputs.
-    println!("\nMINIMAL failing graph: nodes={nodes}, {} edges:", edges.len());
-    let mut es: Vec<(i64, i64)> = edges.iter().map(|(k, _)| match k {
-        Value::Tuple(f) => (f[0].as_int(), f[1].as_int()),
-        _ => unreachable!(),
-    }).collect();
-    es.sort();
-    println!("  edges = {es:?}");
-    let inputs = vec![edges.clone()];
-    println!("  corgi = {:?}", corgi::evaluate(&prog, &inputs));
-    println!("  vec   = {:?}", vec::evaluate(&prog, &inputs));
-}
diff --git a/interactive/examples/corgi_scc_stream.rs b/interactive/examples/corgi_scc_stream.rs
deleted file mode 100644
index b2e6d12aa..000000000
--- a/interactive/examples/corgi_scc_stream.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//! Emit the full (data, time, diff) update STREAM of SCC intermediates on the minimal 4-node repro,
-//! via `inspect`, for one backend (BACKEND=corgi|vec). Diff the two streams offline (consolidated by
-//! (data, time)) to find the FIRST moment of divergence — the operator whose inputs agree but output
-//! does not is the bug.
-//!
-//!   BACKEND=corgi ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_stream 2>c.txt
-//!   BACKEND=vec   ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_stream 2>v.txt
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn tup(a: i64, b: i64) -> Row {
-    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
-}
-
-fn edges() -> Vec<(Row, Row)> {
-    [(0, 0), (0, 2), (1, 3), (2, 1), (2, 2)]
-        .iter()
-        .map(|&(a, b)| (tup(a, b), Value::unit()))
-        .collect()
-}
-
-// SCC with `inspect` taps on fwd::labels, trim_fwd, bwd::labels (each lifted to the outer scope).
-const SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges
-            | join(fwd::labels, ($1 ; $0, $2))
-            | join(fwd::labels, ($0 ; $1, $2))
-            | filter($1[1] == $1[2])
-            | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let bin = proposals + nodes | inspect(bwdin);
-            let labels = bin | min | inspect(bwdout);
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans
-            | join(bwd::labels, ($1 ; $0, $2))
-            | join(bwd::labels, ($0 ; $1, $2))
-            | filter($1[1] == $1[2])
-            | key($0 ; $1[0]);
-        let fl = fwd::labels | inspect(fl);
-        let tf = trim_fwd | inspect(tf);
-        let bl = bwd::labels | inspect(bl);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | arrange;
-"#;
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(SRC));
-    p.optimize();
-    let inputs = vec![edges()];
-    match std::env::var("BACKEND").as_deref() {
-        Ok("vec") => { vec::evaluate(&p, &inputs); }
-        _ => { corgi::evaluate(&p, &inputs); }
-    }
-}
diff --git a/interactive/examples/corgi_scc_trace.rs b/interactive/examples/corgi_scc_trace.rs
deleted file mode 100644
index a1291b9ea..000000000
--- a/interactive/examples/corgi_scc_trace.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-//! Trace the minimal SCC divergence: on the fixed 4-node repro, export each intermediate of the SCC
-//! program (fwd labels, trim_fwd, bwd labels, trim_bwd, scc) and compare corgi vs vec. The first
-//! intermediate that diverges localizes the bug within corgi.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_trace
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn tup(a: i64, b: i64) -> Row {
-    Value::Tuple(vec![Value::Int(a), Value::Int(b)])
-}
-
-// The minimal failing graph found by corgi_scc_min.
-fn edges() -> Vec<(Row, Row)> {
-    [(0, 0), (0, 2), (1, 3), (2, 1), (2, 2)]
-        .iter()
-        .map(|&(a, b)| (tup(a, b), Value::unit()))
-        .collect()
-}
-
-// The SCC body, with a parameterized export target.
-fn src(export: &str) -> String {
-    format!(r#"
-        let edges = input 0 | key($0[0] ; $0[1]);
-        let trans = edges | key($1 ; $0);
-        outer: {{
-            let scc = edges + trim;
-            fwd: {{
-                let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-                let labels = proposals + nodes | min;
-                var proposals = labels | join(scc, ($2 ; $1));
-            }}
-            let trim_fwd = edges
-                | join(fwd::labels, ($1 ; $0, $2))
-                | join(fwd::labels, ($0 ; $1, $2))
-                | filter($1[1] == $1[2])
-                | key($0 ; $1[0]);
-            bwd: {{
-                let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-                let labels = proposals + nodes | min;
-                var proposals = labels | join(trim_fwd, ($2 ; $1));
-            }}
-            let trim_bwd = trans
-                | join(bwd::labels, ($1 ; $0, $2))
-                | join(bwd::labels, ($0 ; $1, $2))
-                | filter($1[1] == $1[2])
-                | key($0 ; $1[0]);
-            let fl = fwd::labels;
-            let bl = bwd::labels;
-            var trim = trim_bwd - edges;
-        }}
-        export "result" = {export} | arrange;
-    "#)
-}
-
-fn compile(export: &str) -> interactive::scope_ir::Program {
-    let mut p = lower::lower_tree(parse::pipe::parse(&src(export)));
-    p.optimize();
-    p
-}
-
-fn main() {
-    let inputs = vec![edges()];
-    // From the inside out: labels feed trims feed the next scope feed scc.
-    for target in ["outer::fl", "outer::trim_fwd", "outer::bl", "outer::trim_bwd", "outer::scc"] {
-        // Some intermediates may not be exportable across scopes; skip on compile/eval panic.
-        let res = std::panic::catch_unwind(|| {
-            let prog = compile(target);
-            let co = corgi::evaluate(&prog, &inputs);
-            let ve = vec::evaluate(&prog, &inputs);
-            (co, ve)
-        });
-        match res {
-            Ok((co, ve)) => {
-                let tag = if co == ve { "OK  " } else { "DIFF" };
-                println!("[{tag}] {target}");
-                if co != ve {
-                    println!("       corgi = {co:?}");
-                    println!("       vec   = {ve:?}");
-                }
-            }
-            Err(_) => println!("[skip] {target} (not exportable)"),
-        }
-    }
-}
diff --git a/interactive/src/corgi_arrange.rs b/interactive/src/corgi_arrange.rs
deleted file mode 100644
index b760f3f91..000000000
--- a/interactive/src/corgi_arrange.rs
+++ /dev/null
@@ -1,465 +0,0 @@
-//! Phase 2 / M2(b) Route B — the cursor-less corgi arrangement batch.
-//!
-//! `CorgiBatch` stores a sorted, consolidated run of `(key, val, time, diff)` with key/val as corgi
-//! columns and time/diff as Rust Vecs. It implements `BatchReader` (len/description) but NO `Cursor`:
-//! navigation is the tactic's concern (it reads the corgi columns in bulk). Sorting/merging use the
-//! corgi `arrange` API (`compare_at` for the (key,val) order, `gather`/`gather_lanes` to materialize),
-//! with the time tiebreak + diff consolidation + time-advance in plain Rust (corgi never sees time).
-//!
-//! Order: (key, val) by corgi structural order, then time by `Ord`. Any total order works as long as
-//! it is used consistently (correctness compares multisets, not against DDIR's derived `Ord`).
-
-use std::cmp::Ordering;
-
-use timely::progress::{Antichain, Timestamp};
-use timely::progress::frontier::AntichainRef;
-
-use differential_dataflow::difference::Semigroup;
-use differential_dataflow::lattice::Lattice;
-use differential_dataflow::trace::{Batch, BatchReader, Builder as DdBuilder, Description, Merger as DdMerger};
-
-use corgi::Value as CValue;
-use corgi::arrange::{compare_at, gather, gather_lanes};
-
-use crate::corgi_logic::{infer_shape, transcode, untranscode};
-use crate::ir::Value as DValue;
-
-/// A sorted, consolidated arrangement batch with corgi-columnar key/val payload.
-#[derive(Clone)]
-pub struct CorgiBatch<T, R> {
-    /// Key column (corgi), aligned with `vals`/`times`/`diffs`, sorted by (key, val, time).
-    pub keys: CValue,
-    /// Val column (corgi).
-    pub vals: CValue,
-    /// Per-update times (Rust; the lattice algebra lives here, not in corgi).
-    pub times: Vec<T>,
-    /// Per-update diffs (Rust).
-    pub diffs: Vec<R>,
-    /// Time bounds of the batch.
-    pub desc: Description<T>,
-}
-
-impl<T: Timestamp + Lattice, R: Semigroup + 'static> BatchReader for CorgiBatch<T, R> {
-    type Time = T;
-    fn len(&self) -> usize { self.times.len() }
-    fn description(&self) -> &Description<T> { &self.desc }
-}
-
-/// The (key,val) sort payload as one corgi Prod column (cheap Arc bumps).
-fn kv_of<T, R>(b: &CorgiBatch<T, R>) -> CValue {
-    CValue::Prod(vec![b.keys.clone(), b.vals.clone()])
-}
-
-/// Split a `Prod([keys, vals])` corgi value into its two columns.
-fn split_kv(kv: CValue) -> (CValue, CValue) {
-    let mut cols = kv.into_prod("corgi batch kv");
-    let vals = cols.pop().unwrap();
-    let keys = cols.pop().unwrap();
-    (keys, vals)
-}
-
-impl<T: Clone, R: Copy> CorgiBatch<T, R> {
-    /// Read the batch back to `((key, val), time, diff)` rows (cursor-free; untranscodes the corgi
-    /// key/val columns). Used by `Backend::as_collection`, the reduce tactic, and tests.
-    pub fn to_updates(&self) -> Vec<((DValue, DValue), T, R)> {
-        if self.times.is_empty() {
-            return Vec::new();
-        }
-        let keys = untranscode(self.keys.clone(), &corgi::shape_of_value(&self.keys));
-        let vals = untranscode(self.vals.clone(), &corgi::shape_of_value(&self.vals));
-        keys.into_iter()
-            .zip(vals)
-            .zip(&self.times)
-            .zip(&self.diffs)
-            .map(|(((k, v), t), d)| ((k, v), t.clone(), *d))
-            .collect()
-    }
-}
-
-impl<T: Timestamp + Lattice, R: Semigroup + Clone + 'static> CorgiBatch<T, R> {
-    /// Build a batch from parallel, UNSORTED columns: sort by (key,val,time) and consolidate
-    /// equal (key,val,time) triples (dropping zero diffs).
-    pub fn from_unsorted(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>, desc: Description<T>) -> Self {
-        let n = times.len();
-        let kv = CValue::Prod(vec![keys, vals]);
-        let mut perm: Vec<usize> = (0..n).collect();
-        perm.sort_by(|&i, &j| compare_at(&kv, i, &kv, j).then_with(|| times[i].cmp(&times[j])));
-        let kv_s = gather(&kv, &perm);
-        let times_s: Vec<T> = perm.iter().map(|&i| times[i].clone()).collect();
-        let diffs_s: Vec<R> = perm.iter().map(|&i| diffs[i].clone()).collect();
-
-        let (mut keep, mut ot, mut od) = (Vec::new(), Vec::new(), Vec::new());
-        let mut i = 0;
-        while i < n {
-            let t = times_s[i].clone();
-            let mut d = diffs_s[i].clone();
-            let mut k = i + 1;
-            while k < n && compare_at(&kv_s, i, &kv_s, k) == Ordering::Equal && times_s[k] == t {
-                d.plus_equals(&diffs_s[k]);
-                k += 1;
-            }
-            if !d.is_zero() {
-                keep.push(i);
-                ot.push(t);
-                od.push(d);
-            }
-            i = k;
-        }
-        let (keys, vals) = split_kv(gather(&kv_s, &keep));
-        CorgiBatch { keys, vals, times: ot, diffs: od, desc }
-    }
-}
-
-/// Advance a group's (time, diff) pairs to `frontier`, consolidate by advanced time, and emit the
-/// surviving rows pointing at one representative source row `(rep_tag, rep_off)` (same key/val).
-#[allow(clippy::too_many_arguments)]
-fn emit_group<T, R>(
-    pairs: Vec<(T, R)>,
-    rep_tag: usize,
-    rep_off: usize,
-    frontier: AntichainRef<T>,
-    tags: &mut Vec<usize>,
-    off: &mut Vec<usize>,
-    times: &mut Vec<T>,
-    diffs: &mut Vec<R>,
-) where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone,
-{
-    let mut adv: Vec<(T, R)> = pairs
-        .into_iter()
-        .map(|(mut t, d)| {
-            t.advance_by(frontier);
-            (t, d)
-        })
-        .collect();
-    adv.sort_by(|a, b| a.0.cmp(&b.0));
-    let mut k = 0;
-    while k < adv.len() {
-        let t = adv[k].0.clone();
-        let mut d = adv[k].1.clone();
-        k += 1;
-        while k < adv.len() && adv[k].0 == t {
-            d.plus_equals(&adv[k].1);
-            k += 1;
-        }
-        if !d.is_zero() {
-            tags.push(rep_tag);
-            off.push(rep_off);
-            times.push(t);
-            diffs.push(d);
-        }
-    }
-}
-
-/// Merge two sorted `CorgiBatch`es into one, advancing all times to `frontier` and consolidating.
-/// (key,val) groups are walked in sorted order via `compare_at`; each group's (time,diff) pairs from
-/// both sources are advanced+consolidated; output columns are materialized with `gather_lanes`.
-pub fn merge<T, R>(b1: &CorgiBatch<T, R>, b2: &CorgiBatch<T, R>, frontier: AntichainRef<T>) -> CorgiBatch<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    let kv1 = kv_of(b1);
-    let kv2 = kv_of(b2);
-    let (n1, n2) = (b1.len(), b2.len());
-    let (mut i, mut j) = (0, 0);
-    let (mut tags, mut off) = (Vec::new(), Vec::new());
-    let (mut times, mut diffs) = (Vec::new(), Vec::new());
-
-    // length of b1's (key,val) run starting at `s`.
-    let run1 = |s: usize, i: &mut usize| {
-        let mut pairs = Vec::new();
-        while *i < n1 && compare_at(&kv1, s, &kv1, *i) == Ordering::Equal {
-            pairs.push((b1.times[*i].clone(), b1.diffs[*i].clone()));
-            *i += 1;
-        }
-        pairs
-    };
-    let run2 = |s: usize, j: &mut usize| {
-        let mut pairs = Vec::new();
-        while *j < n2 && compare_at(&kv2, s, &kv2, *j) == Ordering::Equal {
-            pairs.push((b2.times[*j].clone(), b2.diffs[*j].clone()));
-            *j += 1;
-        }
-        pairs
-    };
-
-    while i < n1 && j < n2 {
-        match compare_at(&kv1, i, &kv2, j) {
-            Ordering::Less => {
-                let s = i;
-                let pairs = run1(s, &mut i);
-                emit_group(pairs, 0, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
-            }
-            Ordering::Greater => {
-                let s = j;
-                let pairs = run2(s, &mut j);
-                emit_group(pairs, 1, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
-            }
-            Ordering::Equal => {
-                let (s1, s2) = (i, j);
-                let mut pairs = run1(s1, &mut i);
-                pairs.extend(run2(s2, &mut j));
-                emit_group(pairs, 0, s1, frontier, &mut tags, &mut off, &mut times, &mut diffs);
-            }
-        }
-    }
-    while i < n1 {
-        let s = i;
-        let pairs = run1(s, &mut i);
-        emit_group(pairs, 0, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
-    }
-    while j < n2 {
-        let s = j;
-        let pairs = run2(s, &mut j);
-        emit_group(pairs, 1, s, frontier, &mut tags, &mut off, &mut times, &mut diffs);
-    }
-
-    // An empty source carries a `Unit(0)` placeholder shape (see `Batch::empty`), which would trip
-    // `gather_lanes`' cross-source shape check even though no tag references it. Substitute the
-    // non-empty side's `kv` for any empty source so all sources share the real shape; the substituted
-    // reference is never indexed (no tag points to an empty side).
-    let (src0, src1) = match (n1 == 0, n2 == 0) {
-        (false, true) => (&kv1, &kv1),
-        (true, false) => (&kv2, &kv2),
-        _ => (&kv1, &kv2),
-    };
-    let (keys, vals) = if tags.is_empty() {
-        // Both empty (or fully cancelled): use whichever source has a real shape.
-        let witness = if n1 != 0 { &b1.keys } else { &b2.keys };
-        let witness_v = if n1 != 0 { &b1.vals } else { &b2.vals };
-        (gather(witness, &[]), gather(witness_v, &[]))
-    } else {
-        split_kv(gather_lanes(&[Some(src0), Some(src1)], &tags, &off))
-    };
-    let lower = b1.desc.lower().meet(b2.desc.lower());
-    let upper = b1.desc.upper().join(b2.desc.upper());
-    let desc = Description::new(lower, upper, frontier.to_owned());
-    CorgiBatch { keys, vals, times, diffs, desc }
-}
-
-/// `Batch::Merger` for `CorgiBatch`: an eager wrapper around [`merge`]. Correctness-first — it does
-/// the whole merge on the first `work` and leaves `fuel` untouched (positive → "complete"), so there
-/// is no latency smoothing yet. Fuel-bounded incremental merging is a later refinement.
-pub struct CorgiMerger<T, R> {
-    result: Option<CorgiBatch<T, R>>,
-    frontier: Antichain<T>,
-}
-
-impl<T, R> DdMerger<CorgiBatch<T, R>> for CorgiMerger<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    fn new(_s1: &CorgiBatch<T, R>, _s2: &CorgiBatch<T, R>, frontier: AntichainRef<T>) -> Self {
-        CorgiMerger { result: None, frontier: frontier.to_owned() }
-    }
-    fn work(&mut self, s1: &CorgiBatch<T, R>, s2: &CorgiBatch<T, R>, _fuel: &mut isize) {
-        if self.result.is_none() {
-            self.result = Some(merge(s1, s2, self.frontier.borrow()));
-        }
-    }
-    fn done(self) -> CorgiBatch<T, R> {
-        self.result.expect("CorgiMerger::done called before work")
-    }
-}
-
-impl<T, R> Batch for CorgiBatch<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    type Merger = CorgiMerger<T, R>;
-    fn empty(lower: Antichain<T>, upper: Antichain<T>) -> Self {
-        CorgiBatch {
-            keys: CValue::Unit(0),
-            vals: CValue::Unit(0),
-            times: Vec::new(),
-            diffs: Vec::new(),
-            desc: Description::new(lower, upper, Antichain::from_elem(T::minimum())),
-        }
-    }
-}
-
-/// Build a `CorgiBatch` from DDIR row updates (the arrangement-ingest boundary transcode). The
-/// batcher delivers sorted+consolidated chains; `from_unsorted` re-sorts idempotently for safety.
-fn build_batch<T, R>(updates: Vec<((DValue, DValue), T, R)>, desc: Description<T>) -> CorgiBatch<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    if updates.is_empty() {
-        return CorgiBatch { keys: CValue::Unit(0), vals: CValue::Unit(0), times: Vec::new(), diffs: Vec::new(), desc };
-    }
-    let kshape = infer_shape(&updates[0].0 .0);
-    let vshape = infer_shape(&updates[0].0 .1);
-    let keys_rows: Vec<DValue> = updates.iter().map(|u| u.0 .0.clone()).collect();
-    let vals_rows: Vec<DValue> = updates.iter().map(|u| u.0 .1.clone()).collect();
-    let times = updates.iter().map(|u| u.1.clone()).collect();
-    let diffs = updates.iter().map(|u| u.2.clone()).collect();
-    let keys = transcode(&keys_rows, &kshape);
-    let vals = transcode(&vals_rows, &vshape);
-    CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
-}
-
-/// DD `Builder` for `CorgiBatch`: consumes sorted/consolidated row chains (the batcher's `Output`)
-/// and builds a corgi-columnar batch. `Input = Vec<((key,val), time, diff)>` so the existing
-/// `MergeBatcher` over vec rows can be reused as the `Batcher`. Wrapped by `RcBuilder` → `Rc<CorgiBatch>`.
-pub struct CorgiBatchBuilder<T, R> {
-    updates: Vec<((DValue, DValue), T, R)>,
-}
-
-impl<T, R> DdBuilder for CorgiBatchBuilder<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    type Input = Vec<((DValue, DValue), T, R)>;
-    type Time = T;
-    type Output = CorgiBatch<T, R>;
-
-    fn with_capacity(_keys: usize, _vals: usize, upds: usize) -> Self {
-        CorgiBatchBuilder { updates: Vec::with_capacity(upds) }
-    }
-    fn push(&mut self, chunk: &mut Self::Input) {
-        self.updates.append(chunk);
-    }
-    fn done(self, description: Description<T>) -> CorgiBatch<T, R> {
-        build_batch(self.updates, description)
-    }
-    fn seal(chain: &mut Vec<Self::Input>, description: Description<T>) -> CorgiBatch<T, R> {
-        let mut all = Vec::new();
-        for c in chain.iter_mut() {
-            all.append(c);
-        }
-        build_batch(all, description)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    fn xorshift(seed: &mut u64) -> u64 {
-        *seed ^= *seed << 13;
-        *seed ^= *seed >> 7;
-        *seed ^= *seed << 17;
-        *seed
-    }
-
-    /// Build a CorgiBatch from u64 (key,val) updates with a [lower,upper) description.
-    fn batch(updates: &[((u64, u64), u64, i64)], lower: u64, upper: u64) -> CorgiBatch<u64, i64> {
-        let keys = CValue::u64(updates.iter().map(|u| u.0 .0).collect());
-        let vals = CValue::u64(updates.iter().map(|u| u.0 .1).collect());
-        let times = updates.iter().map(|u| u.1).collect();
-        let diffs = updates.iter().map(|u| u.2).collect();
-        let desc = Description::new(
-            Antichain::from_elem(lower),
-            Antichain::from_elem(upper),
-            Antichain::from_elem(0u64),
-        );
-        CorgiBatch::from_unsorted(keys, vals, times, diffs, desc)
-    }
-
-    /// Read a batch back to a ((k,v),t)->d map.
-    fn read(b: &CorgiBatch<u64, i64>) -> std::collections::BTreeMap<((u64, u64), u64), i64> {
-        let ks = b.keys.clone().into_u64("k");
-        let vs = b.vals.clone().into_u64("v");
-        let mut m = std::collections::BTreeMap::new();
-        for idx in 0..b.times.len() {
-            *m.entry(((ks[idx], vs[idx]), b.times[idx])).or_insert(0) += b.diffs[idx];
-        }
-        m.retain(|_, d| *d != 0);
-        m
-    }
-
-    /// Reference: union both update sets, advance times to `f`, consolidate by ((k,v),t).
-    fn reference(u1: &[((u64, u64), u64, i64)], u2: &[((u64, u64), u64, i64)], f: u64) -> std::collections::BTreeMap<((u64, u64), u64), i64> {
-        let mut m = std::collections::BTreeMap::new();
-        for u in u1.iter().chain(u2) {
-            let t = u.1.max(f); // advance_by for a total u64 order = max
-            *m.entry((u.0, t)).or_insert(0) += u.2;
-        }
-        m.retain(|_, d| *d != 0);
-        m
-    }
-
-    #[test]
-    fn from_unsorted_sorts_and_consolidates() {
-        let u = vec![((1, 0), 3, 1), ((0, 0), 0, 1), ((1, 0), 3, 1), ((0, 0), 0, -1), ((2, 5), 1, 1)];
-        let b = batch(&u, 0, 10);
-        // (0,0)@0 cancels; (1,0)@3 sums to 2; (2,5)@1 stays.
-        let got = read(&b);
-        assert_eq!(got.get(&((1, 0), 3)), Some(&2));
-        assert_eq!(got.get(&((0, 0), 0)), None);
-        assert_eq!(got.get(&((2, 5), 1)), Some(&1));
-    }
-
-    #[test]
-    fn builder_builds_corgi_batch() {
-        let rows: Vec<((DValue, DValue), u64, i64)> = vec![
-            ((DValue::Int(1), DValue::Int(10)), 0, 1),
-            ((DValue::Int(1), DValue::Int(10)), 0, 1), // dup -> consolidates to diff 2
-            ((DValue::Int(2), DValue::Int(20)), 0, 1),
-        ];
-        let desc = Description::new(Antichain::from_elem(0u64), Antichain::from_elem(1u64), Antichain::from_elem(0u64));
-        let mut b = CorgiBatchBuilder::<u64, i64>::with_capacity(0, 0, 3);
-        b.push(&mut rows.clone());
-        let batch = b.done(desc);
-        assert_eq!(batch.len(), 2, "consolidated to 2 distinct (key,val)");
-        let ks = batch.keys.clone().into_u64("k");
-        let vs = batch.vals.clone().into_u64("v");
-        // locate (1,10) and check its diff is 2
-        let idx = (0..batch.len()).find(|&i| ks[i] == 1 && vs[i] == 10).expect("(1,10) present");
-        assert_eq!(batch.diffs[idx], 2);
-    }
-
-    #[test]
-    fn merger_trait_drives() {
-        // Drive the Batch::Merger (fuel loop, as the spine does) and confirm == reference.
-        let u1 = vec![((0, 0), 0, 1), ((1, 0), 2, 1), ((1, 0), 5, 1)];
-        let u2 = vec![((1, 0), 2, 1), ((2, 3), 0, 1), ((0, 0), 0, -1)];
-        let f = 3u64;
-        let b1 = batch(&u1, 0, 10);
-        let b2 = batch(&u2, 0, 10);
-        let mut m = CorgiMerger::new(&b1, &b2, Antichain::from_elem(f).borrow());
-        loop {
-            let mut fuel = 1isize;
-            m.work(&b1, &b2, &mut fuel);
-            if fuel > 0 {
-                break;
-            }
-        }
-        let out = m.done();
-        assert_eq!(read(&out), reference(&u1, &u2, f));
-    }
-
-    #[test]
-    fn merge_matches_reference() {
-        let mut seed = 0x1234_5678_9abc_def1u64;
-        for _ in 0..300 {
-            let gen = |seed: &mut u64| -> Vec<((u64, u64), u64, i64)> {
-                let n = (xorshift(seed) % 30) as usize + 1;
-                (0..n)
-                    .map(|_| {
-                        let k = xorshift(seed) % 6;
-                        let v = xorshift(seed) % 4;
-                        let t = xorshift(seed) % 8;
-                        let d = if xorshift(seed) % 4 == 0 { -1 } else { 1 };
-                        ((k, v), t, d)
-                    })
-                    .collect()
-            };
-            let u1 = gen(&mut seed);
-            let u2 = gen(&mut seed);
-            let f = xorshift(&mut seed) % 8;
-
-            let b1 = batch(&u1, 0, 10);
-            let b2 = batch(&u2, 0, 10);
-            let merged = merge(&b1, &b2, Antichain::from_elem(f).borrow());
-
-            assert_eq!(read(&merged), reference(&u1, &u2, f), "f={f}\n u1={u1:?}\n u2={u2:?}");
-        }
-    }
-}
diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index 9e3ba4ef0..d8cf4eb69 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -17,7 +17,7 @@
 //! refill), so `gather_lanes` source indices stay valid for the whole call. The `Chunk` contract
 //! permits this — "consume at least one input; the harness may re-invoke."
 
-use std::collections::{HashMap, VecDeque};
+use std::collections::VecDeque;
 use std::rc::Rc;
 
 use timely::progress::{Antichain, Timestamp};
@@ -26,12 +26,11 @@ use timely::progress::frontier::AntichainRef;
 use differential_dataflow::difference::Semigroup;
 use differential_dataflow::lattice::Lattice;
 use differential_dataflow::trace::chunk::{merge_chains, pack, Chunk, ChunkBatch};
-use differential_dataflow::trace::{Builder as DdBuilder, Description};
+use differential_dataflow::trace::Description;
 
 use corgi::arrange::{compare_at, compare_idx, find_ranges, gather, gather_lanes, sort_perm};
 use corgi::Value as CValue;
 
-use crate::corgi_logic::{infer_shape_cols, transcode, untranscode};
 use crate::ir::Value as DValue;
 
 use std::cmp::Ordering;
@@ -388,51 +387,13 @@ where
     T: Timestamp + Lattice,
     R: Semigroup + Clone + 'static,
 {
-    /// One sorted+consolidated chunk from DDIR rows (the arrange-ingest transcode boundary). Shapes
-    /// are inferred by whole-column scan ([`infer_shape_cols`]) so variant arms resolve correctly.
-    pub fn from_rows(rows: &[Upd<T, R>]) -> Self {
-        if rows.is_empty() { return Self::default(); }
-        let keys_rows: Vec<DValue> = rows.iter().map(|u| u.0 .0.clone()).collect();
-        let vals_rows: Vec<DValue> = rows.iter().map(|u| u.0 .1.clone()).collect();
-        let keys = transcode(&keys_rows, &infer_shape_cols(&keys_rows));
-        let vals = transcode(&vals_rows, &infer_shape_cols(&vals_rows));
-        let times = rows.iter().map(|u| u.1.clone()).collect();
-        let diffs = rows.iter().map(|u| u.2.clone()).collect();
-        let (keys, vals, times, diffs) = sort_consolidate(keys, vals, times, diffs);
-        Self::from_parts(keys, vals, times, diffs)
-    }
-
     /// One sorted+consolidated chunk from columns already in corgi form (the column-native arrange
-    /// ingest — no transcode, unlike `from_rows`).
+    /// ingest — no transcode).
     pub fn from_columns(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
         let (keys, vals, times, diffs) = sort_consolidate(keys, vals, times, diffs);
         Self::from_parts(keys, vals, times, diffs)
     }
 
-    /// Untranscode this chunk back to DDIR rows (egress / history read).
-    pub fn to_rows(&self) -> Vec<Upd<T, R>> {
-        if self.len_() == 0 { return Vec::new(); }
-        let keys = untranscode(self.0.keys.clone(), &corgi::shape_of_value(&self.0.keys));
-        let vals = untranscode(self.0.vals.clone(), &corgi::shape_of_value(&self.0.vals));
-        keys.into_iter()
-            .zip(vals)
-            .zip(&self.0.times)
-            .zip(&self.0.diffs)
-            .map(|(((k, v), t), d)| ((k, v), t.clone(), d.clone()))
-            .collect()
-    }
-}
-
-/// Read a whole `ChunkBatch<CorgiChunk>` back to DDIR rows (across all chunks) — the cursor-less
-/// history read used by `as_collection` and the reduce tactic.
-pub fn batch_to_rows<T, R>(b: &ChunkBatch<CorgiChunk<T, R>>) -> Vec<Upd<T, R>>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    let mut out = Vec::new();
-    for ch in &b.chunks { out.extend(ch.to_rows()); }
-    out
 }
 
 /// Concatenate chunks' columns into flat `(keys, vals, times, diffs)` with **no transcode** — for
@@ -451,17 +412,6 @@ where
     (keys, vals, times, diffs)
 }
 
-/// Build a `ChunkBatch<CorgiChunk>` from DDIR rows: transcode+sort+consolidate into one chunk, then
-/// `settle` it into a graded chunk sequence.
-fn rows_to_batch<T, R>(rows: Vec<Upd<T, R>>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    let chunk = CorgiChunk::from_rows(&rows);
-    settle_one(chunk, description)
-}
-
 /// Build a `ChunkBatch<CorgiChunk>` from corgi key/val COLUMNS directly (no transcode): sort +
 /// consolidate into one chunk, then `settle`. The column-native egress the reduce backend seals its
 /// output with (it resolves proxy ids to real columns by `gather` and hands them here).
@@ -487,35 +437,6 @@ where
     ChunkBatch::new(output.into(), description)
 }
 
-/// DD [`Builder`](DdBuilder) that consumes sorted/consolidated row chains (the vec batcher's `Output`)
-/// and builds a `ChunkBatch<CorgiChunk>`. `Input = Vec<Upd>` so the existing `MergeBatcher` over vec
-/// rows can stay the arrange batcher; only the builder + trace become chunk-native. `RcBuilder` wraps
-/// it → `Rc<ChunkBatch<CorgiChunk>>`.
-pub struct CorgiChunkBuilder<T, R> {
-    rows: Vec<Upd<T, R>>,
-}
-
-impl<T, R> DdBuilder for CorgiChunkBuilder<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    type Input = Vec<Upd<T, R>>;
-    type Time = T;
-    type Output = ChunkBatch<CorgiChunk<T, R>>;
-
-    fn with_capacity(_keys: usize, _vals: usize, upds: usize) -> Self {
-        CorgiChunkBuilder { rows: Vec::with_capacity(upds) }
-    }
-    fn push(&mut self, chunk: &mut Self::Input) { self.rows.append(chunk); }
-    fn done(self, description: Description<T>) -> Self::Output { rows_to_batch(self.rows, description) }
-    fn seal(chain: &mut Vec<Self::Input>, description: Description<T>) -> Self::Output {
-        let mut all = Vec::new();
-        for c in chain.iter_mut() { all.append(c); }
-        rows_to_batch(all, description)
-    }
-}
-
 /// A column-native arrange **chunker**: turns input `CorgiContainer`s into sorted+consolidated
 /// `CorgiChunk`s WITHOUT `ContainerChunker`'s drain-to-rows (which untranscodes). Paired with the
 /// standard `ChunkBatcher`/`ChunkBuilder`, the arrange ingest stays column-native — no
@@ -688,95 +609,6 @@ where
     Some(SortedRun { keys, vals, times, diffs })
 }
 
-/// Group a key column by identity, returning integers only — the Rust↔corgi boundary primitive.
-/// `perm` lists row indices in group order; `ends[g]` is the exclusive end of group `g` within `perm`
-/// (so group `g`'s member rows are `perm[ends[g-1]..ends[g]]`, with `ends[-1] = 0`). DD orchestrates
-/// per group by index — it never sees a key `Value`; keys and payloads stay columnar in corgi. Built
-/// on the columnar discrimination sort + one batched adjacent-compare (no per-pair `compare_at`).
-pub fn group_offsets(col: &CValue) -> (Vec<usize>, Vec<usize>) {
-    let n = col.len();
-    if n == 0 {
-        return (Vec::new(), Vec::new());
-    }
-    let perm = sort_perm(col);
-    let sorted = gather(col, &perm);
-    let mut ends = Vec::new();
-    if n > 1 {
-        let left: Vec<usize> = (0..n - 1).collect();
-        let right: Vec<usize> = (1..n).collect();
-        // adj[i] == 0 iff sorted[i] == sorted[i+1] — a group boundary is where adj[i] != 0.
-        let adj = compare_idx(&sorted, &sorted, &left, &right);
-        for (i, &a) in adj.iter().enumerate() {
-            if a != 0 {
-                ends.push(i + 1);
-            }
-        }
-    }
-    ends.push(n);
-    (perm, ends)
-}
-
-/// Semijoin: for each key in `needle_keys` (a set of DDIR keys), gather its `(val, time, diff)`
-/// history from `batches` via a batched `find` probe over the flattened, sorted source — untranscoding
-/// only the matched rows, never the whole trace. Returns a `key -> history` map (only matched keys
-/// present), the drop-in replacement for grouping untranscode-all rows by key. `O(|needle|·log|source|)`
-/// probe + `O(matched)` untranscode, vs the old `O(|source|)` untranscode + hash-group.
-pub fn semijoin_history<T, R>(
-    batches: &[Rc<ChunkBatch<CorgiChunk<T, R>>>],
-    needle_keys: &[DValue],
-) -> HashMap<DValue, Vec<(DValue, T, R)>>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    let mut out: HashMap<DValue, Vec<(DValue, T, R)>> = HashMap::new();
-    if needle_keys.is_empty() {
-        return out;
-    }
-    // Each chunk already holds a sorted key column, so probe each in place — NO flatten/merge (which
-    // would re-materialize the whole accumulated trace every round). Transcode the needle once with
-    // the arrangement's key shape (taken from the first non-empty chunk; the schema is uniform).
-    let shape = batches
-        .iter()
-        .flat_map(|b| b.chunks.iter())
-        .find(|c| c.len_() > 0)
-        .map(|c| corgi::shape_of_value(c.keys()));
-    let Some(shape) = shape else { return out };
-    let needle_col = transcode(needle_keys, &shape);
-
-    for b in batches {
-        for chunk in &b.chunks {
-            if chunk.len_() == 0 {
-                continue;
-            }
-            let (lo, hi) = find_ranges(&needle_col, chunk.keys());
-            let mut matched: Vec<usize> = Vec::new();
-            for i in 0..needle_keys.len() {
-                matched.extend(lo[i]..hi[i]);
-            }
-            if matched.is_empty() {
-                continue;
-            }
-            let vcol = gather(chunk.vals(), &matched);
-            let vals = untranscode(vcol.clone(), &corgi::shape_of_value(&vcol));
-            let mut c = 0;
-            for i in 0..needle_keys.len() {
-                let len = hi[i] - lo[i];
-                if len == 0 {
-                    continue;
-                }
-                let entry = out.entry(needle_keys[i].clone()).or_default();
-                for k in 0..len {
-                    let r = matched[c + k];
-                    entry.push((vals[c + k].clone(), chunk.times()[r].clone(), chunk.diffs()[r].clone()));
-                }
-                c += len;
-            }
-        }
-    }
-    out
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -786,22 +618,6 @@ mod test {
 
     fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
 
-    #[test]
-    fn group_offsets_partitions_by_key() {
-        // keys 3,1,1,2,3 → groups key1={rows 1,2}, key2={row 3}, key3={rows 0,4}.
-        let col = CValue::u64(vec![3, 1, 1, 2, 3]);
-        let (perm, ends) = group_offsets(&col);
-        let mut groups: Vec<Vec<usize>> = Vec::new();
-        let mut start = 0;
-        for &e in &ends {
-            let mut g = perm[start..e].to_vec();
-            g.sort();
-            groups.push(g);
-            start = e;
-        }
-        assert_eq!(groups, vec![vec![1, 2], vec![3], vec![0, 4]]);
-    }
-
     /// Build a single sorted+consolidated CorgiChunk from u64 (key,val,time,diff) rows.
     fn chunk(rows: &[((u64, u64), u64, i64)]) -> CorgiChunk<u64, i64> {
         // Sort + consolidate by ((k,v),t) so a chunk is a legal sorted run.
diff --git a/interactive/src/corgi_reduce.rs b/interactive/src/corgi_reduce.rs
deleted file mode 100644
index ebf575afc..000000000
--- a/interactive/src/corgi_reduce.rs
+++ /dev/null
@@ -1,368 +0,0 @@
-//! Phase 2 / M2(b) — the cursor-less corgi REDUCE tactic (Route B), built on Frank's `active_times`.
-//!
-//! `reduce_with_tactic` needs only `TraceReader` (not `Navigable`), so a cursor-less `CorgiBatch`
-//! arrangement drives a custom `ReduceTactic`. The incremental skeleton mirrors DD's `CursorTactic`/
-//! `HistoryReplayer` but swaps the lazy interesting-time derivation for the explicit (over-deriving)
-//! `active_times`, and the cursor reads for corgi-column reads:
-//!
-//!   per changed key (input keys ∪ carried pending keys):
-//!     read input history (source+input batches) & output history (output batches) to rows
-//!     novel = input times in [lower,upper) ∪ carried pending times;  prior = input times < lower
-//!     active_times(upper, prior, novel) -> active (∈[lower,upper)) + pended (≥upper)
-//!     for t in active (increasing): desired = reduce(Σ input ≤ t); cur = Σ (output ≤ t ⊎ emitted ≤ t)
-//!       emit (desired − cur) at t, into the held bucket = largest held time ≤ t
-//!     carry pended → next pending
-//!   build one output batch per held time (tile [lower,upper)); held frontier = pending times
-//!
-//! The per-key reducer runs in RUST (the DDIR `Reducer`s, matching `backend::vec`) — at each
-//! interesting time it sees a tiny per-key value slice, where corgi's columnar win doesn't apply
-//! (corgi pays on wide columns); corgi's role in reduce is the columnar *storage* + merge/advance.
-
-use std::collections::{BTreeSet, HashMap};
-use std::rc::Rc;
-
-use timely::progress::{Antichain, Timestamp};
-use timely::progress::frontier::AntichainRef;
-
-use differential_dataflow::lattice::Lattice;
-use differential_dataflow::operators::reduce::ReduceTactic;
-use differential_dataflow::trace::Builder as _;
-use differential_dataflow::trace::Description;
-use differential_dataflow::trace::chunk::ChunkBatch;
-
-use corgi::{eval_graph, parse_ml, Bounds, Value as CValue};
-
-use crate::corgi_chunk::{batch_to_rows, CorgiChunk, CorgiChunkBuilder};
-use crate::ir::{Diff, Value as DValue};
-use crate::parse::Reducer;
-
-type Row = DValue;
-
-/// Columnar per-key sum — the monoid `Count`/consolidate fold as the value building block for a
-/// column-native reduce, driven entirely by corgi ops (`group → map(fold_add) → filter`), touching
-/// no `Value` rows. Diffs are passed as RAW two's-complement `u64` bits so `fold_add`'s wrapping add
-/// is the correct `i64` sum and `ne 0` is the sign-agnostic zero-drop (per the corgi note). Returns
-/// the surviving `(key column, per-key raw-bit sums)`. (Groundwork: the wave loop will call this
-/// across many keys at once; not yet wired into the live reduce.)
-#[allow(dead_code)]
-fn columnar_sum_by_key(keys: CValue, diffs_raw: CValue) -> (CValue, Vec<u64>) {
-    const ML: &str = "let acc = input group map ((k, vs) -> (k, vs fold_add)) in \
-                      let keep = acc map ((k, s) -> s ne 0) in \
-                      (acc, keep) filter";
-    let n = keys.len();
-    if n == 0 {
-        return (CValue::Unit(0), Vec::new());
-    }
-    let input = CValue::List(Bounds::Offsets(vec![n]), Box::new(CValue::Prod(vec![keys, diffs_raw])));
-    let graph = parse_ml(ML).expect("parse consolidate ML");
-    let out = eval_graph(&graph, input);
-    let (_bounds, vals) = out.into_list("consolidate output");
-    let (keys_out, sums) = vals.into_pair("consolidate (key, sum)");
-    (keys_out, sums.into_u64("consolidate sums"))
-}
-
-/// Columnar `Distinct`: the keys with at least one **present** value, where "present" = net diff ≠ 0
-/// (the nonzero simplification — ignores the signed sign of the accumulation for now). Two-level
-/// consolidate over `(key, val)`: group by the `(key,val)` composite, `fold_add` the raw diffs, keep
-/// the nonzero, then take the distinct keys of the survivors. Returns the surviving key column.
-#[allow(dead_code)]
-fn columnar_distinct_keys(keys: CValue, vals: CValue, diffs_raw: CValue) -> CValue {
-    // input : List<((key,val), diff)> — group by the (key,val) composite, sum diffs, drop net-zero,
-    // re-key to (key, _), group by key → distinct present keys.
-    const ML: &str = "let net = input group map ((kv, ds) -> (kv, ds fold_add)) in \
-                      let keep = net map ((kv, s) -> s ne 0) in \
-                      let present = (net, keep) filter in \
-                      let rekey = present map ((kv, s) -> (kv.0, s)) in \
-                      rekey group map ((k, ss) -> k)";
-    let n = keys.len();
-    if n == 0 {
-        return CValue::Unit(0);
-    }
-    let composite = CValue::Prod(vec![keys, vals]);
-    let input = CValue::List(Bounds::Offsets(vec![n]), Box::new(CValue::Prod(vec![composite, diffs_raw])));
-    let out = eval_graph(&parse_ml(ML).expect("parse distinct ML"), input);
-    // out : List<key> — one row of the surviving keys.
-    let (_bounds, keys_out) = out.into_list("distinct output");
-    keys_out
-}
-
-#[cfg(test)]
-mod consolidate_test {
-    use super::*;
-
-    #[test]
-    fn columnar_distinct_keeps_present_keys() {
-        // (1,10):+1,-1 → net 0 (absent); (2,20):+1, (2,21):+1 (present); (3,30):+1 (present).
-        let keys = CValue::u64(vec![1, 1, 2, 2, 3]);
-        let vals = CValue::u64(vec![10, 10, 20, 21, 30]);
-        let diffs = CValue::u64(vec![1u64, (-1i64) as u64, 1, 1, 1]);
-        let present = columnar_distinct_keys(keys, vals, diffs);
-        assert_eq!(present.into_u64("present"), vec![2, 3]);
-    }
-
-    #[test]
-    fn columnar_consolidate_sums_and_drops_zeros() {
-        // keys 1,1,2,3,3 with raw-bit diffs +1,-1,5,9,1 → key 1 nets 0 (dropped), 2→5, 3→10.
-        let keys = CValue::u64(vec![1, 1, 2, 3, 3]);
-        let diffs = CValue::u64(vec![1u64, (-1i64) as u64, 5, 9, 1]);
-        let (kout, sums) = columnar_sum_by_key(keys, diffs);
-        let ks = kout.into_u64("k");
-        let got: Vec<(u64, i64)> = ks.iter().zip(&sums).map(|(&k, &s)| (k, s as i64)).collect();
-        assert_eq!(got, vec![(2, 5), (3, 10)]);
-    }
-}
-
-/// Determines the active times for an interval `[lower, upper)` (Frank's definition).
-///
-/// Active times are joins of input times (`novel` + `prior`) that are `>= lower` but not `>= upper`;
-/// the over-derivation is sound (a non-changing time yields a zero delta). Times `>= upper` are
-/// `pended` for a future interval. `novel ∈ [lower, upper)` (seeds); `prior ∈ ..lower)` (join partners).
-fn active_times<T: Lattice + Ord + Clone>(
-    upper: AntichainRef<T>,
-    prior: &[T],
-    novel: &[T],
-    active: &mut BTreeSet<T>,
-    pended: &mut BTreeSet<T>,
-) {
-    let mut todo: BTreeSet<T> = novel.iter().cloned().collect();
-    while let Some(next) = todo.pop_first() {
-        if upper.less_equal(&next) {
-            pended.insert(next);
-        } else if active.insert(next.clone()) {
-            for t in novel.iter().chain(prior.iter()) {
-                let join = next.join(t);
-                if !active.contains(&join) {
-                    todo.insert(join);
-                }
-            }
-        }
-    }
-}
-
-/// Consolidate `(val, diff)` pairs (sum per val, drop zeros), sorted by val.
-fn consolidate_vals(mut v: Vec<(Row, Diff)>) -> Vec<(Row, Diff)> {
-    v.sort_by(|a, b| a.0.cmp(&b.0));
-    let mut out: Vec<(Row, Diff)> = Vec::with_capacity(v.len());
-    for (val, d) in v {
-        if let Some(last) = out.last_mut() {
-            if last.0 == val {
-                last.1 += d;
-                continue;
-            }
-        }
-        out.push((val, d));
-    }
-    out.retain(|(_, d)| *d != 0);
-    out
-}
-
-/// The DDIR reducers, in Rust — matching `backend::vec`'s closures so output == the vec backend.
-fn reduce_logic(reducer: &Reducer, input: &[(Row, Diff)]) -> Vec<(Row, Diff)> {
-    match reducer {
-        Reducer::Min => input
-            .iter()
-            .filter(|(_, d)| *d > 0)
-            .map(|(v, _)| v.clone())
-            .min()
-            .map(|m| vec![(m, 1)])
-            .unwrap_or_default(),
-        Reducer::Distinct => {
-            if input.iter().any(|(_, d)| *d > 0) {
-                vec![(DValue::unit(), 1)]
-            } else {
-                Vec::new()
-            }
-        }
-        Reducer::Count => {
-            let count: Diff = input.iter().map(|(_, d)| *d).sum();
-            if count > 0 {
-                vec![(DValue::Tuple(vec![DValue::Int(count)]), 1)]
-            } else {
-                Vec::new()
-            }
-        }
-        Reducer::Collect => {
-            let mut items = Vec::new();
-            for (v, d) in input {
-                for _ in 0..(*d).max(0) {
-                    items.push(v.clone());
-                }
-            }
-            vec![(DValue::List(items), 1)]
-        }
-    }
-}
-
-/// Cursor-less corgi reduce tactic. Stateful: carries per-key pending (deferred ≥upper) times.
-pub struct CorgiReduceTactic<T> {
-    reducer: Reducer,
-    pending: HashMap<Row, Vec<T>>,
-}
-
-impl<T> CorgiReduceTactic<T> {
-    pub fn new(reducer: Reducer) -> Self {
-        CorgiReduceTactic { reducer, pending: HashMap::new() }
-    }
-}
-
-impl<T> ReduceTactic<Rc<ChunkBatch<CorgiChunk<T, Diff>>>, Rc<ChunkBatch<CorgiChunk<T, Diff>>>> for CorgiReduceTactic<T>
-where
-    T: Timestamp + Lattice + Ord,
-{
-    fn retire(
-        &mut self,
-        source_batches: Vec<Rc<ChunkBatch<CorgiChunk<T, Diff>>>>,
-        output_batches: Vec<Rc<ChunkBatch<CorgiChunk<T, Diff>>>>,
-        input_batches: Vec<Rc<ChunkBatch<CorgiChunk<T, Diff>>>>,
-        lower: &Antichain<T>,
-        upper: &Antichain<T>,
-        held: &Antichain<T>,
-    ) -> (Vec<(T, Rc<ChunkBatch<CorgiChunk<T, Diff>>>)>, Antichain<T>) {
-        // Only work if we hold a time we can actually ship in [.., upper).
-        if held.elements().iter().all(|t| upper.less_equal(t)) {
-            return (Vec::new(), held.clone());
-        }
-
-        // Incremental key selection: only keys touched by the new input delta (`input_batches`) or
-        // carrying pending times can change output in [lower, upper). Unchanged accumulated keys
-        // cannot — reconsidering them was an O(all keys × rounds) blowup (mirrors DD's reduce, which
-        // only recomputes keys the new batch touches). Restricting the per-key histories to `changed`
-        // also keeps `group_by_key`'s BTreeMap + `Value::cmp` cost proportional to the delta.
-        let mut changed: std::collections::HashSet<Row> = std::collections::HashSet::new();
-        for b in &input_batches {
-            for ((k, _), _, _) in batch_to_rows(b) { changed.insert(k); }
-        }
-        for k in self.pending.keys() { changed.insert(k.clone()); }
-        if changed.is_empty() {
-            // No input delta and no carried pending → no key's output can change this interval, and
-            // nothing remains to hold. Downgrade to the EMPTY frontier: this matches what the full
-            // flow computes (an empty `pending` → empty frontier). Returning `held` here would keep
-            // the capability forever and DEADLOCK a recursive scope (scc), which reach never exercised.
-            self.pending.clear();
-            return (Vec::new(), Antichain::new());
-        }
-
-        // Full per-key input history (source ∪ input) and output history, restricted to `changed`.
-        // (A `find`-semijoin read was tried here and measured SLOWER: the source read is only ~7% of
-        // reduce cost, and `find`'s per-chunk overhead exceeds the untranscode it saves. The dominant
-        // cost is the row-wise per-key compute below, which needs a columnar segmented-fold, not a
-        // faster read. See `corgi_chunk::semijoin_history` — kept for when that lands / at larger scale.)
-        let mut input_hist: HashMap<Row, Vec<(Row, T, Diff)>> = HashMap::new();
-        for b in source_batches.iter().chain(input_batches.iter()) {
-            for ((k, v), t, d) in batch_to_rows(b) {
-                if changed.contains(&k) { input_hist.entry(k).or_default().push((v, t, d)); }
-            }
-        }
-        let mut output_hist: HashMap<Row, Vec<(Row, T, Diff)>> = HashMap::new();
-        for b in &output_batches {
-            for ((k, v), t, d) in batch_to_rows(b) {
-                if changed.contains(&k) { output_hist.entry(k).or_default().push((v, t, d)); }
-            }
-        }
-        let keys = changed;
-
-        // One output-row buffer per held time (ship-time bucket); a delta at `t` routes to the
-        // largest held time `<= t`.
-        let held_elems: Vec<T> = held.elements().to_vec();
-        let mut builders: Vec<Vec<((Row, Row), T, Diff)>> = vec![Vec::new(); held_elems.len()];
-
-        let mut new_pending: HashMap<Row, Vec<T>> = HashMap::new();
-
-        for key in keys {
-            let in_hist = input_hist.get(&key).cloned().unwrap_or_default();
-            let out_hist = output_hist.get(&key).cloned().unwrap_or_default();
-
-            // novel (seeds) = input times in [lower,upper) ∪ carried pending; prior = times < lower.
-            let mut novel: Vec<T> = in_hist
-                .iter()
-                .map(|(_, t, _)| t.clone())
-                .filter(|t| lower.less_equal(t) && !upper.less_equal(t))
-                .collect();
-            if let Some(p) = self.pending.get(&key) {
-                novel.extend(p.iter().cloned());
-            }
-            let prior: Vec<T> = in_hist.iter().map(|(_, t, _)| t.clone()).filter(|t| !lower.less_equal(t)).collect();
-            novel.sort();
-            novel.dedup();
-
-            let mut active = BTreeSet::new();
-            let mut pended = BTreeSet::new();
-            active_times(upper.borrow(), &prior, &novel, &mut active, &mut pended);
-            if !pended.is_empty() {
-                new_pending.entry(key.clone()).or_default().extend(pended);
-            }
-            if active.is_empty() {
-                continue;
-            }
-
-            // Running output (committed output + deltas emitted this pass), accumulated as-of each t.
-            let mut emitted: Vec<(Row, T, Diff)> = Vec::new();
-            for t in active {
-                // Count = Σ diffs ≤ t: summing the consolidated per-value diffs equals summing the raw
-                // diffs, so skip the per-value consolidation (and its Value sort/clones) entirely.
-                let desired = if matches!(self.reducer, Reducer::Count) {
-                    let c: Diff = in_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(_, _, d)| *d).sum();
-                    if c > 0 { vec![(DValue::Tuple(vec![DValue::Int(c)]), 1)] } else { Vec::new() }
-                } else {
-                    let in_acc = consolidate_vals(
-                        in_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect(),
-                    );
-                    reduce_logic(&self.reducer, &in_acc)
-                };
-
-                let mut cur: Vec<(Row, Diff)> =
-                    out_hist.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)).collect();
-                cur.extend(emitted.iter().filter(|(_, ti, _)| ti.less_equal(&t)).map(|(v, _, d)| (v.clone(), *d)));
-                let cur = consolidate_vals(cur);
-
-                let mut delta: HashMap<Row, Diff> = HashMap::new();
-                for (v, d) in desired {
-                    *delta.entry(v).or_insert(0) += d;
-                }
-                for (v, d) in cur {
-                    *delta.entry(v).or_insert(0) -= d;
-                }
-                delta.retain(|_, d| *d != 0);
-                if delta.is_empty() {
-                    continue;
-                }
-
-                let idx = held_elems.iter().rposition(|h| h.less_equal(&t)).expect("no held capability <= active time");
-                for (v, d) in delta {
-                    emitted.push((v.clone(), t.clone(), d));
-                    builders[idx].push(((key.clone(), v), t.clone(), d));
-                }
-            }
-        }
-
-        self.pending = new_pending;
-
-        // Build one output batch per held time, tiling [lower, upper) (mirrors CursorTactic).
-        let mut produced = Vec::new();
-        let mut out_lower = lower.clone();
-        for (index, rows) in builders.into_iter().enumerate() {
-            let mut out_upper = upper.clone();
-            for t in &held_elems[index + 1..] {
-                out_upper.insert(t.clone());
-            }
-            if out_upper != out_lower {
-                let desc = Description::new(out_lower.clone(), out_upper.clone(), Antichain::from_elem(T::minimum()));
-                let mut builder = CorgiChunkBuilder::<T, Diff>::with_capacity(0, 0, rows.len());
-                let mut rows = rows;
-                builder.push(&mut rows);
-                let batch = Rc::new(builder.done(desc));
-                produced.push((held_elems[index].clone(), batch));
-                out_lower = out_upper;
-            }
-        }
-
-        // New held frontier = all carried pending times.
-        let mut frontier = Antichain::new();
-        for times in self.pending.values() {
-            for t in times {
-                frontier.insert(t.clone());
-            }
-        }
-        (produced, frontier)
-    }
-}
diff --git a/interactive/src/lib.rs b/interactive/src/lib.rs
index 4764a17cf..776d9f606 100644
--- a/interactive/src/lib.rs
+++ b/interactive/src/lib.rs
@@ -2,10 +2,8 @@ pub mod parse;
 pub mod ir;
 pub mod corgi_logic;
 pub mod corgi_backend;
-pub mod corgi_arrange;
 pub mod corgi_chunk;
 pub mod corgi_join;
-pub mod corgi_reduce;
 pub mod corgi_reduce_backend;
 pub mod lower;
 pub mod scope_ir;

From df00ba80a363fdc681b041777968b8794a67b07e Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 10 Jul 2026 17:10:53 -0400
Subject: [PATCH 39/68] Re-port corgi onto the merged #781 seam (windowed
 reduce + iterator join)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reduce backend → the windowed ProxyReduceBackend: seed_times(+ReduceInstance),
begin (open tiled session), next_window (single window = all changed keys; build
input+output ProxyBridges via collect_present + consolidate_updates), and the new
reduce_corrections (reduce_brackets for desired, then difference vs. presented
output per value_id — the backend now owns the desired−current subtraction),
emit/finish (tiled column materialization). Content-hash value_ids + in_index
resolution as before; ProxyChunk/from_unsorted gone.

Join tactic → the #790 iterator contract: defer/work collapse to prep returning
Box<dyn Iterator<Item = CorgiContainer>>; run_unit now returns the container
instead of a session give_container. meet ignored (correctness-first).

CorgiContainer already impls Accountable; fixed the join_with_tactic container
(not builder) generic at the call site.

Gates green on merged master-next DD: corgi_progs 6/6 match vec, incl. scc.
Structural order (correctness first); hash-order + join hash-probe = Phase 2b.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../examples/columnar/main.rs                 |    3 +-
 .../src/operators/arrange/arrangement.rs      |    2 +-
 .../src/operators/int_proxy/history.rs        |  116 +-
 .../src/operators/int_proxy/join.rs           |  299 +++--
 .../src/operators/int_proxy/mod.rs            |  148 +--
 .../src/operators/int_proxy/reduce.rs         |  759 +++++------
 .../src/operators/int_proxy/reference.rs      |  353 -----
 differential-dataflow/src/operators/join.rs   |  366 +++---
 differential-dataflow/src/operators/mod.rs    |   92 +-
 differential-dataflow/src/operators/reduce.rs |   66 +-
 .../src/trace/chunk/int_proxy.rs              |  542 --------
 differential-dataflow/src/trace/chunk/mod.rs  |    1 -
 differential-dataflow/tests/int_proxy.rs      | 1143 -----------------
 .../tests/reduce_reference.rs                 |   85 +-
 interactive/src/backend/corgi.rs              |    2 +-
 interactive/src/corgi_join.rs                 |   70 +-
 interactive/src/corgi_reduce_backend.rs       |  184 ++-
 17 files changed, 1056 insertions(+), 3175 deletions(-)
 delete mode 100644 differential-dataflow/src/operators/int_proxy/reference.rs
 delete mode 100644 differential-dataflow/src/trace/chunk/int_proxy.rs
 delete mode 100644 differential-dataflow/tests/int_proxy.rs

diff --git a/differential-dataflow/examples/columnar/main.rs b/differential-dataflow/examples/columnar/main.rs
index 692f1fd27..d8775f44e 100644
--- a/differential-dataflow/examples/columnar/main.rs
+++ b/differential-dataflow/examples/columnar/main.rs
@@ -90,6 +90,7 @@ fn main() {
 /// Push on UpdatesTyped for the reduce builder path.
 mod reachability {
 
+    use timely::container::PushInto;
     use timely::order::Product;
     use differential_dataflow::Collection;
     use differential_dataflow::AsCollection;
@@ -149,7 +150,7 @@ mod reachability {
                         use differential_dataflow::difference::Multiply;
                         let dst: Node = *dst;
                         let diff: Diff = d1.clone().multiply(d2);
-                        session.give::<(Node, (), IterTime, Diff)>((dst, (), time.clone(), diff));
+                        session.push_into((dst, (), time.clone(), diff));
                     },
                 ).as_collection();
 
diff --git a/differential-dataflow/src/operators/arrange/arrangement.rs b/differential-dataflow/src/operators/arrange/arrangement.rs
index bb7f74f6f..359ad8945 100644
--- a/differential-dataflow/src/operators/arrange/arrangement.rs
+++ b/differential-dataflow/src/operators/arrange/arrangement.rs
@@ -251,7 +251,7 @@ impl<'scope, Tr1: TraceReader<Batch: Navigable>+'static> Arranged<'scope, Tr1> {
             other,
             move |k, v1, v2, t, d1, d2, c| {
                 for datum in result(k, v1, v2, t, d1, d2) {
-                    c.give(datum);
+                    c.push_into(datum);
                 }
             }
         )
diff --git a/differential-dataflow/src/operators/int_proxy/history.rs b/differential-dataflow/src/operators/int_proxy/history.rs
index 84edcc1c0..c2a8febe4 100644
--- a/differential-dataflow/src/operators/int_proxy/history.rs
+++ b/differential-dataflow/src/operators/int_proxy/history.rs
@@ -1,114 +1,16 @@
 //! Time-ordered replay of proxy update histories, with meet-advancement.
-//!
-//! The id-space port of the cursor tactics' [`ValueHistory`] machinery: a run of
-//! `(value_id, time, diff)` edits is replayed in ascending time order, stepping edits
-//! into a working buffer that is repeatedly *advanced* — times joined with the meet of
-//! the times still to be considered — and consolidated. Advancement is what keeps the
-//! buffer collapsed (for totally ordered times, a whole prefix folds to a single time
-//! per value id), which is what keeps a key with many distinct times linear instead of
-//! quadratic: accumulations read the small buffer, never the raw history.
-//!
-//! [`ValueHistory`]: crate::operators::ValueHistory (private; see `operators/mod.rs`)
 
-use crate::difference::Semigroup;
 use crate::lattice::Lattice;
 
-/// A replayable history of `(value_id, time, diff)` edits.
-pub(crate) struct IdHistory<T, R> {
-    /// Un-replayed edits as `(time, meet, value_id, diff)`, sorted descending by
-    /// `(time, value_id)` so popping replays ascending; `meet` is the meet of this
-    /// edit's time with all times later in the replay (i.e. of the remaining suffix).
-    history: Vec<(T, T, u64, R)>,
-    /// Stepped-in edits, advanced and consolidated: `((value_id, time), diff)`, sorted.
-    buffer: Vec<((u64, T), R)>,
-}
-
-impl<T: Lattice + Clone + Ord, R: Semigroup + Clone> IdHistory<T, R> {
-    pub fn new() -> Self {
-        IdHistory { history: Vec::new(), buffer: Vec::new() }
-    }
-
-    /// Load `edits`, advancing each time by `advance_by` if supplied, and organize the
-    /// replay (sort + suffix meets).
-    pub fn load(&mut self, edits: impl Iterator<Item = (u64, T, R)>, advance_by: Option<&T>) {
-        self.history.clear();
-        self.buffer.clear();
-        for (vid, mut time, diff) in edits {
-            if let Some(m) = advance_by {
-                time = time.join(m);
-            }
-            self.history.push((time.clone(), time, vid, diff));
-        }
-        self.history.sort_by(|x, y| (&y.0, y.2).cmp(&(&x.0, x.2)));
-        self.history.iter_mut().reduce(|prev, cur| {
-            cur.1.meet_assign(&prev.1);
-            cur
-        });
-    }
-
-    /// The next (least) un-replayed time.
-    pub fn time(&self) -> Option<&T> {
-        self.history.last().map(|x| &x.0)
-    }
-    /// The meet of all un-replayed times.
-    pub fn meet(&self) -> Option<&T> {
-        self.history.last().map(|x| &x.1)
-    }
-    /// The next un-replayed edit, as `(value_id, time, diff)`.
-    pub fn edit(&self) -> Option<(u64, &T, &R)> {
-        self.history.last().map(|(t, _, v, d)| (*v, t, d))
-    }
-
-    /// Move the next edit into the buffer.
-    pub fn step(&mut self) {
-        let (time, _, vid, diff) = self.history.pop().unwrap();
-        self.buffer.push(((vid, time), diff));
-    }
-    /// Step edits while the next time equals `time`; true iff any did.
-    pub fn step_while_time_is(&mut self, time: &T) -> bool {
-        let mut found = false;
-        while self.time() == Some(time) {
-            found = true;
-            self.step();
-        }
-        found
-    }
-    /// Step edits while the next time is at most `time` in the *total* order (a
-    /// superset of the partially-ordered downset; readers filter the buffer by
-    /// `less_equal` themselves).
-    pub fn step_through(&mut self, time: &T) {
-        while self.time().is_some_and(|t| t <= time) {
-            self.step();
-        }
-    }
+/// A value history suitable for integer proxy values.
+pub(in crate::operators) type IdHistory<T, R> = crate::operators::ValueHistory<u64, T, R>;
 
-    /// Advance buffered times by `meet` and consolidate — the collapse that keeps
-    /// replay linear.
-    pub fn advance_buffer_by(&mut self, meet: &T) {
-        for ((_, time), _) in self.buffer.iter_mut() {
-            *time = time.join(meet);
-        }
-        crate::consolidation::consolidate(&mut self.buffer);
-    }
-
-    /// The buffered (stepped-in, advanced, consolidated) edits.
-    pub fn buffer(&self) -> &[((u64, T), R)] {
-        &self.buffer
-    }
-
-}
-
-/// A replayable history of interesting *times* — the seed source, ported from the same
-/// [`ValueHistory`] machinery but carrying no values or diffs.
-///
-/// The reduce tactic seeds from the batch's `(key, time)` support and never reads the
-/// batch's values or diffs (only its times drive interestingness and the synthetic-join
-/// closure). Seeds may over-approximate `b.support` — a spurious interesting time yields
-/// a zero delta and is discarded — so the times are taken raw, unconsolidated. Meet-
-/// advancement still collapses the buffer, keeping a key with many distinct batch times
-/// linear (the `*_scaling` shapes) rather than quadratic.
+/// A value history minus the values (and diffs).
 ///
-/// [`ValueHistory`]: crate::operators::ValueHistory (private; see `operators/mod.rs`)
+/// This type mirrors ValueHistory, but traverses only the times and does not watch for
+/// cancelation of data (and their times). We may learn that that pattern is preferred,
+/// but for the moment the int-proxy tactic determines all interesting times before any
+/// collection manipulation (and potential cancelation) occurs.
 pub(crate) struct TimeHistory<T> {
     /// Un-replayed `(time, meet)`, sorted descending by time so popping replays ascending;
     /// `meet` is the meet of this time with all times later in the replay.
@@ -118,9 +20,7 @@ pub(crate) struct TimeHistory<T> {
 }
 
 impl<T: Lattice + Clone + Ord> TimeHistory<T> {
-    pub fn new() -> Self {
-        TimeHistory { history: Vec::new(), buffer: Vec::new() }
-    }
+    pub fn new() -> Self { TimeHistory { history: Vec::new(), buffer: Vec::new() } }
 
     /// Load `times`, advancing each by `advance_by` if supplied, and organize the replay
     /// (sort + suffix meets).
diff --git a/differential-dataflow/src/operators/int_proxy/join.rs b/differential-dataflow/src/operators/int_proxy/join.rs
index 6d26ebb9d..dbda06db0 100644
--- a/differential-dataflow/src/operators/int_proxy/join.rs
+++ b/differential-dataflow/src/operators/int_proxy/join.rs
@@ -1,27 +1,33 @@
-//! The proxy join: equi-match by `key_hash`, value work by matched index lists.
+//! The proxy join framework.
+//!
+//! A conventional differential join against `(u64, u64)` values, which are provided by
+//! and then interpreted by a backend, who is relieved of lattice-time reasoning.
 
-use std::collections::VecDeque;
-
-use timely::ContainerBuilder;
-use timely::dataflow::operators::Capability;
-use timely::dataflow::operators::generic::OutputBuilderSession;
-
-use timely::progress::Timestamp;
+use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
 
 use crate::difference::{Multiply, Semigroup};
 use crate::lattice::Lattice;
 use crate::trace::BatchReader;
-use crate::trace::chunk::int_proxy::ProxyChunk;
-use crate::operators::join::{EffortBuilder, Fresh, JoinTactic};
+use super::ProxyBridge;
+use crate::operators::join::{Fresh, JoinTactic};
 
 use super::history::IdHistory;
 
-/// The join backend: value semantics for a proxy-space equijoin.
+/// A unit of proxied join work, presented to the backend.
+pub struct JoinInstance<'a, B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
+    /// The first input's batches.
+    pub batches0: &'a [B0],
+    /// The second input's batches.
+    pub batches1: &'a [B1],
+    /// The compaction frontier for loading (the unit's capability time).
+    pub lower: AntichainRef<'a, B0::Time>,
+}
+
+/// A type that can interpret and retire pairs of batches, joined by key hashes.
 ///
-/// Protocol (per deferred work unit, driven by [`ProxyJoinTactic`]): one `present0`, one
-/// `present1`, then at most one `cross` whose indices refer to those two presentations.
-/// The backend must keep each presentation's alignment (run index → real record) until
-/// the `cross` call.
+/// The protocol invokes the `present*` methods with the instance to produce the proxy collection,
+/// and then returns with any number (including zero) calls to `cross` to produce outputs.
 pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     /// Diff type presented for the first input.
     type R0: Semigroup + Multiply<Self::R1, Output = Self::ROut>;
@@ -29,217 +35,198 @@ pub trait ProxyJoinBackend<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
     type R1: Semigroup;
     /// Diff type of matched records (`R0 * R1`), computed by the tactic.
     type ROut: Semigroup;
-    /// The output container built from matched index lists.
+    /// The output container built from matched value ids.
     type Output;
 
-    /// (read) Flatten `batches` into one sorted, consolidated proxy run. When `filter` is
-    /// set (sorted key hashes), restrict to records of those keys: the tactic presents a
-    /// unit's fresh side unfiltered and passes its key set when presenting the
-    /// accumulated side, so per-unit work tracks the fresh batch, not the accumulated
-    /// trace — the join analogue of reduce's changed-key restriction, and just as
-    /// load-bearing (without it, a small update against a large trace re-reads the
-    /// trace).
-    fn present0(&mut self, batches: &[B0], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, Self::R0>;
-    /// (read) As `present0`, for the second input.
-    fn present1(&mut self, batches: &[B1], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, Self::R1>;
-    /// (value work) The projection. `left[i]`/`right[i]` index the current presentations;
-    /// each pair matched on `key_hash`. `times[i]`/`diffs[i]` are the DD-computed lattice
-    /// join of the pair's times and product of its diffs, to carry through per record.
-    fn cross(&mut self, left: &[usize], right: &[usize], times: Vec<B0::Time>, diffs: Vec<Self::ROut>) -> Self::Output;
+    /// Prepare a proxy bridge from the instance's first input, optionally key-hash restricted.
+    ///
+    /// The returned bridge **must be sorted and consolidated** by `((key_hash, value_id), time)`.
+    fn present0(&mut self, instance: &JoinInstance<'_, B0, B1>, filter: Option<&[u64]>) -> ProxyBridge<B0::Time, Self::R0>;
+    /// Prepare a proxy bridge from the instance's second input, optionally key-hash restricted.
+    ///
+    /// The returned bridge **must be sorted and consolidated** by `((key_hash, value_id), time)`.
+    fn present1(&mut self, instance: &JoinInstance<'_, B0, B1>, filter: Option<&[u64]>) -> ProxyBridge<B0::Time, Self::R1>;
+    /// From a list of left and right identifiers, and corresponding times and diffs, the output.
+    fn cross(&mut self, instance: &JoinInstance<'_, B0, B1>, left: &[(u64, u64)], right: &[(u64, u64)], times: Vec<B0::Time>, diffs: Vec<Self::ROut>) -> Self::Output;
 }
 
 /// A proxy-space [`JoinTactic`]: matches records of the two presented runs by `key_hash`,
-/// cross-products matched records with DD-computed times (lattice join) and diffs
-/// (product), and hands the backend the matched index lists for the value work.
-///
-/// Work units are queued by arrival direction (as in the cursor tactic) and currently
-/// drained eagerly; fuel budgeting is a later refinement.
-pub struct ProxyJoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, Bk> {
+pub struct ProxyJoinTactic<B0, B1, Bk> {
     backend: Bk,
-    todo0: VecDeque<JoinUnit<B0, B1>>,
-    todo1: VecDeque<JoinUnit<B0, B1>>,
-}
-
-/// A deferred bilinear join unit: a fresh batch list against the accumulated other side.
-struct JoinUnit<B0: BatchReader, B1: BatchReader<Time = B0::Time>> {
-    left: Vec<B0>,
-    right: Vec<B1>,
-    /// Which side carried the fresh batch; the other side is presented restricted to the
-    /// fresh side's keys.
-    fresh: Fresh,
-    capability: Capability<B0::Time>,
+    _marker: std::marker::PhantomData<(B0, B1)>,
 }
 
-impl<B0: BatchReader, B1: BatchReader<Time = B0::Time>, Bk> ProxyJoinTactic<B0, B1, Bk> {
-    /// A tactic deferring all value semantics to `backend`.
+impl<B0, B1, Bk> ProxyJoinTactic<B0, B1, Bk> {
+    /// A join tactic deferring all value semantics to `backend`.
     pub fn new(backend: Bk) -> Self {
-        ProxyJoinTactic { backend, todo0: VecDeque::new(), todo1: VecDeque::new() }
+        ProxyJoinTactic { backend, _marker: std::marker::PhantomData }
     }
 }
 
-impl<B0, B1, Bk, CB> JoinTactic<B0, B1, CB> for ProxyJoinTactic<B0, B1, Bk>
+impl<B0, B1, Bk> JoinTactic<B0, B1, Bk::Output> for ProxyJoinTactic<B0, B1, Bk>
 where
     B0: BatchReader,
     B1: BatchReader<Time = B0::Time>,
     Bk: ProxyJoinBackend<B0, B1>,
-    CB: ContainerBuilder<Container = Bk::Output>,
+    Bk::Output: 'static,
 {
-    fn defer(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, capability: Capability<B0::Time>) {
-        let queue = match fresh {
-            Fresh::Input0 => &mut self.todo0,
-            Fresh::Input1 => &mut self.todo1,
-        };
-        queue.push_back(JoinUnit { left: input0, right: input1, fresh, capability });
-    }
-
-    fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>) {
-        while let Some(unit) = self.todo0.pop_front() {
-            join_unit(&mut self.backend, unit, output);
-        }
-        while let Some(unit) = self.todo1.pop_front() {
-            join_unit(&mut self.backend, unit, output);
-        }
-        *fuel = 0;
+    fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: B0::Time) -> Box<dyn Iterator<Item = Bk::Output>> {
+        Box::new(join_prep(&mut self.backend, input0, input1, fresh, meet).into_iter())
     }
 }
 
-/// Join one deferred unit: present both sides, merge-match key runs over the sorted
-/// hashes, cross-product matched records, and hand the backend the index lists.
-fn join_unit<B0, B1, Bk, CB>(backend: &mut Bk, unit: JoinUnit<B0, B1>, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>)
+/// Update count threshold used to return to the backend with join output to instantiate.
+const JOIN_CHUNK: usize = 1 << 20;
+
+/// Prepare one join unit: present both sides, merge-match key runs over the sorted hashes, and
+/// cross-product matched records into a sequence of output containers — one per ~[`JOIN_CHUNK`]
+/// matches, flushed wherever the batch fills (including mid-key; parity: their concatenation is the
+/// single-container output). `meet` is a lower bound on the fresh side's times, so the accumulated
+/// side loads compacted (see [`JoinInstance`]); every output is produced under the capability at
+/// `meet`, so advancing loaded times by it leaves the output unchanged.
+fn join_prep<B0, B1, Bk>(backend: &mut Bk, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: B0::Time) -> Vec<Bk::Output>
 where
     B0: BatchReader,
     B1: BatchReader<Time = B0::Time>,
     Bk: ProxyJoinBackend<B0, B1>,
-    CB: ContainerBuilder<Container = Bk::Output>,
 {
-    // Present the fresh side first (delta-sized), then the accumulated side restricted
-    // to the fresh side's keys, so a unit's work tracks the fresh batch.
-    let (p0, p1) = match unit.fresh {
+    let lower = Antichain::from_elem(meet);
+    let instance = JoinInstance { batches0: &input0, batches1: &input1, lower: lower.borrow() };
+
+    // Prepare work using the keys of the just-received side.
+    // FIXME: Use the smaller of the two instead.
+    let (p0, p1) = match fresh {
         Fresh::Input0 => {
-            let p0 = backend.present0(&unit.left, None);
-            if p0.is_empty() { return; }
-            let mut keys = p0.key_hashes().to_vec();
+            let p0 = backend.present0(&instance, None);
+            if p0.is_empty() { return Vec::new(); }
+            let mut keys: Vec<u64> = p0.iter().map(|r| r.0.0).collect();
             keys.dedup();
-            let p1 = backend.present1(&unit.right, Some(&keys));
+            let p1 = backend.present1(&instance, Some(&keys));
             (p0, p1)
         }
         Fresh::Input1 => {
-            let p1 = backend.present1(&unit.right, None);
-            if p1.is_empty() { return; }
-            let mut keys = p1.key_hashes().to_vec();
+            let p1 = backend.present1(&instance, None);
+            if p1.is_empty() { return Vec::new(); }
+            let mut keys: Vec<u64> = p1.iter().map(|r| r.0.0).collect();
             keys.dedup();
-            let p0 = backend.present0(&unit.left, Some(&keys));
+            let p0 = backend.present0(&instance, Some(&keys));
             (p0, p1)
         }
     };
-    if p0.is_empty() || p1.is_empty() { return; }
-    let (k0, k1) = (p0.key_hashes(), p1.key_hashes());
+    if p0.is_empty() || p1.is_empty() { return Vec::new(); }
+    super::debug_assert_sorted_bridge(&p0, "present0");
+    super::debug_assert_sorted_bridge(&p1, "present1");
 
-    let (mut li, mut ri) = (Vec::new(), Vec::new());
-    let (mut ot, mut od) = (Vec::new(), Vec::new());
-    let (mut i, mut j) = (0usize, 0usize);
-    while i < k0.len() && j < k1.len() {
-        if k0[i] < k1[j] {
-            i += 1;
-        } else if k1[j] < k0[i] {
-            j += 1;
-        } else {
-            let key = k0[i];
-            let mut e0 = i;
-            while e0 < k0.len() && k0[e0] == key { e0 += 1; }
-            let mut e1 = j;
-            while e1 < k1.len() && k1[e1] == key { e1 += 1; }
-            join_key(&p0, i..e0, &p1, j..e1, &mut li, &mut ri, &mut ot, &mut od);
-            i = e0;
-            j = e1;
+    // Merge-join the two presented runs on `key_hash` (both sorted) and cross matched pairs. `flush`
+    // ships the accumulated batch as a container and resets the buffers; `join_key` calls it at each
+    // `JOIN_CHUNK` boundary — including *within* a high-fanout key's wave — so no single key
+    // materializes more than a chunk of its cross product. The closure scope releases its
+    // `backend`/`out` borrow before `out` is returned.
+    let mut out: Vec<Bk::Output> = Vec::new();
+    {
+        let mut flush = |li: &mut Vec<(u64, u64)>, ri: &mut Vec<(u64, u64)>, ot: &mut Vec<B0::Time>, od: &mut Vec<Bk::ROut>| {
+            out.push(backend.cross(&instance, li.as_slice(), ri.as_slice(), std::mem::take(ot), std::mem::take(od)));
+            li.clear();
+            ri.clear();
+        };
+
+        let (mut li, mut ri) = (Vec::new(), Vec::new());
+        let (mut ot, mut od) = (Vec::new(), Vec::new());
+        // Per-key replay histories, held across the unit and reloaded per key (only the >=16/>=16
+        // replay-wave path touches them), so a high-fanout join pays no per-key `IdHistory` alloc.
+        let mut h0 = IdHistory::new();
+        let mut h1 = IdHistory::new();
+        let (mut i, mut j) = (0usize, 0usize);
+        while i < p0.len() && j < p1.len() {
+            let (ki, kj) = (p0[i].0.0, p1[j].0.0);
+            if ki < kj {
+                i += 1;
+            } else if kj < ki {
+                j += 1;
+            } else {
+                let mut e0 = i;
+                while e0 < p0.len() && p0[e0].0.0 == ki { e0 += 1; }
+                let mut e1 = j;
+                while e1 < p1.len() && p1[e1].0.0 == ki { e1 += 1; }
+                join_key(ki, &p0, i..e0, &p1, j..e1, &mut h0, &mut h1, &mut li, &mut ri, &mut ot, &mut od, &mut flush);
+                i = e0;
+                j = e1;
+            }
+        }
+        if !li.is_empty() {
+            flush(&mut li, &mut ri, &mut ot, &mut od);
         }
     }
-    if li.is_empty() { return; }
-    let mut container = backend.cross(&li, &ri, ot, od);
-    output.session_with_builder(&unit.capability).give_container(&mut container);
+    out
 }
 
 /// Match one key's records across the two presented runs.
 ///
-/// For reasonably sized histories, the dead-simple cross product. For larger ones, the
-/// [`JoinThinker`]'s replay (ported to proxy space): both sides' edits are replayed in
-/// ascending time order, each edit joined against the *other* side's accumulated buffer,
-/// which is repeatedly advanced by the meet of the times still to come and consolidated —
-/// so a key whose two histories carry many distinct times costs the histories' sum times
-/// the buffer width, not their product. Emitted times are identical either way
-/// (`t0 ∨ (t1 ∨ meet) = t0 ∨ t1` since `meet ≤ t0`), and consolidation only pre-sums
-/// diffs whose product terms would have consolidated downstream.
-///
-/// Matched records reach the backend as representative indices per `value_id` (equal ids
-/// denote equal values, so any representative serves the projection).
-///
-/// [`JoinThinker`]: crate::operators::join (private; see the cursor tactic)
+/// If either history is small, this performs a simple cross product.
+/// If both histories are large, this replays the histories compacting as it goes in
+/// order to (potentially) avoid quadratic blow-up.
 #[allow(clippy::too_many_arguments)]
-fn join_key<T, R0, R1, RO>(
-    p0: &ProxyChunk<T, R0>,
+fn join_key<T, R0, R1, RO, F>(
+    kh: u64,
+    p0: &ProxyBridge<T, R0>,
     r0: std::ops::Range<usize>,
-    p1: &ProxyChunk<T, R1>,
+    p1: &ProxyBridge<T, R1>,
     r1: std::ops::Range<usize>,
-    li: &mut Vec<usize>,
-    ri: &mut Vec<usize>,
+    h0: &mut IdHistory<T, R0>,
+    h1: &mut IdHistory<T, R1>,
+    li: &mut Vec<(u64, u64)>,
+    ri: &mut Vec<(u64, u64)>,
     ot: &mut Vec<T>,
     od: &mut Vec<RO>,
+    flush: &mut F,
 ) where
     T: Lattice + Timestamp,
     R0: Semigroup + Multiply<R1, Output = RO> + Clone,
     R1: Semigroup + Clone,
+    F: FnMut(&mut Vec<(u64, u64)>, &mut Vec<(u64, u64)>, &mut Vec<T>, &mut Vec<RO>),
 {
+    // `flush` ships the accumulated batch once it reaches `JOIN_CHUNK` and resets the buffers. It's
+    // checked after every produced pair — *including inside the replay wave below* — so even a key
+    // whose fanout dwarfs `JOIN_CHUNK` never materializes more than a chunk of its cross product.
     if r0.len() < 16 || r1.len() < 16 {
         for a in r0 {
             for b in r1.clone() {
-                li.push(a);
-                ri.push(b);
-                ot.push(p0.times()[a].join(&p1.times()[b]));
-                od.push(p0.diffs()[a].clone().multiply(&p1.diffs()[b]));
+                li.push((kh, p0[a].0.1));
+                ri.push((kh, p1[b].0.1));
+                ot.push(p0[a].1.join(&p1[b].1));
+                od.push(p0[a].2.clone().multiply(&p1[b].2));
+                if li.len() >= JOIN_CHUNK { flush(li, ri, ot, od); }
             }
         }
         return;
     }
 
-    // value_id → representative record index, per side (each side's records are sorted
-    // by (value_id, time) within the key).
-    let rep = |p_vids: &[u64], range: std::ops::Range<usize>| {
-        let mut rep: Vec<(u64, usize)> = Vec::new();
-        for i in range {
-            if rep.last().is_none_or(|(v, _)| *v != p_vids[i]) {
-                rep.push((p_vids[i], i));
-            }
-        }
-        rep
-    };
-    let rep0 = rep(p0.value_ids(), r0.clone());
-    let rep1 = rep(p1.value_ids(), r1.clone());
-    let find = |rep: &[(u64, usize)], vid: u64| rep[rep.binary_search_by_key(&vid, |x| x.0).expect("vid presented")].1;
-
-    let mut h0: IdHistory<T, R0> = IdHistory::new();
-    h0.load(r0.map(|i| (p0.value_ids()[i], p0.times()[i].clone(), p0.diffs()[i].clone())), None);
-    let mut h1: IdHistory<T, R1> = IdHistory::new();
-    h1.load(r1.map(|i| (p1.value_ids()[i], p1.times()[i].clone(), p1.diffs()[i].clone())), None);
+    // Reusable replay scratch, reloaded per key (`load_iter` clears + rebuilds, keeping capacity);
+    // the caller holds `h0`/`h1` across the unit so a high-fanout join allocates no per-key history.
+    h0.load_iter(r0.map(|i| (p0[i].0.1, p0[i].1.clone(), p0[i].2.clone())), None);
+    h1.load_iter(r1.map(|i| (p1[i].0.1, p1[i].1.clone(), p1[i].2.clone())), None);
 
     while h0.time().is_some() && h1.time().is_some() {
         if h0.time().unwrap() < h1.time().unwrap() {
             h1.advance_buffer_by(h0.meet().unwrap());
             let (v0, t0, d0) = h0.edit().unwrap();
             for ((v1, t1), d1) in h1.buffer() {
-                li.push(find(&rep0, v0));
-                ri.push(find(&rep1, *v1));
+                li.push((kh, v0));
+                ri.push((kh, *v1));
                 ot.push(t0.join(t1));
                 od.push(d0.clone().multiply(d1));
+                if li.len() >= JOIN_CHUNK { flush(li, ri, ot, od); }
             }
             h0.step();
         } else {
             h0.advance_buffer_by(h1.meet().unwrap());
             let (v1, t1, d1) = h1.edit().unwrap();
             for ((v0, t0), d0) in h0.buffer() {
-                li.push(find(&rep0, *v0));
-                ri.push(find(&rep1, v1));
+                li.push((kh, *v0));
+                ri.push((kh, v1));
                 ot.push(t0.join(t1));
                 od.push(d0.clone().multiply(d1));
+                if li.len() >= JOIN_CHUNK { flush(li, ri, ot, od); }
             }
             h1.step();
         }
@@ -248,10 +235,11 @@ fn join_key<T, R0, R1, RO>(
         h1.advance_buffer_by(h0.meet().unwrap());
         let (v0, t0, d0) = h0.edit().unwrap();
         for ((v1, t1), d1) in h1.buffer() {
-            li.push(find(&rep0, v0));
-            ri.push(find(&rep1, *v1));
+            li.push((kh, v0));
+            ri.push((kh, *v1));
             ot.push(t0.join(t1));
             od.push(d0.clone().multiply(d1));
+            if li.len() >= JOIN_CHUNK { flush(li, ri, ot, od); }
         }
         h0.step();
     }
@@ -259,10 +247,11 @@ fn join_key<T, R0, R1, RO>(
         h0.advance_buffer_by(h1.meet().unwrap());
         let (v1, t1, d1) = h1.edit().unwrap();
         for ((v0, t0), d0) in h0.buffer() {
-            li.push(find(&rep0, *v0));
-            ri.push(find(&rep1, v1));
+            li.push((kh, *v0));
+            ri.push((kh, v1));
             ot.push(t0.join(t1));
             od.push(d0.clone().multiply(d1));
+            if li.len() >= JOIN_CHUNK { flush(li, ri, ot, od); }
         }
         h1.step();
     }
diff --git a/differential-dataflow/src/operators/int_proxy/mod.rs b/differential-dataflow/src/operators/int_proxy/mod.rs
index 75cca2988..9c72ffeab 100644
--- a/differential-dataflow/src/operators/int_proxy/mod.rs
+++ b/differential-dataflow/src/operators/int_proxy/mod.rs
@@ -1,113 +1,67 @@
-//! Backend-agnostic join and reduce over integer proxies.
+//! Backend-agnostic operator tactics using integer proxies.
 //!
-//! The tactics here run DD's operator logic over [`ProxyChunk`]s — sorted, consolidated
-//! runs of `((key_hash, value_id), time, diff)` — while a backend keeps the real keys and
-//! values in whatever (typically columnar) layout it likes. Only integers cross the
-//! boundary, in both directions:
+//! The tactics are intended to support custom operator implementations without rebuilding
+//! the non-trivial and often non-obvious time-based logic that supports them.
 //!
-//! * **Read side.** The backend *presents* a batch list as one proxy run
-//!   ([`ProxyJoinBackend::present0`], [`ProxyReduceBackend::present_input`], ...). DD
-//!   navigates the run — grouping by `key_hash`, consolidating diffs by `value_id`, and
-//!   running all lattice/time logic — and refers back to backend records only by *index
-//!   into the presented run*.
-//! * **Write side.** Reduce produces `((key_hash, value_id), time, diff)` deltas. The
-//!   `key_hash` is carried from the input key; output `value_id`s are *minted by hashing
-//!   the produced value* ([`ProxyReduceBackend::reduce`] — batched across every
-//!   `(key, time)` moment as [`reduce_many`](ProxyReduceBackend::reduce_many), so a
-//!   backend whose value logic is interpreted or columnar pays one crossing per
-//!   *retire*, not per key), and the backend's
-//!   [`materialize`](ProxyReduceBackend::materialize) seals the proxy records into a real
-//!   output batch — a real arrangement, fit to be a downstream operator's input, where
-//!   the same value presents with the same id because the id *is* its content hash.
+//! The tactics here run DD's operator logic over consolidated `[((u64, u64), time, diff)]`
+//! lists, the first integer a hash of the "key" and granule of independence, the second an
+//! ephemeral data identifier understood by the backend but opaque to the operator harness.
+//! The tactics first elicit proxy identifiers from the backends, perform their necessary time
+//! and difference based computations to stage integer collections, and then re-invoke the
+//! backends with those same identifiers to produce the necessary output.
 //!
-//! The tactics implement the seams in [`join`](crate::operators::join) and
-//! [`reduce`](crate::operators::reduce): [`ProxyJoinTactic`] is a [`JoinTactic`] for
-//! [`join_with_tactic`](crate::operators::join::join_with_tactic), [`ProxyReduceTactic`] a
-//! [`ReduceTactic`] for [`reduce_with_tactic`](crate::operators::reduce::reduce_with_tactic).
-//! Neither driver requires `Navigable` of its input, so a cursor-less backend arrangement
-//! (a [`Chunk`](crate::trace::chunk::Chunk) that skips the navigation capability) suffices.
-//! The [`reference`](mod@reference) module supplies an in-memory backend over the
-//! [`VecChunk`](crate::trace::chunk::vec::VecChunk) layout, so the framework is testable
-//! without any columnar engine.
-//!
-//! [`JoinTactic`]: crate::operators::join::JoinTactic
-//! [`ReduceTactic`]: crate::operators::reduce::ReduceTactic
+//! The backend is oblivious to the navigation of time, and the operator to the backend's
+//! implementation.
 //!
 //! # The two integers
 //!
-//! * `key_hash: u64` — a content hash of the key, stable across the whole system with no
-//!   registry: the same key hashes identically in every operator, including across the
-//!   output→input boundary. The hash function is a property of the *backend* (all of its
-//!   operators must share it); DD never hashes anything.
-//! * `value_id: u64` — an intra-key value identifier, consistent within one operator
-//!   computation: equal values ⇔ equal ids there (both directions — a value-id collision
-//!   merges two values' diffs, a correctness bug of the same character as a key
-//!   collision). No id outlives a computation: a join work unit's presentations, or one
-//!   reduce retire — within which the output presentation and minted ids must agree on
-//!   equal values (see [`ProxyReduceBackend`]); `materialize` resolves ids to real data
-//!   before anything leaves the retire. Content hashing (`id = hash(value)`) is the
-//!   stateless scheme that discharges all of this at once — the reference backend's
-//!   choice, and it makes min "reusing an input value's id" automatic — but *exact*
-//!   schemes are equally valid and collision-free: dense ordinals from grouping the
-//!   presented values, plus a per-retire value→id map on the output side. Only a future
-//!   design that persists ids into an output arrangement itself would force stable
-//!   (hashed) value ids.
-//!
-//! # Design note: `value_id` is *not* order-preserving
-//!
-//! We considered assigning `value_id`s in value order within each key, which would let
-//! the reduce tactic compute order-sensitive reductions (min/max) directly over the
-//! integers. We decided against it; min/max fall to the value callback. Why:
-//!
-//! 1. **It would reimport the cost the framework exists to avoid.** Order-preserving ids
-//!    require the backend to rank values by their *semantic* order per key per
-//!    presentation. Columnar backends deliberately order by their own structural
-//!    comparison (any consistent total order is fine for arrangement maintenance);
-//!    imposing the semantic `Ord` is exactly the row-wise value-comparison cost being
-//!    removed.
-//! 2. **The write side scrambles order anyway.** Minted ids must be stable content
-//!    hashes, and hashes are order-blind. An order-preserving read side would be a second
-//!    id regime living alongside the hashed one; a single hash-based scheme serves both.
-//! 3. **Division of labor stays clean.** The tactic's competence is time/lattice logic,
-//!    for which id *equality* suffices. Order is value semantics, and all value semantics
-//!    live behind the callback — which sees one key's few present values, the same work
-//!    a row backend does for min today, without the value materialization elsewhere.
+//! The two integers play the role of key and value to the operator, but their connection
+//! to the key and value of the intended computation is nuanced.
 //!
-//! The cost: min/max cannot be answered purely in proxy space. The callback does one pass
-//! over the key's present values — acceptable, and recoverable later backend-side with a
-//! columnar min primitive applied across many keys per wave.
+//! *   `key_hash: u64` — a content hash of the intended key.
+//!     This value should be identical for each instance of identical keys.
+//!     The value is not assumed to be a well-distributed quality hash, only distinct.
+//!     There may be collisions, and the next identifier should assist with this.
 //!
-//! # Collision risk
+//! *   `value_id: u64` — an ephemeral intra-hash value identifier.
+//!     These values should be distinct for each distinct datum with the same key_hash.
+//!     In particular, they should account for the conventional `(key, val)` data,
+//!     rather than only the value component, to avoid errors due to colliding keys.
 //!
-//! Key ids are 64-bit content hashes, and colliding *keys* merge two groups (a join
-//! would cross-match them; a reduce would reduce their union). By the birthday bound the
-//! probability of any collision among `n` distinct keys is ≈ `n²/2⁶⁵`: about `5·10⁻⁸` at
-//! a million, `5·10⁻²` at a billion. This is the accepted risk of the design — it buys
-//! key-id stability across the operator's lifetime with no registry and no coordination,
-//! which the cross-retire `pending` set and the changed-key restriction rely on. If a
-//! deployment's key cardinality makes the bound uncomfortable, the upgrade path is
-//! widening the id to 128 bits (a second id column), not a registry.
+//! The key hash acts as an independence marker: keys with different hashes will be isolated,
+//! and their incremental updates performed independently. By forcing the keyspace into `u64`,
+//! there is the risk of hash collision. This means that per-hash logic should be prepared for
+//! this, and should not discard key information that remains semantically important.
 //!
-//! Value ids carry the same exposure only if the backend hashes them (as the reference
-//! backend does). Because they are scoped to one computation, a backend can instead
-//! assign them exactly (see above) and eliminate value-side collisions outright; the key
-//! side is the irreducible exposure.
-//!
-//! # What DD owns vs what the backend owns
-//!
-//! DD (the tactics, written once): interesting-time discovery (joins of input times),
-//! wave navigation, per-`(key, time)` desired-vs-current deltas, `pending` keyed by the
-//! stable `key_hash` across retires, held-capability bucket routing, output batch
-//! descriptions, and all sorting/merging/consolidation of proxy runs. The backend:
-//! hashing, the value function, and building real columns from ids. The backend never
-//! sees a timestamp except as an opaque payload.
+//! Informally, one should mentally rewrite one's `(key, val)` into `(hash(key), (key, val))`.
+//! Retaining the `key` as data provides access to it, and allows one to certainly respond to
+//! hash collisions that can occur. Although the operator will treat `hash(key)` as the "key",
+//! the backend implementation can apply its own subseqent logic to resolve unwanted matches.
+//! As examples, join logic can follow its hash-wise cross product with key-based filtering,
+//! and reduce logic can group by keys and apply logic to slices within the per-hash list.
+//! Both are welcome to efficiently notice that there have been no collisions and optimize,
+//! or to ignore the risk entirely and live dangerously.
 
 mod history;
 
 pub mod join;
 pub mod reduce;
-pub mod reference;
 
-pub use crate::trace::chunk::int_proxy::ProxyChunk;
-pub use join::{ProxyJoinBackend, ProxyJoinTactic};
-pub use reduce::{ProxyReduceBackend, ProxyReduceTactic};
+/// Integer-only exchange medium: a consolidated collection of `[((hash, id), time, diff)]`.
+///
+/// The [`debug_assert_sorted_bridge`] method is (and can be) used to validate this property.
+pub type ProxyBridge<T, R> = Vec<((u64, u64), T, R)>;
+
+/// Debug check that a presented [`ProxyBridge`] is consolidated.
+///
+/// Operator harnesses use the test to flag backend implementations that do not uphold it.
+pub(crate) fn debug_assert_sorted_bridge<T: Ord, R>(bridge: &ProxyBridge<T, R>, who: &str) {
+    debug_assert!(
+        bridge.windows(2).all(|w| (w[0].0, &w[0].1) < (w[1].0, &w[1].1)),
+        "{}: a presented bridge must be sorted & consolidated by ((key_hash, value_id), time)",
+        who,
+    );
+}
+
+pub use join::{JoinInstance, ProxyJoinBackend, ProxyJoinTactic};
+pub use reduce::{ProxyReduceBackend, ProxyReduceTactic, ReduceInstance, ReduceWindow};
diff --git a/differential-dataflow/src/operators/int_proxy/reduce.rs b/differential-dataflow/src/operators/int_proxy/reduce.rs
index 8169718c6..7b29d9d82 100644
--- a/differential-dataflow/src/operators/int_proxy/reduce.rs
+++ b/differential-dataflow/src/operators/int_proxy/reduce.rs
@@ -1,135 +1,104 @@
-//! The proxy reduce: all interesting-time logic in proxy space, value work by callback.
+//! The proxy reduce framework.
+//!
+//! A conventional differential reduce against `(u64, u64)`, where the backend supplies the
+//! implementation of the interpretation of the integers.
 
-use std::collections::{BTreeMap, BTreeSet, HashMap};
-use std::hash::{BuildHasherDefault, Hasher};
+use std::collections::{BTreeMap, BTreeSet};
 
 use timely::PartialOrder;
 use timely::progress::{Antichain, Timestamp};
+use timely::progress::frontier::AntichainRef;
 
-use crate::difference::{Abelian, IsZero, Semigroup};
+use crate::difference::Semigroup;
 use crate::lattice::Lattice;
 use crate::trace::{BatchReader, Description};
-use crate::trace::chunk::int_proxy::ProxyChunk;
-use crate::operators::reduce::ReduceTactic;
+use super::ProxyBridge;
+use crate::operators::reduce::{ReduceTactic, sort_dedup};
 
 use super::history::{IdHistory, TimeHistory};
 
-/// Identity hasher for `value_id`-keyed scratch maps: `value_id`s are already 64-bit content hashes,
-/// so re-hashing them is waste. Reused across moments (cleared, not reallocated) to avoid a
-/// per-moment map alloc/free.
-#[derive(Default)]
-struct IdHasher(u64);
-impl Hasher for IdHasher {
-    #[inline] fn write_u64(&mut self, i: u64) { self.0 = i; }
-    #[inline] fn write(&mut self, _: &[u8]) { unreachable!("value_id keys are u64") }
-    #[inline] fn finish(&self) -> u64 { self.0 }
+/// A unit of proxied reduce work, presented to the backend.
+pub struct ReduceInstance<'a, B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
+    /// The accumulated input history.
+    pub source_batches: &'a [B1],
+    /// The freshly arrived input delta.
+    pub input_batches: &'a [B1],
+    /// The accumulated output history.
+    pub output_batches: &'a [B2],
+    /// The compaction frontier for loading (the retire's lower bound).
+    pub lower: AntichainRef<'a, B1::Time>,
 }
-type IdMap<R> = HashMap<u64, R, BuildHasherDefault<IdHasher>>;
 
-/// The reduce backend: value semantics for a proxy-space reduction.
+/// One window of a retire's changed keys: a bounded, hash-contiguous snip the backend sizes.
 ///
-/// Protocol (per `retire`, driven by [`ProxyReduceTactic`]): one `seed_times` (over the
-/// new input batches — the batch's `(key, time)` support and the changed keys), one
-/// `present_input`, one `present_output`, ONE batched `reduce_many` call carrying every
-/// `(key, interesting time)` moment of the retire — with indices referring to the input
-/// presentation — then one `materialize` per output batch. Within
-/// one retire the backend must be able to resolve every presented `key_hash` to its key
-/// and every presented or minted `value_id` to its value.
+/// The window has the input (old and new) and output histories, restricted to the window's keys.
+pub struct ReduceWindow<T, RIn, ROut> {
+    /// The window's key hashes: a contiguous, ascending slice of the retire's `changed` keys.
+    pub keys: Vec<u64>,
+    /// Input presentation for `keys`, sorted & consolidated by `((key_hash, value_id), time)`.
+    pub input: ProxyBridge<T, RIn>,
+    /// Output-history presentation for `keys`, same ordering.
+    pub output: ProxyBridge<T, ROut>,
+}
+
+/// The reduce backend: value semantics for a proxy-space reduction, driven by [`ProxyReduceTactic`].
+///
+/// The protocol is currently (temporarily) for each round of invocation:
+/// `seed_times begin [ next_window reduce_correction* emit ]* finish`
+/// This should be improved to put the `seed_times` in the per-window loop, or remove it entirely.
 pub trait ProxyReduceBackend<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
     /// Diff type presented for the input.
     type RIn: Semigroup;
-    /// Diff type of the output; the desired-vs-current delta needs negation.
-    type ROut: Abelian + 'static;
+    /// Diff type of the output.
+    type ROut: Semigroup + 'static;
 
-    /// (read) The freshly arrived batches' `(key_hash, time)` support: one entry per
-    /// novel record, sorted by `key_hash`. RAW — no merge with stored history, no
-    /// consolidation, no value work (no `value_id`, no diffs). Also how the tactic learns
-    /// the changed keys (their distinct `key_hash`es).
+    /// Hash keys and associated times in the instance's novel input batches.
     ///
-    /// Seeding interesting times from the batch's OWN times — never from a time-filter
-    /// over the merged accumulation — is load-bearing for CORRECTNESS: legal compaction
-    /// may advance a stored record onto a novel record's exact `(value, time)`,
-    /// cancelling it out of the merged view while the batch still owes output changes at
-    /// that time. The model pins this: seeds are `b.support ∪ pending` (`Model.lean`'s
-    /// `seedSet`; `scenario1_cancels` is the compaction-cancellation case).
+    /// This is used (with held times) to seed the interesting times for each key.
+    fn seed_times(&self, instance: &ReduceInstance<'_, B1, B2>) -> Vec<(u64, B1::Time)>;
+
+    /// Initiate a session to create batches for these descriptions, which span `[lower, upper)`.
     ///
-    /// Cheap by design: seeds need only key hashes and times. Interesting-time
-    /// over-derivation is sound (a non-changing seed yields a zero delta), so the raw
-    /// novel times — a superset of `b.support` — suffice, and the tactic reads only times
-    /// from them. So this method does NOT hash values, assign `value_id`s, sort by value,
-    /// or consolidate; a full value-present of the delta happens once, in `present_input`.
-    fn seed_times(&self, novel: &[B1]) -> Vec<(u64, B1::Time)>;
-    /// (read) Flatten the input history (`history` ∪ `novel`, the accumulated trace and
-    /// the freshly arrived batches) into one sorted, consolidated proxy run, restricted to
-    /// the sorted `keys` — the ACCUMULATION run (consolidation across history and novel
-    /// is fine here: compaction is accumulation-preserving; only seeding must not read
-    /// this view). The restriction is load-bearing: presenting only changed keys is
-    /// what keeps small-delta recursion from re-reading the accumulated trace each round.
-    fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, Self::RIn>;
-    /// (read) As `present_input`, for the operator's own output trace. The `value_id`s
-    /// here must agree, on equal output values, with the ids [`reduce`](Self::reduce)
-    /// mints later in this retire — desired and current output cancel by id. Content
-    /// hashing achieves this statelessly; an exact per-retire value→id map achieves it
-    /// with no collision risk.
-    fn present_output(&mut self, batches: &[B2], keys: &[u64]) -> ProxyChunk<B1::Time, Self::ROut>;
-    /// (value callback) Apply the reduction to one key's accumulated input: `input` holds
-    /// one entry per value with a nonzero accumulation — a representative record index
-    /// into the current input presentation, and the accumulated diff. Never called with
-    /// `input` empty. Returns the reduced output as `(value_id, diff)`, minting ids for
-    /// produced values — by any scheme that agrees with
-    /// [`present_output`](Self::present_output) on equal values within this retire — and
-    /// recording `id → value` for `materialize`.
-    fn reduce(&mut self, key_hash: u64, input: &[(usize, Self::RIn)]) -> Vec<(u64, Self::ROut)>;
-    /// (value callback, batched) As [`reduce`](Self::reduce), for a run of brackets in
-    /// one call: bracket `i` is the accumulated input `input[ends[i-1]..ends[i]]` (with
-    /// `ends[-1] = 0`, every bracket non-empty) for `keys[i]` — and a key may appear
-    /// several times, once per moment the tactic evaluates it at (the bracket is the
-    /// unit, not the key). Returns the concatenated per-bracket outputs together with
-    /// their own bracket ends, aligned with `keys`.
+    /// It is the backend's job to prepare output batches for each of these descriptions.
+    /// The computation proceeds in windows of keys, where only the backend maintains this
+    /// work in progress, until `finish()` is called.
+    fn begin(&mut self, tiles: &[Description<B1::Time>]);
+
+    /// Produce the next window, resticted to `changed[cursor..]`, and update `cursor` to track.
     ///
-    /// This is the boundary's bulk crossing: the tactic calls this method once per
-    /// retire, with every `(key, interesting time)` moment as a bracket — desired
-    /// outputs depend only on input accumulations, so no time ordering constrains the
-    /// batch — and a backend whose value logic crosses into interpreted or columnar
-    /// execution (where per-call overhead dominates) does the whole retire's value work
-    /// in one crossing. The default implementation loops [`reduce`](Self::reduce);
-    /// backends with cheap native per-key logic need not override it.
-    fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, Self::RIn)]) -> (Vec<(u64, Self::ROut)>, Vec<usize>) {
-        let mut outs = Vec::new();
-        let mut out_ends = Vec::with_capacity(keys.len());
-        let mut start = 0;
-        for (i, &key) in keys.iter().enumerate() {
-            outs.extend(self.reduce(key, &input[start..ends[i]]));
-            out_ends.push(outs.len());
-            start = ends[i];
-        }
-        (outs, out_ends)
-    }
-    /// (egress) Seal proxy-space output records into a real output batch: resolve each
-    /// record's `key_hash` and `value_id` to real data, order by the backend's own record
-    /// order, and build the batch with the given description. `records` may be empty (the
-    /// description still advances the output trace).
-    fn materialize(&mut self, records: ProxyChunk<B1::Time, Self::ROut>, description: Description<B1::Time>) -> B2;
+    /// The size of the window is up to the backend, where the window should be large enough to
+    /// amortize the crossings between the harness and the backend. The proxy bridges for the
+    /// whole window will be active at the same time, so tighter windows reduce the required state.
+    fn next_window(&mut self, instance: &ReduceInstance<'_, B1, B2>, changed: &[u64], cursor: &mut usize) -> Option<ReduceWindow<B1::Time, Self::RIn, Self::ROut>>;
+
+    /// A wave of input-output reconciliation, in which the backend supplies necessary edits.
+    ///
+    /// Multiple keys are provided concurrently, for each an accumulated input and tentative output.
+    /// The backend should provide for each key the necessary output updates to bring the output in
+    /// with its desires. The `usize` integers upper bound the range for the corresponding key.
+    fn reduce_corrections(
+        &mut self,
+        keys: &[u64],
+        in_ends: &[usize],
+        input: &[(u64, Self::RIn)],
+        out_ends: &[usize],
+        output: &[(u64, Self::ROut)],
+    ) -> (Vec<(u64, Self::ROut)>, Vec<usize>);
+
+    /// Commit to a collection of updates at a specific batch in progress.
+    ///
+    /// The `tile: usize` indexes the list of descriptions provided to `begin()`, and these updates
+    /// are aimed at that batch in progress.
+    fn emit(&mut self, tile: usize, records: &[((u64, u64), B1::Time, Self::ROut)]);
+
+    /// Complete the session matching `begin`. The outputs correspond to the descriptions it was provided.
+    fn finish(&mut self) -> Vec<B2>;
 }
 
-/// A proxy-space [`ReduceTactic`]: owns all interesting-time logic over
-/// `(key_hash, value_id, time, diff)`, calling the backend only for value semantics.
-///
-/// Per changed key (keys touched by new input, plus keys carrying pending times) it
-/// derives the active times in `[lower, upper)` — joins of input times, seeded by the
-/// novel times — consolidates each `(key, active time)` moment's input by `value_id`
-/// (presence), and hands ALL moments to the backend in one batched value callback per
-/// retire ([`ProxyReduceBackend::reduce_many`]): desired outputs depend only on input
-/// accumulations, so the batch needs no time ordering. Each moment's desired output is
-/// then diffed against its current output (committed history plus deltas emitted at
-/// earlier moments — the order-sensitive part, kept in proxy space) and the difference
-/// emitted into the held-time bucket. Times at or beyond `upper` are pended, keyed by
-/// the stable `key_hash`, so they survive retires without any reference to backend
-/// state.
+/// A proxy-space [`ReduceTactic`]: matches input and output records by `key_hash`.
 pub struct ProxyReduceTactic<T, Bk> {
     backend: Bk,
-    /// Outstanding interesting `(key, time)` moments at or beyond the last interval,
-    /// keyed by the stable key hash (a `BTreeMap` for deterministic iteration).
+    /// Pending interesting times beyond the upper frontier, keyed by key hash.
     pending: BTreeMap<u64, Vec<T>>,
 }
 
@@ -155,223 +124,238 @@ where
         upper: &Antichain<B1::Time>,
         held: &Antichain<B1::Time>,
     ) -> (Vec<(B1::Time, B2)>, Antichain<B1::Time>) {
-        // Only work if we hold a time we can actually ship in [.., upper).
         if held.elements().iter().all(|t| upper.less_equal(t)) {
             return (Vec::new(), held.clone());
         }
 
-        // Only keys touched by the new input delta or carrying pending times can change
-        // output in [lower, upper); everything else is untouched. This restriction keeps
-        // per-retire cost proportional to the delta, not the accumulation.
-        let seeds = self.backend.seed_times(&input_batches);
+        let instance = ReduceInstance {
+            source_batches: &source_batches,
+            input_batches: &input_batches,
+            output_batches: &output_batches,
+            lower: lower.borrow(),
+        };
+
+        let seeds = self.backend.seed_times(&instance);
         debug_assert!(seeds.windows(2).all(|w| w[0].0 <= w[1].0), "seed_times must be sorted by key_hash");
         let mut changed: BTreeSet<u64> = seeds.iter().map(|(k, _)| *k).collect();
         changed.extend(self.pending.keys().copied());
         if changed.is_empty() {
-            // No input delta and no carried pending: no key's output can change, and
-            // nothing remains to hold. Downgrade to the EMPTY frontier — returning `held`
-            // would keep the capability forever and deadlock a recursive scope.
             self.pending.clear();
             return (Vec::new(), Antichain::new());
         }
         let changed: Vec<u64> = changed.into_iter().collect();
 
-        // The two read-side presentations, restricted to the changed keys: the full input
-        // history (accumulated ∪ new) and the output history. Sorted by (key, val, time).
-        let p_in = self.backend.present_input(&source_batches, &input_batches, &changed);
-        let p_out = self.backend.present_output(&output_batches, &changed);
-
-        // One output-record bucket per held time; a delta at `t` routes to the largest
-        // held time `<= t`.
+        // The output tiling (identical to the Abelian tactic): one tile per held time, keeping
+        // non-degenerate intervals; `tile_of[i]` maps held time `i` to its tile.
         let held_elems: Vec<B1::Time> = held.elements().to_vec();
-        let mut buckets: Vec<Vec<((u64, u64), B1::Time, Bk::ROut)>> = vec![Vec::new(); held_elems.len()];
-
-        let mut new_pending: BTreeMap<u64, Vec<B1::Time>> = BTreeMap::new();
-
-        // Per changed key, phase A: the time-replay loop of the cursor tactic
-        // (`history_replay::compute`), ported to proxy space with the value callback
-        // deferred — it discovers the interesting times in `[lower, upper)`, assembles
-        // each one's consolidated input accumulation as a bracket, and pends times at or
-        // beyond `upper`. Both presentations hold only changed keys, in hash order, so
-        // the ranges advance monotonically. Keys are independent: their brackets share
-        // the retire's single batched callback, and phase B below replays each key's
-        // output side over its own (ascending) moments.
-        let mut keys_v: Vec<u64> = Vec::new();
-        let mut ends: Vec<usize> = Vec::new();
-        let mut entries: Vec<(usize, Bk::RIn)> = Vec::new();
-        struct KeyWork<T> {
-            key: u64,
-            o0: usize,
-            o1: usize,
-            /// The key's interesting in-interval moments, ascending, each with its
-            /// bracket index (`None`: empty accumulation — the callback is only
-            /// consulted for non-empty input, but current output may need retracting).
-            moments: Vec<(T, Option<usize>)>,
-        }
-        let mut work: Vec<KeyWork<B1::Time>> = Vec::new();
-        // Reused across keys (cleared each iteration) so per-key work doesn't reallocate.
-        let mut rep: Vec<(u64, usize)> = Vec::new();
-        let mut raw_moments: Vec<(B1::Time, (usize, usize))> = Vec::new();
-        let (mut is, mut os, mut ns) = (0usize, 0usize, 0usize);
-        for &key in &changed {
-            while is < p_in.len() && p_in.key_hashes()[is] < key { is += 1; }
-            let i0 = is;
-            while is < p_in.len() && p_in.key_hashes()[is] == key { is += 1; }
-            let i1 = is;
-            while os < p_out.len() && p_out.key_hashes()[os] < key { os += 1; }
-            let o0 = os;
-            while os < p_out.len() && p_out.key_hashes()[os] == key { os += 1; }
-            let o1 = os;
-            while ns < seeds.len() && seeds[ns].0 < key { ns += 1; }
-            let n0 = ns;
-            while ns < seeds.len() && seeds[ns].0 == key { ns += 1; }
-            let n1 = ns;
-
-            // value_id → representative record index (the first of the vid's run; the
-            // key's records are sorted by (value_id, time)).
-            rep.clear();
-            for i in i0..i1 {
-                if rep.last().is_none_or(|(v, _)| *v != p_in.value_ids()[i]) {
-                    rep.push((p_in.value_ids()[i], i));
+        let mut tile_descs: Vec<Description<B1::Time>> = Vec::new();
+        let mut tile_held: Vec<B1::Time> = Vec::new();
+        let mut tile_of: Vec<Option<usize>> = vec![None; held_elems.len()];
+        {
+            let mut out_lower = lower.clone();
+            for index in 0..held_elems.len() {
+                let mut out_upper = upper.clone();
+                for t in &held_elems[index + 1..] {
+                    out_upper.insert(t.clone());
+                }
+                if out_upper != out_lower {
+                    tile_of[index] = Some(tile_descs.len());
+                    tile_descs.push(Description::new(out_lower.clone(), out_upper.clone(), Antichain::from_elem(<B1::Time as Timestamp>::minimum())));
+                    tile_held.push(held_elems[index].clone());
+                    out_lower = out_upper;
                 }
             }
-            let pending = self.pending.get(&key).map(|p| &p[..]).unwrap_or(&[]);
-
-            raw_moments.clear();
-            let mut pended: Vec<B1::Time> = Vec::new();
-            let seed_times = seeds[n0..n1].iter().map(|(_, t)| t.clone());
-            discover_and_accumulate(
-                &p_in, i0, i1, seed_times, &rep, pending, upper,
-                &mut raw_moments, &mut entries, &mut pended,
-            );
-            if !pended.is_empty() {
-                new_pending.insert(key, pended);
-            }
-            if raw_moments.is_empty() {
-                continue;
-            }
-            let moments = raw_moments
-                .drain(..)
-                .map(|(t, (lo, hi))| {
-                    if lo < hi {
-                        keys_v.push(key);
-                        ends.push(hi);
-                        (t, Some(keys_v.len() - 1))
-                    } else {
-                        (t, None)
-                    }
-                })
-                .collect();
-            work.push(KeyWork { key, o0, o1, moments });
         }
+        self.backend.begin(&tile_descs);
 
-        // The one crossing for this retire.
-        let (outs, out_ends) = if keys_v.is_empty() {
-            (Vec::new(), Vec::new())
-        } else {
-            self.backend.reduce_many(&keys_v, &ends, &entries)
-        };
+        let mut new_pending: BTreeMap<u64, Vec<B1::Time>> = BTreeMap::new();
 
-        // Phase B, per key: replay the output side over the key's moments in ascending
-        // time order — `Ord` extends the partial order, so earlier deltas are always
-        // emitted before a later moment reads them — with the same meet-advancement
-        // keeping the output buffer and this pass's deltas consolidated.
-        // Reused across keys: `IdHistory::load` clears+refills (retaining capacity), and `meets`/
-        // `emitted` are cleared each key — so per-key replay doesn't reallocate.
-        let mut meets: Vec<B1::Time> = Vec::new();
-        let mut out_replay = IdHistory::new();
-        let mut emitted: Vec<((u64, B1::Time), Bk::ROut)> = Vec::new();
-        // Reused `value_id → diff` accumulator, cleared each moment (retains capacity — no per-moment
-        // map alloc/free).
-        let mut acc: IdMap<Bk::ROut> = IdMap::default();
-        for w in work {
-            meets.clear();
-            meets.extend(w.moments.iter().map(|(t, _)| t.clone()));
-            for i in (1..meets.len()).rev() {
-                let m = meets[i].clone();
-                meets[i - 1].meet_assign(&m);
-            }
-            out_replay.load(
-                (w.o0..w.o1).map(|o| (p_out.value_ids()[o], p_out.times()[o].clone(), p_out.diffs()[o].clone())),
-                meets.first(),
-            );
-            // Deltas emitted for this key earlier in this pass; part of "current output".
-            emitted.clear();
-            for (j, (t, bracket)) in w.moments.iter().enumerate() {
-                out_replay.step_through(t);
-                out_replay.advance_buffer_by(&meets[j]);
-                for ((_, et), _) in emitted.iter_mut() {
-                    *et = et.join(&meets[j]);
+        let mut cursor = 0usize;
+        let mut ns = 0usize;
+
+        // Retire-wide reusable scratch (cleared per window/round/moment, not reallocated). See the
+        // profiling note on `DiscoverScratch`: fresh per-key/per-round `Vec`s were the dominant cost.
+        let mut discover_scratch: DiscoverScratch<B1::Time, Bk::RIn> = DiscoverScratch::new();
+        let mut states: Vec<KeyState<B1::Time, Bk::RIn, Bk::ROut>> = Vec::new();
+        let mut tile_deltas: Vec<Vec<((u64, u64), B1::Time, Bk::ROut)>> = (0..held_elems.len()).map(|_| Vec::new()).collect();
+        let mut batch_keys: Vec<u64> = Vec::new();
+        let mut in_ends: Vec<usize> = Vec::new();
+        let mut in_all: Vec<(u64, Bk::RIn)> = Vec::new();
+        let mut out_ends: Vec<usize> = Vec::new();
+        let mut out_all: Vec<(u64, Bk::ROut)> = Vec::new();
+        let mut active: Vec<(usize, B1::Time)> = Vec::new();
+        let mut in_accum: Vec<(u64, Bk::RIn)> = Vec::new();
+        let mut cur_out: Vec<(u64, Bk::ROut)> = Vec::new();
+        let mut moments_scratch: Vec<B1::Time> = Vec::new();
+        let mut pended_scratch: Vec<B1::Time> = Vec::new();
+
+        while let Some(window) = self.backend.next_window(&instance, &changed, &mut cursor) {
+            let p_in = &window.input;
+            let p_out = &window.output;
+            super::debug_assert_sorted_bridge(p_in, "next_window.input");
+            super::debug_assert_sorted_bridge(p_out, "next_window.output");
+
+            for deltas in tile_deltas.iter_mut() { deltas.clear(); }
+
+            // Phase 1 (determination): for every key in the window, discover its interesting times
+            // (times only — no accumulation) and stand up its per-moment replays. Peak state is
+            // O(window presentation), bounded by the window `next_window` already materialized.
+            // `states` is a long-lived buffer reloaded slot-by-slot (not cleared/rebuilt): a slot's
+            // `Vec`s and replays are allocated once and reused, so keys cost no per-key alloc/free.
+            // `n_states` is the live prefix this window; higher slots persist (retaining capacity).
+            let mut n_states = 0usize;
+            let (mut is, mut os) = (0usize, 0usize);
+            for &key in &window.keys {
+                while is < p_in.len() && p_in[is].0.0 < key { is += 1; }
+                let i0 = is;
+                while is < p_in.len() && p_in[is].0.0 == key { is += 1; }
+                let i1 = is;
+                while os < p_out.len() && p_out[os].0.0 < key { os += 1; }
+                let o0 = os;
+                while os < p_out.len() && p_out[os].0.0 == key { os += 1; }
+                let o1 = os;
+                while ns < seeds.len() && seeds[ns].0 < key { ns += 1; }
+                let n0 = ns;
+                while ns < seeds.len() && seeds[ns].0 == key { ns += 1; }
+                let n1 = ns;
+
+                moments_scratch.clear();
+                pended_scratch.clear();
+                {
+                    let pending = self.pending.get(&key).map(|p| &p[..]).unwrap_or(&[]);
+                    let seed_times = seeds[n0..n1].iter().map(|(_, t)| t.clone());
+                    let out_times = (o0..o1).map(|o| p_out[o].1.clone());
+                    discover_times(
+                        KeyView { p_in, i0, i1, pending },
+                        seed_times, out_times, upper,
+                        &mut discover_scratch,
+                        &mut moments_scratch, &mut pended_scratch,
+                    );
                 }
-                crate::consolidation::consolidate(&mut emitted);
-
-                // Current output at `t`: committed history plus this pass's deltas.
-                acc.clear();
-                for ((vid, et), d) in out_replay.buffer().iter().chain(emitted.iter()) {
-                    if et.less_equal(t) {
-                        match acc.entry(*vid) {
-                            std::collections::hash_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(d),
-                            std::collections::hash_map::Entry::Vacant(e) => { e.insert(d.clone()); }
-                        }
-                    }
+                if !pended_scratch.is_empty() {
+                    new_pending.insert(key, std::mem::take(&mut pended_scratch));
+                }
+                if moments_scratch.is_empty() {
+                    continue;
                 }
-                acc.retain(|_, d| !d.is_zero());
 
-                // delta = desired − current, in proxy space (negate current, add desired).
-                for d in acc.values_mut() {
-                    d.negate();
+                // Reload slot `n_states` in place (grow the buffer by one only when a window is wider
+                // than any before). `drain` moves the discovered moments in without copy or realloc.
+                if n_states == states.len() {
+                    states.push(KeyState::empty());
+                }
+                let st = &mut states[n_states];
+                st.key = key;
+                st.cursor = 0;
+                st.produced.clear();
+                st.moments.clear();
+                st.moments.extend(moments_scratch.drain(..));
+                st.meets.clear();
+                st.meets.extend(st.moments.iter().cloned());
+                for i in (1..st.meets.len()).rev() {
+                    let m = st.meets[i].clone();
+                    st.meets[i - 1].meet_assign(&m);
                 }
-                if let Some(b) = *bracket {
-                    let lo = if b == 0 { 0 } else { out_ends[b - 1] };
-                    for (vid, d) in outs[lo..out_ends[b]].iter().cloned() {
-                        match acc.entry(vid) {
-                            std::collections::hash_map::Entry::Occupied(mut e) => e.get_mut().plus_equals(&d),
-                            std::collections::hash_map::Entry::Vacant(e) => { e.insert(d); }
+                st.in_replay.load_iter((i0..i1).map(|i| (p_in[i].0.1, p_in[i].1.clone(), p_in[i].2.clone())), st.meets.first());
+                st.out_replay.load_iter((o0..o1).map(|o| (p_out[o].0.1, p_out[o].1.clone(), p_out[o].2.clone())), st.meets.first());
+                n_states += 1;
+            }
+
+            // Phase 2 (application): walk all keys' moments in ROUNDS. Each round assembles every
+            // active key's one-moment-deep input and current-output accumulations and crosses them in
+            // a SINGLE `reduce_corrections` — batching across keys (a key's own moments stay
+            // sequential, each seeing its earlier corrections via `produced`). This caps the backend
+            // call count at O(max moments over keys), not O(sum of moments), with peak materialization
+            // one moment deep per key. `produced` is meet-collapsed each round, exactly like the
+            // reference — bounded, not the O(times × values) delta history.
+            loop {
+                batch_keys.clear();
+                in_ends.clear();
+                in_all.clear();
+                out_ends.clear();
+                out_all.clear();
+                active.clear();
+                let mut advanced = false;
+                for (si, st) in states[..n_states].iter_mut().enumerate() {
+                    if st.cursor >= st.moments.len() {
+                        continue;
+                    }
+                    advanced = true;
+                    let j = st.cursor;
+                    st.cursor += 1;
+                    let t = st.moments[j].clone();
+                    st.in_replay.step_through(&t);
+                    st.out_replay.step_through(&t);
+                    st.in_replay.advance_buffer_by(&st.meets[j]);
+                    st.out_replay.advance_buffer_by(&st.meets[j]);
+                    for ((_, et), _) in st.produced.iter_mut() {
+                        *et = et.join(&st.meets[j]);
+                    }
+                    crate::consolidation::consolidate(&mut st.produced);
+
+                    in_accum.clear();
+                    for ((vid, et), d) in st.in_replay.buffer().iter() {
+                        if et.less_equal(&t) {
+                            in_accum.push((*vid, d.clone()));
+                        }
+                    }
+                    crate::consolidation::consolidate(&mut in_accum);
+                    cur_out.clear();
+                    for ((vid, et), d) in st.out_replay.buffer().iter().chain(st.produced.iter()) {
+                        if et.less_equal(&t) {
+                            cur_out.push((*vid, d.clone()));
                         }
                     }
+                    crate::consolidation::consolidate(&mut cur_out);
+
+                    if in_accum.is_empty() && cur_out.is_empty() {
+                        continue;
+                    }
+                    batch_keys.push(st.key);
+                    in_all.extend(in_accum.drain(..));
+                    in_ends.push(in_all.len());
+                    out_all.extend(cur_out.drain(..));
+                    out_ends.push(out_all.len());
+                    active.push((si, t));
+                }
+                // Terminate only when every key is EXHAUSTED — not merely when this round produced no
+                // crossing. A round can be empty because every key's current moment is empty-gated
+                // while keys still have later (non-empty) moments; breaking here would drop them.
+                if !advanced {
+                    break;
                 }
-                acc.retain(|_, d| !d.is_zero());
-                if acc.is_empty() {
+                if batch_keys.is_empty() {
                     continue;
                 }
 
-                let idx = held_elems.iter().rposition(|h| h.less_equal(t)).expect("no held capability <= active time");
-                for (vid, d) in acc.drain() {
-                    emitted.push(((vid, t.clone()), d.clone()));
-                    buckets[idx].push(((w.key, vid), t.clone(), d));
+                let (corr, corr_ends) = self.backend.reduce_corrections(&batch_keys, &in_ends, &in_all, &out_ends, &out_all);
+                let mut cstart = 0usize;
+                for (bi, (si, t)) in active.iter().enumerate() {
+                    let cend = corr_ends[bi];
+                    if cstart != cend {
+                        let idx = held_elems.iter().rposition(|h| h.less_equal(t)).expect("no held capability <= active time");
+                        for (vid, d) in &corr[cstart..cend] {
+                            states[*si].produced.push(((*vid, t.clone()), d.clone()));
+                            tile_deltas[idx].push(((states[*si].key, *vid), t.clone(), d.clone()));
+                        }
+                    }
+                    cstart = cend;
                 }
             }
-        }
 
-        self.pending = new_pending;
-
-        // Build one output batch per held time, tiling [lower, upper): batch `i`'s upper
-        // is `upper` joined with the later held times, so the descriptions abut.
-        let mut produced = Vec::new();
-        let mut out_lower = lower.clone();
-        for (index, rows) in buckets.into_iter().enumerate() {
-            let mut out_upper = upper.clone();
-            for t in &held_elems[index + 1..] {
-                out_upper.insert(t.clone());
-            }
-            if out_upper != out_lower {
-                let description = Description::new(out_lower.clone(), out_upper.clone(), Antichain::from_elem(<B1::Time as Timestamp>::minimum()));
-                let (mut ks, mut vs) = (Vec::with_capacity(rows.len()), Vec::with_capacity(rows.len()));
-                let (mut ts, mut ds) = (Vec::with_capacity(rows.len()), Vec::with_capacity(rows.len()));
-                for ((k, v), t, d) in rows {
-                    ks.push(k);
-                    vs.push(v);
-                    ts.push(t);
-                    ds.push(d);
+            for (held_index, deltas) in tile_deltas.iter_mut().enumerate() {
+                if deltas.is_empty() {
+                    continue;
+                }
+                if let Some(tile) = tile_of[held_index] {
+                    crate::consolidation::consolidate_updates(deltas);
+                    self.backend.emit(tile, &deltas[..]);
                 }
-                let (records, _reps) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
-                let batch = self.backend.materialize(records, description);
-                produced.push((held_elems[index].clone(), batch));
-                out_lower = out_upper;
             }
         }
 
-        // New held frontier: the lower envelope of all carried pending times.
+        self.pending = new_pending;
+        let produced: Vec<(B1::Time, B2)> = tile_held.into_iter().zip(self.backend.finish()).collect();
         let mut frontier = Antichain::new();
         for times in self.pending.values() {
             for t in times {
@@ -382,52 +366,112 @@ where
     }
 }
 
-/// Phase A of one key's retire: the time-replay loop of the cursor tactic
-/// (`history_replay::compute`), ported to proxy space with the value callback deferred.
-///
-/// It replays the key's NOVEL batch times (`seed_times` — the batch's own `(key, time)`
-/// support, raw, apart from the stored history) together with the carried `pending`
-/// times, in ascending time order, discovering the interesting times: those carrying
-/// novel or pending updates, and joins thereof (synthesized as replay proceeds). The
-/// merged input presentation (`p_in[i0..i1]`, which already contains the novel records)
-/// is replayed alongside purely for ACCUMULATION: at each interesting time within the
-/// interval its buffer supplies the consolidated input, appended to `entries` as a
-/// bracket (recorded in `moments` with its entry range; an empty range marks a moment
-/// whose accumulation vanished but whose current output may need retracting). Times at
-/// or beyond `upper` are `pended`.
-///
-/// Seeding from the batch's own times — never from a time-filter over the merged
-/// presentation — is the formal model's `seedSet = b.support ∪ pending`: compaction can
-/// legally advance a stored record onto a novel one and cancel it out of the MERGED
-/// view, but it still owes changes at that time (`scenario1_cancels`). The seed times are
-/// raw (a superset of `b.support`); the spurious extras are sound over-derivation.
-///
-/// The replay buffers are repeatedly advanced by the meet of the times still to come and
-/// consolidated — the collapse that keeps a key with many distinct times linear rather
-/// than quadratic, exactly as in the cursor tactic.
-#[allow(clippy::too_many_arguments)]
-fn discover_and_accumulate<T, RIn>(
-    p_in: &ProxyChunk<T, RIn>,
+/// Per-key application state for [`ProxyReduceTactic`]'s round-batched walk: the key's ordered
+/// interesting `moments` and their suffix `meets`, its input and output replays (meet-collapsed),
+/// the corrections `produced` this round so far, and a `cursor` into `moments`. Held for all of a
+/// window's keys at once so each round's crossing batches across keys — a key's own moments stay
+/// sequential (each sees its earlier corrections via `produced`), but distinct keys are independent.
+struct KeyState<T, RIn, ROut> {
+    key: u64,
+    moments: Vec<T>,
+    meets: Vec<T>,
+    in_replay: IdHistory<T, RIn>,
+    out_replay: IdHistory<T, ROut>,
+    produced: Vec<((u64, T), ROut)>,
+    cursor: usize,
+}
+
+impl<T: Timestamp + Lattice, RIn: Semigroup, ROut: Semigroup> KeyState<T, RIn, ROut> {
+    /// An empty slot, to be filled by [`ProxyReduceTactic`]'s phase 1 (`reload`-style). The `states`
+    /// vector holds these across windows and reloads them in place, so a key's buffers are allocated
+    /// once (per slot) and reused — never dropped per key (which was ~18% of load in `free`).
+    fn empty() -> Self {
+        KeyState { key: 0, moments: Vec::new(), meets: Vec::new(), in_replay: IdHistory::new(), out_replay: IdHistory::new(), produced: Vec::new(), cursor: 0 }
+    }
+}
+
+/// Reusable per-key scratch for [`discover_times`], held once per retire and threaded through every
+/// key so the replays and time buffers are cleared-and-refilled (`load`/`load_iter` reset while
+/// keeping capacity) rather than reallocated. Mirrors the reference `HistoryReplayer`'s field-held
+/// scratch; without it each of ~n keys paid ~7 fresh allocations per call — profiled at ~54% of the
+/// hash-reduce load in `malloc`, against the cursor reduce's ~10% (see DESIGN.md F7).
+struct DiscoverScratch<T, RIn> {
+    batch_replay: TimeHistory<T>,
+    input_replay: IdHistory<T, RIn>,
+    output_replay: TimeHistory<T>,
+    synth: Vec<T>,
+    times_current: Vec<T>,
+    temporary: Vec<T>,
+    meets: Vec<T>,
+}
+
+impl<T: Timestamp + Lattice, RIn: Semigroup + Clone> DiscoverScratch<T, RIn> {
+    fn new() -> Self {
+        DiscoverScratch {
+            batch_replay: TimeHistory::new(),
+            input_replay: IdHistory::new(),
+            output_replay: TimeHistory::new(),
+            synth: Vec::new(),
+            times_current: Vec::new(),
+            temporary: Vec::new(),
+            meets: Vec::new(),
+        }
+    }
+}
+
+/// A one-key view into the input presentation: the read-only arguments [`discover_times`] needs
+/// about a single key — its slice `[i0, i1)` of the merged input run `p_in` and the carried
+/// `pending` times.
+struct KeyView<'a, T, RIn> {
+    p_in: &'a ProxyBridge<T, RIn>,
     i0: usize,
     i1: usize,
+    pending: &'a [T],
+}
+
+/// Updates an optional meet by an optional time.
+fn update_meet<T: Lattice + Clone>(meet: &mut Option<T>, other: Option<&T>) {
+    if let Some(time) = other {
+        match meet.as_mut() {
+            Some(m) => m.meet_assign(time),
+            None => *meet = Some(time.clone()),
+        }
+    }
+}
+
+/// Phase A: discover a key's interesting times in `[lower, upper)` (pending those at/after `upper`)
+/// **without** accumulating input brackets. It mirrors the reference's DETERMINATION step (times
+/// only, ref `reduce.rs` :671–713): it replays the key's novel (`seed_times`) and `pending` times
+/// in ascending order, marking those carrying novel/pending updates interesting and synthesizing the
+/// joins thereof — joins against the input/output histories and the reached times. Nothing
+/// materializes an input collection, so peak memory is O(times), never O(times × values); the
+/// application walk re-assembles each moment's accumulation on the fly, one moment deep — the whole
+/// point of the tactic (see DESIGN.md F8). Buffers are advanced by the meet of the times still to
+/// come and consolidated, keeping a key with many distinct times linear rather than quadratic.
+#[allow(clippy::too_many_arguments)]
+fn discover_times<T, RIn>(
+    key: KeyView<'_, T, RIn>,
     seed_times: impl Iterator<Item = T>,
-    rep: &[(u64, usize)],
-    pending: &[T],
+    out_times: impl Iterator<Item = T>,
     upper: &Antichain<T>,
-    moments: &mut Vec<(T, (usize, usize))>,
-    entries: &mut Vec<(usize, RIn)>,
+    scratch: &mut DiscoverScratch<T, RIn>,
+    moments: &mut Vec<T>,
     pended: &mut Vec<T>,
 ) where
     T: Timestamp + Lattice,
     RIn: Semigroup + Clone,
 {
-    // The batch's times seed interestingness and generate the synthetic joins; the batch
-    // carries no values here — accumulation comes wholly from the merged run below.
-    let mut batch_replay = TimeHistory::new();
+    // Reuse the retire's scratch: `load`/`load_iter` reset the replays (keeping capacity); the plain
+    // buffers are cleared here. `meets_slice` reborrows `meets` immutably; the rest stay disjoint.
+    let DiscoverScratch { batch_replay, input_replay, output_replay, synth, times_current, temporary, meets } = scratch;
+    synth.clear();
+    times_current.clear();
+    temporary.clear();
+
     batch_replay.load(seed_times, None);
 
-    // Suffix meets of the carried pending times (ascending, so meets accumulate from the end).
-    let mut meets: Vec<T> = pending.to_vec();
+    meets.clear();
+    meets.extend(key.pending.iter().cloned());
     for i in (1..meets.len()).rev() {
         let m = meets[i].clone();
         meets[i - 1].meet_assign(&m);
@@ -437,26 +481,25 @@ fn discover_and_accumulate<T, RIn>(
     update_meet(&mut meet, meets.first());
     update_meet(&mut meet, batch_replay.meet());
 
-    // The merged (history ⊎ novel, consolidated) run: the accumulation source.
-    let mut input_replay = IdHistory::new();
-    input_replay.load(
-        (i0..i1).map(|i| (p_in.value_ids()[i], p_in.times()[i].clone(), p_in.diffs()[i].clone())),
+    // The merged (history ⊎ novel) run — replayed for its TIMES only (join base), never
+    // accumulated. Output times likewise: base joins, never seeds.
+    input_replay.load_iter(
+        (key.i0..key.i1).map(|i| (key.p_in[i].0.1, key.p_in[i].1.clone(), key.p_in[i].2.clone())),
         meet.as_ref(),
     );
+    output_replay.load(out_times, meet.as_ref());
 
-    let mut synth: Vec<T> = Vec::new(); // sorted descending: pop ascending
-    let mut times_current: Vec<T> = Vec::new();
-    let mut temporary: Vec<T> = Vec::new();
-    let mut times_slice = pending;
+    let mut times_slice = key.pending;
     let mut meets_slice = &meets[..];
 
-    while let Some(next_time) = [batch_replay.time(), times_slice.first(), input_replay.time(), synth.last()]
+    while let Some(next_time) = [batch_replay.time(), times_slice.first(), input_replay.time(), output_replay.time(), synth.last()]
         .into_iter()
         .flatten()
         .min()
         .cloned()
     {
         input_replay.step_while_time_is(&next_time);
+        output_replay.step_while_time_is(&next_time);
         let mut interesting = batch_replay.step_while_time_is(&next_time);
         if interesting {
             if let Some(m) = meet.as_ref() {
@@ -478,33 +521,29 @@ fn discover_and_accumulate<T, RIn>(
 
         if !upper.less_equal(&next_time) {
             if interesting {
+                // Synthesize joins against the input/output histories (times only — no
+                // accumulation), then record `next_time` as an interesting moment.
                 if let Some(m) = meet.as_ref() {
                     input_replay.advance_buffer_by(m);
                 }
-                // Assemble the accumulation at `next_time` from the merged run's buffer
-                // (the batch's records are already in it — the batch buffer must not
-                // contribute diffs twice); buffered times beyond it contribute joins.
-                let mut acc: Vec<(u64, RIn)> = Vec::new();
-                for ((vid, t), d) in input_replay.buffer().iter() {
-                    if t.less_equal(&next_time) {
-                        acc.push((*vid, d.clone()));
-                    } else {
+                for ((_, t), _) in input_replay.buffer().iter() {
+                    if !t.less_equal(&next_time) {
                         temporary.push(next_time.join(t));
                     }
                 }
-                crate::consolidation::consolidate(&mut acc);
-                let lo = entries.len();
-                for (vid, d) in acc {
-                    let r = rep[rep.binary_search_by_key(&vid, |x| x.0).expect("vid presented")].1;
-                    entries.push((r, d));
+                if let Some(m) = meet.as_ref() {
+                    output_replay.advance_buffer_by(m);
+                }
+                for t in output_replay.buffer().iter() {
+                    if !t.less_equal(&next_time) {
+                        temporary.push(next_time.join(t));
+                    }
                 }
-                moments.push((next_time.clone(), (lo, entries.len())));
+                moments.push(next_time.clone());
             }
-            // Synthetic interesting times: joins with the remaining batch times and the
-            // times seen so far.
             temporary.extend(batch_replay.buffer().iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
             temporary.extend(times_current.iter().filter(|t| !t.less_equal(&next_time)).map(|t| t.join(&next_time)));
-            sort_dedup(&mut temporary);
+            sort_dedup(temporary);
             let synth_len = synth.len();
             for time in temporary.drain(..) {
                 if upper.less_equal(&time) {
@@ -521,11 +560,10 @@ fn discover_and_accumulate<T, RIn>(
             pended.push(next_time.clone());
         }
 
-        // Track the meet of every remaining source of times, and keep `times_current`
-        // advanced by it (the same collapse as the buffers).
         meet = None;
         update_meet(&mut meet, batch_replay.meet());
         update_meet(&mut meet, input_replay.meet());
+        update_meet(&mut meet, output_replay.meet());
         for t in synth.iter() {
             update_meet(&mut meet, Some(t));
         }
@@ -535,22 +573,7 @@ fn discover_and_accumulate<T, RIn>(
                 *t = t.join(m);
             }
         }
-        sort_dedup(&mut times_current);
+        sort_dedup(times_current);
     }
     sort_dedup(pended);
 }
-
-fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
-    list.sort();
-    list.dedup();
-}
-
-/// Updates an optional meet by an optional time.
-fn update_meet<T: Lattice + Clone>(meet: &mut Option<T>, other: Option<&T>) {
-    if let Some(time) = other {
-        match meet.as_mut() {
-            Some(m) => m.meet_assign(time),
-            None => *meet = Some(time.clone()),
-        }
-    }
-}
diff --git a/differential-dataflow/src/operators/int_proxy/reference.rs b/differential-dataflow/src/operators/int_proxy/reference.rs
deleted file mode 100644
index a49324b10..000000000
--- a/differential-dataflow/src/operators/int_proxy/reference.rs
+++ /dev/null
@@ -1,353 +0,0 @@
-//! The in-memory reference backend: real data in [`VecChunk`] arrangements, ids by
-//! hashing the real keys and values with the crate's [`Hashable`] (a deterministic,
-//! process-wide-stable content hash — the "system-wide hash function" every backend must
-//! fix for itself).
-//!
-//! The backend honors the tactics' delta-proportionality restrictions: a filtered
-//! present *seeks* the requested keys in the batch lists rather than scanning them, so
-//! per-retire (reduce) and per-unit (join) work tracks the delta, not the accumulated
-//! trace — the same access pattern as the cursor tactics. The `work_is_delta_proportional`
-//! tests pin this.
-//!
-//! [`VecChunk`]: crate::trace::chunk::vec::VecChunk
-//! [`Hashable`]: crate::hashable::Hashable
-
-use std::collections::HashMap;
-use std::hash::Hash;
-use std::marker::PhantomData;
-use std::rc::Rc;
-
-use timely::progress::Timestamp;
-
-use crate::difference::{Abelian, Multiply, Semigroup};
-use crate::hashable::Hashable;
-use crate::lattice::Lattice;
-use crate::trace::{Builder, Description, Navigable};
-use crate::trace::cursor::Cursor;
-use crate::trace::chunk::{ChunkBatch, ChunkBuilder};
-use crate::trace::chunk::int_proxy::ProxyChunk;
-use crate::trace::chunk::vec::VecChunk;
-
-use super::join::ProxyJoinBackend;
-use super::reduce::ProxyReduceBackend;
-
-/// The backend's stable content hash: same input → same `u64`, everywhere in the
-/// process, with no registry.
-pub fn stable_hash<D: Hash>(data: &D) -> u64 {
-    data.hashed()
-}
-
-/// A batch of the reference backend's arrangements.
-pub type RefBatch<K, V, T, R> = Rc<ChunkBatch<VecChunk<K, V, T, R>>>;
-
-/// Parallel proxy and real columns under construction, one entry per record.
-struct Rows<K, V, T, R> {
-    keys: Vec<u64>,
-    vals: Vec<u64>,
-    times: Vec<T>,
-    diffs: Vec<R>,
-    reals: Vec<(K, V)>,
-}
-
-impl<K, V, T, R> Rows<K, V, T, R> {
-    fn new() -> Self {
-        Rows { keys: Vec::new(), vals: Vec::new(), times: Vec::new(), diffs: Vec::new(), reals: Vec::new() }
-    }
-}
-
-impl<K, V, T, R> Rows<K, V, T, R>
-where
-    K: Ord + Clone + Hash + 'static,
-    V: Ord + Clone + Hash + 'static,
-    T: Lattice + Timestamp,
-    R: Ord + Semigroup + 'static,
-{
-    /// Append one key's `(val, time, diff)` records read at the cursor's current key.
-    fn read_key(&mut self, cursor: &mut <RefBatch<K, V, T, R> as Navigable>::Cursor, batch: &RefBatch<K, V, T, R>, key: &K, kh: u64) {
-        while let Some(val) = cursor.get_val(batch) {
-            let vh = stable_hash(val);
-            cursor.map_times(batch, |t, d| {
-                self.keys.push(kh);
-                self.vals.push(vh);
-                self.times.push(t.clone());
-                self.diffs.push(d.clone());
-                self.reals.push((key.clone(), val.clone()));
-            });
-            cursor.step_val(batch);
-        }
-    }
-
-    /// Read every record of `batches` (the unfiltered, delta-sized read).
-    fn scan(&mut self, batches: &[RefBatch<K, V, T, R>]) {
-        for batch in batches {
-            let mut cursor = batch.cursor();
-            while let Some(key) = cursor.get_key(batch) {
-                let key = key.clone();
-                self.read_key(&mut cursor, batch, &key, stable_hash(&key));
-                cursor.step_key(batch);
-            }
-        }
-    }
-
-    /// Read exactly the records of `keys` (sorted) from `batches`, by seeking — the
-    /// filtered read costs `O(|keys| · log)` per batch plus the matched records, never
-    /// the batch size.
-    fn seek(&mut self, batches: &[RefBatch<K, V, T, R>], keys: &[K]) {
-        debug_assert!(keys.windows(2).all(|w| w[0] < w[1]));
-        for batch in batches {
-            let mut cursor = batch.cursor();
-            for key in keys {
-                cursor.seek_key(batch, key);
-                if cursor.get_key(batch) == Some(key) {
-                    self.read_key(&mut cursor, batch, key, stable_hash(key));
-                }
-            }
-        }
-    }
-
-    /// Sort, consolidate, and align: the proxy run plus the real record per run entry.
-    fn present(self) -> (ProxyChunk<T, R>, Vec<(K, V)>) {
-        let (chunk, reps) = ProxyChunk::from_unsorted(self.keys, self.vals, self.times, self.diffs);
-        let aligned = reps.iter().map(|&i| self.reals[i].clone()).collect();
-        (chunk, aligned)
-    }
-}
-
-/// The distinct keys among `reals` whose hash appears in the sorted `filter`, sorted by
-/// the *key* order (ready for seeking).
-fn keys_matching<K: Ord + Clone + Hash, V>(reals: &[(K, V)], filter: &[u64]) -> Vec<K> {
-    let mut keys: Vec<K> = reals
-        .iter()
-        .filter(|(k, _)| filter.binary_search(&stable_hash(k)).is_ok())
-        .map(|(k, _)| k.clone())
-        .collect();
-    keys.sort();
-    keys.dedup();
-    keys
-}
-
-/// The join backend: presents [`VecChunk`] batches by hashing, applies a
-/// `(key, val0, val1) → data` projection to matched index pairs, and emits
-/// `Vec<(data, time, diff)>` containers.
-///
-/// A filtered present resolves the filter's hashes to real keys through the *other*
-/// side's presentation (the fresh side, presented first, unfiltered) and seeks them.
-pub struct VecJoinBackend<K, V0, V1, D, L> {
-    logic: L,
-    /// Real records aligned with the current first-input presentation.
-    left: Vec<(K, V0)>,
-    /// Real records aligned with the current second-input presentation.
-    right: Vec<(K, V1)>,
-    marker: PhantomData<fn() -> D>,
-}
-
-impl<K, V0, V1, D, L> VecJoinBackend<K, V0, V1, D, L> {
-    /// A backend applying `logic` to each matched `(key, val0, val1)`.
-    pub fn new(logic: L) -> Self {
-        VecJoinBackend { logic, left: Vec::new(), right: Vec::new(), marker: PhantomData }
-    }
-}
-
-impl<K, V0, V1, T, R0, R1, RO, D, L> ProxyJoinBackend<RefBatch<K, V0, T, R0>, RefBatch<K, V1, T, R1>> for VecJoinBackend<K, V0, V1, D, L>
-where
-    K: Ord + Clone + Hash + 'static,
-    V0: Ord + Clone + Hash + 'static,
-    V1: Ord + Clone + Hash + 'static,
-    T: Lattice + Timestamp,
-    R0: Ord + Semigroup + Multiply<R1, Output = RO> + 'static,
-    R1: Ord + Semigroup + 'static,
-    RO: Semigroup + 'static,
-    D: 'static,
-    L: FnMut(&K, &V0, &V1) -> D,
-{
-    type R0 = R0;
-    type R1 = R1;
-    type ROut = RO;
-    type Output = Vec<(D, T, RO)>;
-
-    fn present0(&mut self, batches: &[RefBatch<K, V0, T, R0>], filter: Option<&[u64]>) -> ProxyChunk<T, R0> {
-        let mut rows = Rows::new();
-        match filter {
-            None => rows.scan(batches),
-            Some(f) => rows.seek(batches, &keys_matching(&self.right, f)),
-        }
-        let (chunk, reals) = rows.present();
-        self.left = reals;
-        chunk
-    }
-
-    fn present1(&mut self, batches: &[RefBatch<K, V1, T, R1>], filter: Option<&[u64]>) -> ProxyChunk<T, R1> {
-        let mut rows = Rows::new();
-        match filter {
-            None => rows.scan(batches),
-            Some(f) => rows.seek(batches, &keys_matching(&self.left, f)),
-        }
-        let (chunk, reals) = rows.present();
-        self.right = reals;
-        chunk
-    }
-
-    fn cross(&mut self, left: &[usize], right: &[usize], times: Vec<T>, diffs: Vec<RO>) -> Vec<(D, T, RO)> {
-        let mut out = Vec::with_capacity(left.len());
-        for (((&l, &r), t), d) in left.iter().zip(right).zip(times).zip(diffs) {
-            let (k, v0) = &self.left[l];
-            let (_, v1) = &self.right[r];
-            out.push(((self.logic)(k, v0, v1), t, d));
-        }
-        out
-    }
-}
-
-/// The reduce backend: presents [`VecChunk`] batches by hashing, applies the
-/// user's reduction logic (row-reduce-shaped: `(key, &[(val, diff)], &mut output)`)
-/// per key, mints output ids by hashing produced values, and materializes proxy records
-/// back into [`VecChunk`] output batches.
-///
-/// The changed-key restriction is honored by *seeking*: the accumulated input and output
-/// histories are read only at the changed keys. Every changed hash is resolvable to its
-/// key — this retire's touched keys from the (delta-sized) novel batches, pending keys
-/// from the retire that pended them (the `keys` map persists exactly those entries).
-pub struct VecReduceBackend<K, V, V2, L> {
-    logic: L,
-    /// `key_hash → key` for the changed keys: primed from each retire's novel batches,
-    /// pruned to the changed set on entry (so pending keys survive between retires and
-    /// nothing else accumulates).
-    keys: HashMap<u64, K>,
-    /// Real values aligned with the current input presentation.
-    in_vals: Vec<V>,
-    /// `value_id → output value` for the current retire, primed by the output
-    /// presentation and by minting; cleared each retire.
-    out_vals: HashMap<u64, V2>,
-}
-
-impl<K, V, V2, L> VecReduceBackend<K, V, V2, L> {
-    /// A backend applying `logic` — shaped like the row reduce's closure — per key.
-    pub fn new(logic: L) -> Self {
-        VecReduceBackend { logic, keys: HashMap::new(), in_vals: Vec::new(), out_vals: HashMap::new() }
-    }
-
-    /// The changed keys, in key order, ready for seeking.
-    fn seek_keys(&self) -> Vec<K>
-    where
-        K: Ord + Clone,
-    {
-        let mut keys: Vec<K> = self.keys.values().cloned().collect();
-        keys.sort();
-        keys
-    }
-}
-
-impl<K, V, V2, T, RIn, ROut, L> ProxyReduceBackend<RefBatch<K, V, T, RIn>, RefBatch<K, V2, T, ROut>> for VecReduceBackend<K, V, V2, L>
-where
-    K: Ord + Clone + Hash + 'static,
-    V: Ord + Clone + Hash + 'static,
-    V2: Ord + Clone + Hash + 'static,
-    T: Lattice + Timestamp,
-    RIn: Ord + Semigroup + 'static,
-    ROut: Ord + Abelian + 'static,
-    L: FnMut(&K, &[(&V, RIn)], &mut Vec<(V2, ROut)>),
-{
-    type RIn = RIn;
-    type ROut = ROut;
-
-    fn seed_times(&self, novel: &[RefBatch<K, V, T, RIn>]) -> Vec<(u64, T)> {
-        // The batch's raw (key_hash, time) support: hash keys only (no value work), one
-        // entry per record, sorted by key_hash. Never merged with stored history, so no
-        // compacted record can cancel a seed.
-        let mut out = Vec::new();
-        for batch in novel {
-            let mut cursor = batch.cursor();
-            while let Some(k) = cursor.get_key(batch) {
-                let kh = stable_hash(k);
-                while cursor.get_val(batch).is_some() {
-                    cursor.map_times(batch, |t, _| out.push((kh, t.clone())));
-                    cursor.step_val(batch);
-                }
-                cursor.step_key(batch);
-            }
-        }
-        out.sort_by_key(|(k, _)| *k);
-        out
-    }
-
-    fn present_input(&mut self, history: &[RefBatch<K, V, T, RIn>], novel: &[RefBatch<K, V, T, RIn>], keys: &[u64]) -> ProxyChunk<T, RIn> {
-        // Prune the hash→key map to the changed set: what survives from earlier retires
-        // is exactly the pending keys, so the map is bounded by the delta. Shrink too —
-        // `retain` keeps the backing table, and a table sized by a past big retire would
-        // make every later `values()` walk pay for its capacity, not its contents.
-        self.keys.retain(|h, _| keys.binary_search(h).is_ok());
-        self.keys.shrink_to_fit();
-        // The novel batches are delta-sized and their keys are all changed: read them
-        // fully, and prime the map from what was read.
-        let mut rows = Rows::new();
-        rows.scan(novel);
-        for (k, _) in &rows.reals {
-            self.keys.entry(stable_hash(k)).or_insert_with(|| k.clone());
-        }
-        // The accumulated history is not scanned: seek exactly the changed keys.
-        rows.seek(history, &self.seek_keys());
-        let (chunk, reals) = rows.present();
-        self.in_vals = reals.into_iter().map(|(_, v)| v).collect();
-        chunk
-    }
-
-    fn present_output(&mut self, batches: &[RefBatch<K, V2, T, ROut>], _keys: &[u64]) -> ProxyChunk<T, ROut> {
-        // The id → value map is per-retire state; start it afresh. A fresh map, not
-        // `clear()`: clearing keeps the backing table, whose capacity a past big retire
-        // set, and later walks would pay for it.
-        self.out_vals = HashMap::new();
-        // Seek the changed keys (the same set `present_input` resolved).
-        let mut rows = Rows::new();
-        rows.seek(batches, &self.seek_keys());
-        let (chunk, reals) = rows.present();
-        for (i, (_, v)) in reals.into_iter().enumerate() {
-            self.out_vals.entry(chunk.value_ids()[i]).or_insert(v);
-        }
-        chunk
-    }
-
-    fn reduce(&mut self, key_hash: u64, input: &[(usize, RIn)]) -> Vec<(u64, ROut)> {
-        let key = self.keys.get(&key_hash).expect("key presented this retire");
-        // The value semantics are the backend's: the reduction contract presents
-        // values in their `Ord` order, so sort the (hash-ordered) accumulation.
-        let mut pairs: Vec<(&V, RIn)> = input.iter().map(|&(i, ref d)| (&self.in_vals[i], d.clone())).collect();
-        pairs.sort_by(|a, b| a.0.cmp(b.0));
-        let mut produced = Vec::new();
-        (self.logic)(key, &pairs, &mut produced);
-        produced
-            .into_iter()
-            .map(|(v, d)| {
-                let id = stable_hash(&v);
-                self.out_vals.entry(id).or_insert(v);
-                (id, d)
-            })
-            .collect()
-    }
-
-    fn materialize(&mut self, records: ProxyChunk<T, ROut>, description: Description<T>) -> RefBatch<K, V2, T, ROut> {
-        // Resolve ids to real data and re-order by the *real* record order — the proxy
-        // ordering (by hash) is not the arrangement's ordering.
-        let mut rows: Vec<((K, V2), T, ROut)> = (0..records.len())
-            .map(|i| {
-                let k = self.keys.get(&records.key_hashes()[i]).expect("key presented this retire").clone();
-                let v = self.out_vals.get(&records.value_ids()[i]).expect("value presented or minted this retire").clone();
-                ((k, v), records.times()[i].clone(), records.diffs()[i].clone())
-            })
-            .collect();
-        crate::consolidation::consolidate_updates(&mut rows);
-        // Feed the builder TARGET-sized chunks: handing it one giant chunk would make its
-        // settle peel TARGET-sized pieces off the front, copying the remaining tail each
-        // time — quadratic in the batch size.
-        let mut builder = ChunkBuilder::<VecChunk<K, V2, T, ROut>>::with_capacity(0, 0, 0);
-        let mut rows = rows.into_iter().peekable();
-        while rows.peek().is_some() {
-            let mut chunk = VecChunk::default();
-            for row in rows.by_ref().take(<VecChunk<K, V2, T, ROut> as crate::trace::chunk::Chunk>::TARGET) {
-                use timely::container::PushInto;
-                chunk.push_into(row);
-            }
-            builder.push(&mut chunk);
-        }
-        builder.done(description)
-    }
-}
diff --git a/differential-dataflow/src/operators/join.rs b/differential-dataflow/src/operators/join.rs
index 9bd9d9341..58b42e6f3 100644
--- a/differential-dataflow/src/operators/join.rs
+++ b/differential-dataflow/src/operators/join.rs
@@ -4,65 +4,34 @@
 //! the multiplication distributes over addition. That is, we will repeatedly evaluate (a + b) * c as (a * c)
 //! + (b * c), and if this is not equal to the former term, little is known about the actual output.
 use std::cmp::Ordering;
+use std::collections::VecDeque;
 
-use timely::{Accountable, ContainerBuilder};
-use timely::container::PushInto;
+use timely::{Container, ContainerBuilder};
+use timely::container::NoopBuilder;
 use timely::order::PartialOrder;
 use timely::progress::Timestamp;
 use timely::dataflow::Stream;
-use timely::dataflow::operators::generic::{Operator, OutputBuilderSession, Session};
+use timely::dataflow::operators::generic::{Operator, OutputBuilderSession};
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::Capability;
 
 use crate::lattice::Lattice;
 use crate::operators::arrange::Arranged;
 use crate::trace::{BatchCursor, BatchDiff, BatchKey, BatchReader, BatchVal, Cursor, Navigable, TraceReader};
-use crate::trace::cursor::{cursor_list, CursorList};
+use crate::trace::cursor::cursor_list;
 use crate::operators::ValueHistory;
 
-/// The session passed to join closures.
-pub type JoinSession<'a, 'b, T, CB, CT> = Session<'a, 'b, T, EffortBuilder<CB>, CT>;
-
-/// A container builder that tracks the length of outputs to estimate the effort of join closures.
-#[derive(Default, Debug)]
-pub struct EffortBuilder<CB>(pub std::cell::Cell<usize>, pub CB);
-
-impl<CB: ContainerBuilder> timely::container::ContainerBuilder for EffortBuilder<CB> {
-    type Container = CB::Container;
-
-    #[inline]
-    fn extract(&mut self) -> Option<&mut Self::Container> {
-        let extracted = self.1.extract();
-        self.0.replace(self.0.take() + extracted.as_ref().map_or(0, |e| e.record_count() as usize));
-        extracted
-    }
-
-    #[inline]
-    fn finish(&mut self) -> Option<&mut Self::Container> {
-        let finished = self.1.finish();
-        self.0.replace(self.0.take() + finished.as_ref().map_or(0, |e| e.record_count() as usize));
-        finished
-    }
-}
-
-impl<CB: PushInto<D>, D> PushInto<D> for EffortBuilder<CB> {
-    #[inline]
-    fn push_into(&mut self, item: D) {
-        self.1.push_into(item);
-    }
-}
-
 /// A type that can manage the joining of lists of batches.
-pub trait JoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, CB: ContainerBuilder> {
-    /// Prepare for work the join of two lists of corresponding batches, against a sufficient capability.
-    ///
-    /// `fresh` names which input contributed the freshly-arrived batch; its times all lie at or beyond
-    /// the capability, so a tactic need not advance that side by the capability's meet.
-    fn defer(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, capability: Capability<B0::Time>);
-    /// Perform an amount of work that just barely exceeds `fuel`, which is decremented.
+///
+/// The trait is parameterized by the output container `C`, not by the builder that assembles it: a tactic
+/// yields finished containers, and how it produces them (pushing records into a [`ContainerBuilder`], or
+/// otherwise) is its own concern.
+pub trait JoinTactic<B0: BatchReader, B1: BatchReader<Time = B0::Time>, C> {
+    /// Prepare the join of two lists of batches into an iterator of output containers.
     ///
-    /// Returning with a non-negative fuel indicates that all work was exhausted.
-    fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>);
+    /// The supplied `fresh` and `meet` indicate respectively which input is "novel", and should drive the
+    /// join, as well as a lower bound on that input's times, so that the other input can be loaded compacted.
+    fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: B0::Time) -> Box<dyn Iterator<Item = C>>;
 }
 
 /// Which input contributed the freshly-arrived batch of a deferred join unit.
@@ -96,10 +65,10 @@ where
     Tr2: TraceReader<Batch: Navigable, Time = Tr1::Time>+'static,
     BatchCursor<Tr1>: Cursor<Time = Tr1::Time>,
     for<'a> BatchCursor<Tr2>: Cursor<Key<'a>=BatchKey<'a, Tr1>, Time = Tr1::Time>,
-    L: FnMut(BatchKey<'_, Tr1>,BatchVal<'_, Tr1>,BatchVal<'_, Tr2>,Tr1::Time,&BatchDiff<Tr1>,&BatchDiff<Tr2>,&mut JoinSession<Tr1::Time, CB, Capability<Tr1::Time>>)+'static,
-    CB: ContainerBuilder,
+    L: FnMut(BatchKey<'_, Tr1>,BatchVal<'_, Tr1>,BatchVal<'_, Tr2>,Tr1::Time,&BatchDiff<Tr1>,&BatchDiff<Tr2>,&mut CB)+'static,
+    CB: ContainerBuilder<Container: Default> + 'static,
 {
-    join_with_tactic(arranged1, arranged2, cursors::CursorTactic::<Tr1::Batch, Tr2::Batch, _>::new(result))
+    join_with_tactic(arranged1, arranged2, cursors::CursorTactic::<Tr1::Batch, Tr2::Batch, _, CB>::new(result))
 }
 
 /// Drives an equijoin of two traces using a supplied [`JoinTactic`].
@@ -108,12 +77,12 @@ where
 /// compaction) and routes the per-batch work through the tactic. It requires only `TraceReader` of its
 /// inputs, never `Navigable`: it extracts trace batches via `batches_through`, and building cursors over
 /// them (if that is how the join proceeds) is the tactic's concern.
-pub fn join_with_tactic<'scope, Tr1, Tr2, T, CB>(arranged1: Arranged<'scope, Tr1>, arranged2: Arranged<'scope, Tr2>, mut tactic: T) -> Stream<'scope, Tr1::Time, CB::Container>
+pub fn join_with_tactic<'scope, Tr1, Tr2, T, C>(arranged1: Arranged<'scope, Tr1>, arranged2: Arranged<'scope, Tr2>, mut tactic: T) -> Stream<'scope, Tr1::Time, C>
 where
     Tr1: TraceReader+'static,
     Tr2: TraceReader<Time = Tr1::Time>+'static,
-    T: JoinTactic<Tr1::Batch, Tr2::Batch, CB>+'static,
-    CB: ContainerBuilder,
+    T: JoinTactic<Tr1::Batch, Tr2::Batch, C>+'static,
+    C: Container + 'static,
 {
     // Rename traces for symmetry from here on out.
     let mut trace1 = arranged1.trace;
@@ -141,6 +110,13 @@ where
         let mut acknowledged1 = Antichain::from_elem(Tr1::Time::minimum());
         let mut acknowledged2 = Antichain::from_elem(Tr1::Time::minimum());
 
+        // Deferred work, as `(capability, iterator)` pairs bucketed by which input carried the fresh
+        // batch (so a burst on one input cannot starve the other). The driver owns the capabilities and
+        // the fuel budget; each iterator, prepared by the tactic, yields the output containers to ship
+        // under its paired capability, and is dropped once it goes dry.
+        let mut todo0: VecDeque<(Capability<Tr1::Time>, Box<dyn Iterator<Item = C>>)> = VecDeque::new();
+        let mut todo1: VecDeque<(Capability<Tr1::Time>, Box<dyn Iterator<Item = C>>)> = VecDeque::new();
+
         // We'll unload the initial batches here, to put ourselves in a less non-deterministic state to start.
         trace1.map_batches(|batch1| {
             acknowledged1.clone_from(batch1.upper());
@@ -177,7 +153,8 @@ where
             // TODO: downgrade the capability by searching out the one time in `batch2.lower()` and not
             // in `batch2.upper()`. Only necessary for non-empty batches, as empty batches may not have
             // that property.
-            tactic.defer(trace1_storage, vec![batch2], Fresh::Input1, capability.clone());
+            let work = tactic.prep(trace1_storage, vec![batch2], Fresh::Input1, capability.time().clone());
+            todo1.push_back((capability.clone(), work));
         }
 
         // Droppable handles to shared trace data structures.
@@ -211,7 +188,8 @@ where
                                 // It is safe to ask for `ack2` as we validated that it was at least `get_physical_compaction()`
                                 // at start-up, and have held back physical compaction ever since.
                                 let trace2_storage = trace2.batches_through(acknowledged2.borrow()).unwrap();
-                                tactic.defer(vec![batch1.clone()], trace2_storage, Fresh::Input0, capability.clone());
+                                let work = tactic.prep(vec![batch1.clone()], trace2_storage, Fresh::Input0, capability.time().clone());
+                                todo0.push_back((capability.clone(), work));
                             }
 
                             // To update `acknowledged1` we might presume that `batch1.lower` should equal it, but we
@@ -237,7 +215,8 @@ where
                                 // It is safe to ask for `ack1` as we validated that it was at least `get_physical_compaction()`
                                 // at start-up, and have held back physical compaction ever since.
                                 let trace1_storage = trace1.batches_through(acknowledged1.borrow()).unwrap();
-                                tactic.defer(trace1_storage, vec![batch2.clone()], Fresh::Input1, capability.clone());
+                                let work = tactic.prep(trace1_storage, vec![batch2.clone()], Fresh::Input1, capability.time().clone());
+                                todo1.push_back((capability.clone(), work));
                             }
 
                             // To update `acknowledged2` we might presume that `batch2.lower` should equal it, but we
@@ -269,13 +248,31 @@ where
             // which results in unintentionally quadratic processing time (each batch of either
             // input must scan all batches from the other input).
 
-            // Perform some amount of outstanding work. The tactic decrements `fuel` as it works, and
-            // leaves it negative exactly when work remains; we reschedule the operator in that case.
-            // The two inputs' work shares this budget, so we set it to `2_000_000` to preserve the
-            // historical `1_000_000` of progress per input each activation.
-            let mut fuel = 2_000_000;
-            tactic.work(&mut fuel, output);
-            if fuel < 0 {
+            // Perform some amount of outstanding work by pulling the deferred iterators and shipping the
+            // containers they yield. Each direction drains against its own half of the budget, so a burst
+            // on one input cannot starve the other. We reschedule the operator whenever any work remains,
+            // which is observable directly: an iterator has yet to yield `None`. The budget is split from
+            // `2_000_000` to preserve the historical `1_000_000` of progress per input each activation.
+            // The driver only ships finished containers (`give_container`), never pushing records, so it
+            // pins the operator output to `NoopBuilder<C>` — the builder for exactly this "containers ready
+            // to go" case, which is a `ContainerBuilder` for any `C` without further bounds.
+            let output: &mut OutputBuilderSession<'_, Tr1::Time, NoopBuilder<C>> = output;
+            let mut drain = |queue: &mut VecDeque<(Capability<Tr1::Time>, Box<dyn Iterator<Item = C>>)>, mut fuel: isize| {
+                while fuel >= 0 {
+                    let Some((capability, work)) = queue.front_mut() else { break };
+                    match work.next() {
+                        Some(mut container) => {
+                            fuel -= container.record_count() as isize;
+                            output.session_with_builder(&*capability).give_container(&mut container);
+                        }
+                        None => { queue.pop_front(); }
+                    }
+                }
+            };
+            let fuel = 2_000_000;
+            drain(&mut todo0, fuel / 2);
+            drain(&mut todo1, fuel / 2);
+            if !todo0.is_empty() || !todo1.is_empty() {
                 activator.activate();
             }
 
@@ -323,29 +320,35 @@ where
 
 /// Cursor-based join: the conventional [`JoinTactic`] implementation and its per-batch worker.
 mod cursors {
+
+    use std::cell::RefCell;
+    use std::rc::Rc;
+
     use super::*;
 
     /// The conventional cursor-based [`JoinTactic`].
     ///
     /// It builds a [`CursorList`] over each input batch list and plays the merge-join out at whatever rate
-    /// the operator's fuel allows. Each unit joins a `B0`-side cursor against a `B1`-side cursor, emitting
-    /// `(val0, val1)` to `logic`. The two arrival directions are queued separately and drained against
-    /// independent fuel, so a burst on one input cannot starve the other.
-    pub struct CursorTactic<B0, B1, L>
+    /// the driver's fuel allows. Each prepared unit joins a `B0`-side cursor against a `B1`-side cursor,
+    /// emitting `(val0, val1)` to `logic` and yielding the output containers `logic` fills. `logic` is
+    /// shared across all outstanding units (an `Rc<RefCell<_>>`), preserving the single mutable-state
+    /// semantics of one closure threaded through every match — each unit is a self-contained `'static`
+    /// iterator, so it cannot borrow the tactic.
+    ///
+    /// It is parameterized by the builder `CB` into which `logic` pushes output; the [`JoinTactic`] it
+    /// implements is over the container `CB` yields (`CB::Container`).
+    pub struct CursorTactic<B0, B1, L, CB>
     where
         B0: BatchReader + Navigable,
         B1: BatchReader<Time = B0::Time> + Navigable,
         B0::Cursor: Cursor<Time = B0::Time>,
         B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = B0::Time>,
     {
-        logic: L,
-        /// Units whose fresh batch arrived on the first input (`B0`); their accumulated side is `B1`.
-        todo0: std::collections::VecDeque<Deferred<B0::Time, CursorList<B0::Cursor>, CursorList<B1::Cursor>>>,
-        /// Units whose fresh batch arrived on the second input (`B1`); their accumulated side is `B0`.
-        todo1: std::collections::VecDeque<Deferred<B0::Time, CursorList<B0::Cursor>, CursorList<B1::Cursor>>>,
+        logic: Rc<RefCell<L>>,
+        _marker: std::marker::PhantomData<(B0, B1, CB)>,
     }
 
-    impl<B0, B1, L> CursorTactic<B0, B1, L>
+    impl<B0, B1, L, CB> CursorTactic<B0, B1, L, CB>
     where
         B0: BatchReader + Navigable,
         B1: BatchReader<Time = B0::Time> + Navigable,
@@ -354,167 +357,164 @@ mod cursors {
     {
         /// Construct a tactic that applies `logic` to each matched `(key, val0, val1)`.
         pub fn new(logic: L) -> Self {
-            CursorTactic { logic, todo0: std::collections::VecDeque::new(), todo1: std::collections::VecDeque::new() }
+            CursorTactic { logic: Rc::new(RefCell::new(logic)), _marker: std::marker::PhantomData }
         }
     }
 
-    impl<B0, B1, L, CB> JoinTactic<B0, B1, CB> for CursorTactic<B0, B1, L>
+    impl<B0, B1, L, CB> JoinTactic<B0, B1, CB::Container> for CursorTactic<B0, B1, L, CB>
     where
-        B0: BatchReader + Navigable,
-        B1: BatchReader<Time = B0::Time> + Navigable,
+        B0: BatchReader + Navigable + 'static,
+        B1: BatchReader<Time = B0::Time> + Navigable + 'static,
         B0::Cursor: Cursor<Time = B0::Time>,
         B1::Cursor: for<'a> Cursor<Key<'a> = <B0::Cursor as Cursor>::Key<'a>, Time = B0::Time>,
-        CB: ContainerBuilder,
-        L: for<'a> FnMut(<B0::Cursor as Cursor>::Key<'a>, <B0::Cursor as Cursor>::Val<'a>, <B1::Cursor as Cursor>::Val<'a>, B0::Time, &<B0::Cursor as Cursor>::Diff, &<B1::Cursor as Cursor>::Diff, &mut JoinSession<B0::Time, CB, Capability<B0::Time>>),
+        CB: ContainerBuilder<Container: Default> + 'static,
+        L: for<'a> FnMut(<B0::Cursor as Cursor>::Key<'a>, <B0::Cursor as Cursor>::Val<'a>, <B1::Cursor as Cursor>::Val<'a>, B0::Time, &<B0::Cursor as Cursor>::Diff, &<B1::Cursor as Cursor>::Diff, &mut CB) + 'static,
     {
-        fn defer(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, capability: Capability<B0::Time>) {
-            // Advance the accumulated trace's history by `meet` to consolidate it before the cross-product;
-            // leave the fresh batch, whose times already lie at or beyond `meet` (the capability is held at
-            // or below them). `fresh` also selects the queue, so the two arrival directions drain against
-            // independent fuel and neither can starve the other.
-            //
-            // We advance the accumulated side unconditionally. The advance is output-neutral either way (the
-            // fresh side's times are at or beyond `meet`, so the joined time is too), so this is purely a
-            // consolidation: it pays off when the accumulated side carries times below `meet`, and is a wasted
-            // scan when it does not. A more precise rule would skip the scan when the side is already entirely
-            // at or beyond `meet`, but detecting that needs both frontiers, not just `lower`: a batch's times
-            // lie at or beyond both its `lower` and its `since`, so the side is entirely beyond `meet` exactly
-            // when `meet <= lower` or `meet <= since`. A fresh batch is caught by `lower` (its `since` is
-            // `minimum`), a compacted trace by `since` (its `lower` is `minimum`); checking `lower` alone would
-            // wrongly advance a compacted trace whose times are all already at or beyond `meet`. We keep the
-            // simpler fresh-based choice and accept the occasional no-op scan.
-            let (cursor0, storage0) = cursor_list(input0);
-            let (cursor1, storage1) = cursor_list(input1);
-            match fresh {
-                Fresh::Input0 => {
-                    let deferred = Deferred::new(cursor0, storage0, cursor1, storage1, capability, false, true);
-                    self.todo0.push_back(deferred);
-                }
-                Fresh::Input1 => {
-                    let deferred = Deferred::new(cursor0, storage0, cursor1, storage1, capability, true, false);
-                    self.todo1.push_back(deferred);
-                }
-            }
-        }
-
-        fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<B0::Time, EffortBuilder<CB>>) {
-            // Drain each direction against its own half of the budget, so a burst on one input cannot starve
-            // the other. Within a direction the front unit decrements its sub-budget (possibly below zero)
-            // and we stop that direction once it goes negative. If either queue still has work afterward we
-            // drive `fuel` negative so the operator reschedules; an empty pair leaves it non-negative.
-            let mut fuel0 = *fuel / 2;
-            while fuel0 >= 0 {
-                let Some(front) = self.todo0.front_mut() else { break };
-                front.work(output, &mut self.logic, &mut fuel0);
-                if !front.work_remains() { self.todo0.pop_front(); }
-            }
-            let mut fuel1 = *fuel / 2;
-            while fuel1 >= 0 {
-                let Some(front) = self.todo1.front_mut() else { break };
-                front.work(output, &mut self.logic, &mut fuel1);
-                if !front.work_remains() { self.todo1.pop_front(); }
-            }
-            *fuel = if self.todo0.is_empty() && self.todo1.is_empty() { 0 } else { -1 };
+        fn prep(&mut self, input0: Vec<B0>, input1: Vec<B1>, fresh: Fresh, meet: B0::Time) -> Box<dyn Iterator<Item = CB::Container>> {
+            // The accumulated side's history is advanced by `meet` to consolidate it before the
+            // cross-product; the fresh side is left, as its times already lie at or beyond `meet`. `fresh`
+            // fixes which side is which. The advance is output-neutral either way (the fresh side's times are
+            // at or beyond `meet`, so the joined time is too), so it is purely a consolidation: it pays off
+            // when the accumulated side carries times below `meet`, and is a wasted scan when it does not. A
+            // more precise rule would skip the scan when the side is already entirely at or beyond `meet`,
+            // but detecting that needs both frontiers, not just `lower`: a batch's times lie at or beyond
+            // both its `lower` and its `since`, so the side is entirely beyond `meet` exactly when
+            // `meet <= lower` or `meet <= since`. A fresh batch is caught by `lower` (its `since` is
+            // `minimum`), a compacted trace by `since` (its `lower` is `minimum`); checking `lower` alone
+            // would wrongly advance a compacted trace whose times are all already at or beyond `meet`. We
+            // keep the simpler fresh-based choice and accept the occasional no-op scan.
+            let (cursor1, storage1) = cursor_list(input0);
+            let (cursor2, storage2) = cursor_list(input1);
+            let (advance1, advance2) = match fresh {
+                Fresh::Input0 => (false, true),
+                Fresh::Input1 => (true, false),
+            };
+            Box::new(DeferredIter {
+                cursor1,
+                storage1,
+                cursor2,
+                storage2,
+                meet,
+                advance1,
+                advance2,
+                logic: Rc::clone(&self.logic),
+                builder: CB::default(),
+                ready: VecDeque::new(),
+                done: false,
+            })
         }
     }
 
-    /// Deferred join computation.
+    /// Deferred join computation, as an iterator of output containers.
     ///
     /// The structure wraps cursors which allow us to play out join computation at whatever rate we like.
     /// This allows us to avoid producing and buffering massive amounts of data, without giving the timely
-    /// dataflow system a chance to run operators that can consume and aggregate the data.
-    struct Deferred<T, C1, C2>
+    /// dataflow system a chance to run operators that can consume and aggregate the data. Each `next` plays
+    /// the merge-join forward until the builder yields a container (or the cursors run dry), matching the
+    /// former per-unit `work` loop but suspending at container boundaries rather than under a fuel budget:
+    /// the driver stops pulling once its budget is spent and resumes the same iterator next activation.
+    struct DeferredIter<T, C1, C2, L, CB>
     where
         T: Timestamp+Lattice,
         C1: Cursor<Time=T>,
         C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
+        CB: ContainerBuilder,
     {
         cursor1: C1,
         storage1: C1::Storage,
         cursor2: C2,
         storage2: C2::Storage,
-        capability: Capability<T>,
-        /// Whether to advance each side's history by the capability's meet before consolidation.
+        /// The capability's time, at which this unit's output ships; the lower envelope for consolidation.
+        meet: T,
+        /// Whether to advance each side's history by `meet` before consolidation.
         advance1: bool,
         advance2: bool,
+        /// The output closure, shared across all outstanding units.
+        logic: Rc<RefCell<L>>,
+        /// The builder `logic` fills; drained into `ready` as containers complete.
+        builder: CB,
+        /// Completed containers awaiting a `next` call.
+        ready: VecDeque<CB::Container>,
         done: bool,
     }
 
-    impl<T, C1, C2> Deferred<T, C1, C2>
+    impl<T, C1, C2, L, CB> Iterator for DeferredIter<T, C1, C2, L, CB>
     where
+        T: Timestamp+Lattice,
         C1: Cursor<Time=T>,
         C2: for<'a> Cursor<Key<'a>=C1::Key<'a>, Time=T>,
-        T: Timestamp+Lattice,
+        CB: ContainerBuilder<Container: Default>,
+        L: for<'a> FnMut(C1::Key<'a>, C1::Val<'a>, C2::Val<'a>, T, &C1::Diff, &C2::Diff, &mut CB),
     {
-        fn new(cursor1: C1, storage1: C1::Storage, cursor2: C2, storage2: C2::Storage, capability: Capability<T>, advance1: bool, advance2: bool) -> Self {
-            Deferred {
-                cursor1,
-                storage1,
-                cursor2,
-                storage2,
-                capability,
-                advance1,
-                advance2,
-                done: false,
-            }
-        }
-
-        fn work_remains(&self) -> bool {
-            !self.done
-        }
+        type Item = CB::Container;
 
-        /// Process keys until `fuel` is driven below zero, or the work is exhausted.
+        /// Play the merge-join forward until a container is ready, or the cursors run dry.
         #[inline(never)]
-        fn work<L, CB: ContainerBuilder>(&mut self, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>, logic: &mut L, fuel: &mut isize)
-        where
-            L: for<'a> FnMut(C1::Key<'a>, C1::Val<'a>, C2::Val<'a>, T, &C1::Diff, &C2::Diff, &mut JoinSession<T, CB, Capability<T>>),
-        {
-
-            let meet = self.capability.time();
+        fn next(&mut self) -> Option<CB::Container> {
+            // Serve any container completed on an earlier call first.
+            if let Some(container) = self.ready.pop_front() { return Some(container); }
+            if self.done { return None; }
 
-            // Advance the accumulated side by `meet` to consolidate its history; leave the fresh side, whose
-            // times already lie at or beyond `meet`. The choice was fixed per side at construction, from
-            // which input carried the fresh batch.
-            let meet1 = if self.advance1 { Some(meet) } else { None };
-            let meet2 = if self.advance2 { Some(meet) } else { None };
-
-            let mut session = output.session_with_builder(&self.capability);
+            // The accumulated side is advanced by `meet` to consolidate its history; the fresh side is left,
+            // as its times already lie at or beyond `meet`. The choice was fixed per side at construction,
+            // from which input carried the fresh batch.
+            let meet1 = if self.advance1 { Some(&self.meet) } else { None };
+            let meet2 = if self.advance2 { Some(&self.meet) } else { None };
 
             let storage1 = &self.storage1;
             let storage2 = &self.storage2;
-
             let cursor1 = &mut self.cursor1;
             let cursor2 = &mut self.cursor2;
+            let builder = &mut self.builder;
+            let ready = &mut self.ready;
+            let mut logic = self.logic.borrow_mut();
+            let logic = &mut *logic;
 
             let mut thinker = JoinThinker::new();
+            let mut exhausted = false;
 
-            while let (Some(key1), Some(key2), true) = (cursor1.get_key(storage1), cursor2.get_key(storage2), *fuel >= 0) {
+            while ready.is_empty() {
+                match (cursor1.get_key(storage1), cursor2.get_key(storage2)) {
+                    (Some(key1), Some(key2)) => match key1.cmp(&key2) {
+                        Ordering::Less => cursor1.seek_key(storage1, key2),
+                        Ordering::Greater => cursor2.seek_key(storage2, key1),
+                        Ordering::Equal => {
 
-                match key1.cmp(&key2) {
-                    Ordering::Less => cursor1.seek_key(storage1, key2),
-                    Ordering::Greater => cursor2.seek_key(storage2, key1),
-                    Ordering::Equal => {
+                            thinker.history1.edits.load(cursor1, storage1, meet1);
+                            thinker.history2.edits.load(cursor2, storage2, meet2);
 
-                        thinker.history1.edits.load(cursor1, storage1, meet1);
-                        thinker.history2.edits.load(cursor2, storage2, meet2);
+                            thinker.think(|v1,v2,t,r1,r2| {
+                                logic(key1, v1, v2, t, r1, r2, builder);
+                            });
 
-                        // populate `temp` with the results in the best way we know how.
-                        thinker.think(|v1,v2,t,r1,r2| {
-                            logic(key1, v1, v2, t, r1, r2, &mut session);
-                        });
+                            cursor1.step_key(storage1);
+                            cursor2.step_key(storage2);
 
-                        // TODO: Effort isn't perfectly tracked as we might still have some data in the
-                        // session at the moment it's dropped.
-                        *fuel -= session.builder().0.take() as isize;
-                        cursor1.step_key(storage1);
-                        cursor2.step_key(storage2);
+                            thinker.history1.clear();
+                            thinker.history2.clear();
 
-                        thinker.history1.clear();
-                        thinker.history2.clear();
-                    }
+                            // Move any completed containers aside; we yield them one at a time.
+                            while let Some(container) = builder.extract() {
+                                // Avoiding the mem::take would require a non-iterator trait.
+                                ready.push_back(std::mem::take(container));
+                            }
+                        }
+                    },
+                    // One side is exhausted; no further keys can match.
+                    _ => { exhausted = true; break; }
                 }
             }
-            self.done = !cursor1.key_valid(storage1) || !cursor2.key_valid(storage2);
+
+            if exhausted {
+                self.done = true;
+                // Flush the final partial container.
+                while let Some(container) = builder.finish() {
+                    // Avoiding the mem::take would require a non-iterator trait.
+                    ready.push_back(std::mem::take(container));
+                }
+            }
+
+            ready.pop_front()
         }
     }
 
diff --git a/differential-dataflow/src/operators/mod.rs b/differential-dataflow/src/operators/mod.rs
index ea4242048..d230a4ac3 100644
--- a/differential-dataflow/src/operators/mod.rs
+++ b/differential-dataflow/src/operators/mod.rs
@@ -144,9 +144,8 @@ impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: crate::difference::Semigroup> V
         TimeReplay { history: &self.history[..], buffer }
     }
 
-    /// Organizes history based on current contents of edits.
-    fn replay<'history>(&'history mut self) -> HistoryReplay<'history, V, T, D> {
-
+    /// Organizes history based on current contents of edits (sort + suffix meets).
+    fn build(&mut self) {
         self.buffer.clear();
         self.history.clear();
         for value_index in 0 .. self.edits.values.len() {
@@ -160,45 +159,86 @@ impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: crate::difference::Semigroup> V
 
         self.history.sort_by(|x,y| y.cmp(x));
         self.history.iter_mut().reduce(|prev, cur| { cur.1.meet_assign(&prev.1); cur });
+    }
 
+    /// Organizes history based on current contents of edits, returning a fresh replay.
+    fn replay<'history>(&'history mut self) -> HistoryReplay<'history, V, T, D> {
+        self.build();
         HistoryReplay { replay: self }
     }
-}
 
-struct HistoryReplay<'history, V, T, D> {
-    replay: &'history mut ValueHistory<V, T, D>,
+    /// Loads `edits` from a plain iterator (grouped by consecutive value — the presentation
+    /// order), advancing each time by `advance_by` if supplied, then organizes. This is the
+    /// cursor-free ingestion path: the `int_proxy` tactics present `(value_id, time, diff)`
+    /// runs directly rather than through a `Cursor`, and share this machinery instead of
+    /// re-implementing it. Ungrouped input is still correct, only less compact.
+    fn load_iter(&mut self, edits: impl Iterator<Item = (V, T, D)>, advance_by: Option<&T>) {
+        self.edits.clear();
+        let mut cur: Option<V> = None;
+        for (v, mut time, diff) in edits {
+            if cur != Some(v) {
+                if let Some(pv) = cur { self.edits.seal(pv); }
+                cur = Some(v);
+            }
+            if let Some(m) = advance_by { time.join_assign(m); }
+            self.edits.push(time, diff);
+        }
+        if let Some(pv) = cur { self.edits.seal(pv); }
+        self.build();
+    }
 }
 
-impl<'history, V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> HistoryReplay<'history, V, T, D> {
-    fn time(&self) -> Option<&T> { self.replay.history.last().map(|x| &x.0) }
-    fn meet(&self) -> Option<&T> { self.replay.history.last().map(|x| &x.1) }
+impl<V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> ValueHistory<V, T, D> {
+    /// The next (least) un-replayed time.
+    fn time(&self) -> Option<&T> { self.history.last().map(|x| &x.0) }
+    /// The meet of all un-replayed times.
+    fn meet(&self) -> Option<&T> { self.history.last().map(|x| &x.1) }
+    /// The next un-replayed edit, as `(value, time, diff)`.
     fn edit(&self) -> Option<(V, &T, &D)> {
-        self.replay.history.last().map(|&(ref t, _, v, e)| (self.replay.edits.values[v].0, t, &self.replay.edits.edits[e].1))
-    }
-
-    fn buffer(&self) -> &[((V, T), D)] {
-        &self.replay.buffer[..]
+        self.history.last().map(|&(ref t, _, v, e)| (self.edits.values[v].0, t, &self.edits.edits[e].1))
     }
-
+    /// The buffered (stepped-in, advanced, consolidated) edits.
+    fn buffer(&self) -> &[((V, T), D)] { &self.buffer[..] }
+    /// Move the next edit into the buffer.
     fn step(&mut self) {
-        let (time, _, value_index, edit_offset) = self.replay.history.pop().unwrap();
-        self.replay.buffer.push(((self.replay.edits.values[value_index].0, time), self.replay.edits.edits[edit_offset].1.clone()));
+        let (time, _, value_index, edit_offset) = self.history.pop().unwrap();
+        self.buffer.push(((self.edits.values[value_index].0, time), self.edits.edits[edit_offset].1.clone()));
     }
+    /// Step edits while the next time equals `time`; true iff any did.
     fn step_while_time_is(&mut self, time: &T) -> bool {
         let mut found = false;
-        while self.time() == Some(time) {
-            found = true;
-            self.step();
-        }
+        while self.time() == Some(time) { found = true; self.step(); }
         found
     }
+    /// Step edits while the next time is `<= time` in the TOTAL order (a superset of the
+    /// partially-ordered downset; readers filter the buffer by `less_equal` themselves).
+    fn step_through(&mut self, time: &T) {
+        while self.time().is_some_and(|t| t <= time) { self.step(); }
+    }
+    /// Advance buffered times by `meet` and consolidate — the collapse that keeps replay linear.
     fn advance_buffer_by(&mut self, meet: &T) {
-        for element in self.replay.buffer.iter_mut() {
-            (element.0).1.join_assign(meet);
-        }
-        crate::consolidation::consolidate(&mut self.replay.buffer);
+        for element in self.buffer.iter_mut() { (element.0).1.join_assign(meet); }
+        crate::consolidation::consolidate(&mut self.buffer);
     }
-    fn is_done(&self) -> bool { self.replay.history.is_empty() }
+    fn is_done(&self) -> bool { self.history.is_empty() }
+}
+
+struct HistoryReplay<'history, V, T, D> {
+    replay: &'history mut ValueHistory<V, T, D>,
+}
+
+// A `HistoryReplay` is a thin cursor-facing handle over a `ValueHistory`; the replay
+// machinery lives on `ValueHistory` itself (shared with the `int_proxy` tactics), and
+// these forward to it.
+impl<'history, V: Copy + Ord, T: Ord + Clone + Lattice, D: Clone + crate::difference::Semigroup> HistoryReplay<'history, V, T, D> {
+    fn time(&self) -> Option<&T> { self.replay.time() }
+    fn meet(&self) -> Option<&T> { self.replay.meet() }
+    fn edit(&self) -> Option<(V, &T, &D)> { self.replay.edit() }
+    fn buffer(&self) -> &[((V, T), D)] { self.replay.buffer() }
+    fn step(&mut self) { self.replay.step() }
+    fn step_while_time_is(&mut self, time: &T) -> bool { self.replay.step_while_time_is(time) }
+    fn advance_buffer_by(&mut self, meet: &T) { self.replay.advance_buffer_by(meet) }
+    fn is_done(&self) -> bool { self.replay.is_done() }
 }
 
 /// A time-only, non-destructive walk over an already-built [`ValueHistory`] history.
diff --git a/differential-dataflow/src/operators/reduce.rs b/differential-dataflow/src/operators/reduce.rs
index 9feb66bbb..4ba14388c 100644
--- a/differential-dataflow/src/operators/reduce.rs
+++ b/differential-dataflow/src/operators/reduce.rs
@@ -24,6 +24,16 @@ use crate::trace::{BatchCursor, BatchDiff, BatchKey, BatchReader, BatchVal, Batc
 use crate::trace::cursor::cursor_list;
 use crate::trace::implementations::containers::BatchContainer;
 
+/// Sort and deduplicate a list. Shared by the cursor and reference tactics (via their
+/// `use super::*`) and the proxy tactic (`crate::operators::reduce::sort_dedup`), which
+/// each previously carried an identical copy.
+#[inline(never)]
+pub(crate) fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
+    list.dedup();
+    list.sort();
+    list.dedup();
+}
+
 /// A type that resolves a key-wise reduction over batches arriving on the input.
 ///
 /// Unlike join, reduce does not suspend: its output is at most linear in its input, so a single
@@ -36,6 +46,26 @@ pub trait ReduceTactic<B1: BatchReader, B2: BatchReader<Time = B1::Time>> {
     /// the new input batches, and `held`: the times the operator currently holds capabilities for. It
     /// reasons only about times, returning the output batches to ship — each tagged with the time at
     /// which to ship it — and the new frontier of interesting times for the operator to hold.
+    ///
+    /// # Contract
+    ///
+    /// The driver ([`reduce_with_tactic`]) relies on the following; the first two are cheap to check
+    /// and are `debug_assert!`ed there.
+    ///
+    /// * **Ordered, tiling output.** The returned `(time, batch)` pairs are in ascending order and
+    ///   their descriptions *tile* `[lower, upper)`: the first batch's lower is `lower`, each batch's
+    ///   upper is the next batch's lower, and the last batch's upper is `upper` — no gaps, no overlaps.
+    ///   Sub-intervals with no updates are skipped; the next batch's lower simply picks up where the
+    ///   last left off. Producing *in order* is a requirement, not a convenience — it is what lets the
+    ///   driver check the tiling with a single linear scan.
+    /// * **Shipped at a held time.** Each batch's `time` tag is an element of `held`; the driver mints
+    ///   a capability at it, which is only valid for a held time.
+    /// * **Frontier bounds withheld work, and collapses to empty when there is none.** The returned
+    ///   frontier must be at-or-below every time the tactic defers, so the driver knows what is safe to
+    ///   release. In particular, with no work to defer it must be the *empty* antichain. Derive it from
+    ///   the actual withheld set rather than constructing it and this holds for free; returning a
+    ///   non-empty frontier with nothing pending holds capabilities forever and **deadlocks recursive
+    ///   scopes**. (Not driver-checkable — the withheld set is tactic-internal — so tactics self-enforce.)
     fn retire(
         &mut self,
         source_batches: Vec<B1>,
@@ -169,6 +199,26 @@ where
                     // each tagged with the time to ship it at, and the new frontier of interesting times.
                     let (produced, new_frontier) = tactic.retire(source_batches, output_batches, batch_storage, &lower_limit, &upper_limit, &held);
 
+                    // Contract checks (see `ReduceTactic::retire`). Cheap, debug-only.
+                    debug_assert!(
+                        produced.iter().all(|(time, _)| held.elements().contains(time)),
+                        "ReduceTactic::retire shipped a batch at a time not held as a capability",
+                    );
+                    debug_assert!(
+                        {
+                            // Ordered output makes tiling a single linear scan: each description's lower
+                            // must meet the previous upper (starting at `lower_limit`), ending at `upper_limit`.
+                            let mut edge = lower_limit.clone();
+                            let abutting = produced.iter().all(|(_, batch)| {
+                                let matches = batch.description().lower() == &edge;
+                                edge.clone_from(batch.description().upper());
+                                matches
+                            });
+                            abutting && (produced.is_empty() || edge == upper_limit)
+                        },
+                        "ReduceTactic::retire output must be ordered and tile [lower, upper)",
+                    );
+
                     // Ship each batch at a capability minted from the set at its time, and commit it to the
                     // output trace. The times are elements of `held`, so they stay valid until we downgrade.
                     for (time, batch) in produced {
@@ -446,13 +496,6 @@ mod cursors {
     }
 
 
-    #[inline(never)]
-    fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
-        list.dedup();
-        list.sort();
-        list.dedup();
-    }
-
     /// Implementation based on replaying historical and new updates together.
     mod history_replay {
 
@@ -462,7 +505,7 @@ mod cursors {
         use crate::trace::Cursor;
         use crate::operators::ValueHistory;
 
-        use super::sort_dedup;
+        use crate::operators::reduce::sort_dedup;
 
         /// The `HistoryReplayer` is a compute strategy based on moving through existing inputs, interesting times, etc in
         /// time order, maintaining consolidated representations of updates with respect to future interesting times.
@@ -809,13 +852,6 @@ pub(crate) mod reference {
         reduce_with_tactic(trace, name, ReferenceTactic::<Tr1::Batch, Tr2::Batch, Bu, L, P>::new(logic, push))
     }
 
-    /// Sorts and deduplicates, matching `cursors::sort_dedup`.
-    #[inline(never)]
-    fn sort_dedup<T: Ord>(list: &mut Vec<T>) {
-        list.dedup();
-        list.sort();
-        list.dedup();
-    }
 
     /// Updates an optional meet by an optional time.
     fn update_meet<T: Lattice+Clone>(meet: &mut Option<T>, other: Option<&T>) {
diff --git a/differential-dataflow/src/trace/chunk/int_proxy.rs b/differential-dataflow/src/trace/chunk/int_proxy.rs
deleted file mode 100644
index c1d71fc78..000000000
--- a/differential-dataflow/src/trace/chunk/int_proxy.rs
+++ /dev/null
@@ -1,542 +0,0 @@
-//! [`ProxyChunk`]: sorted, consolidated runs of `((key_hash, value_id), time, diff)` — the
-//! integers-only boundary between DD's operator logic and a columnar value backend.
-//!
-//! A backend arrangement keeps its real keys and values in whatever layout it likes; what
-//! crosses to DD is a *projection* of each record onto two integers:
-//!
-//! * `key_hash: u64` — a content hash of the key, **stable across the whole system**: the
-//!   same key hashes identically in every operator, including across the output→input
-//!   boundary (a reduce output re-ingested as a downstream input), with no registry.
-//!   It drives grouping, ordering, and merging. Collisions are an accepted risk (see the
-//!   note in [`operators::int_proxy`](crate::operators::int_proxy)).
-//! * `value_id: u64` — an intra-key identifier for a value, **ephemeral**: consistent only
-//!   within a single operator computation (one presentation, one retire's waves). Equal
-//!   values ⇔ equal ids there — a bijection per computation, which is all DD needs to
-//!   consolidate diffs per value and decide presence; a hash is one scheme, not a
-//!   requirement. It is *not* order-preserving with respect to the value type's
-//!   semantic order — see the design note in [`operators::int_proxy`](crate::operators::int_proxy).
-//!
-//! Chunks sort by `(key_hash, value_id, time)` — an arbitrary but consistent total order
-//! over which DD's sort/merge/consolidate machinery is completely data-blind. Time and
-//! diff stay DD-native: the backend never needs to understand timestamps.
-//!
-//! # Relation to the `Chunk` / `NavigableChunk` split
-//!
-//! `ProxyChunk` implements [`Chunk`], so it slots directly into the #778 machinery: batches
-//! (`ChunkBatch<ProxyChunk>`), fueled merging (`ChunkBatchMerger`), grading (`settle`) all
-//! come for free, entirely in integer space. Like a columnar backend's chunk (and unlike
-//! [`VecChunk`](super::vec::VecChunk)) it is deliberately **not** [`NavigableChunk`](super::NavigableChunk):
-//! its consumers are whole-chunk tactics that read the columns in bulk, not cursors.
-//! (`u64` keys and values are `Ord`, so the capability could be added if a cursor-driven
-//! consumer ever wants it.)
-//!
-//! Only the ids live here; the real data stays in the backend. Read-side chunks are
-//! produced by a backend's `present` (see [`operators::int_proxy`](crate::operators::int_proxy)),
-//! which retains the alignment from record index to real record. Write-side chunks are
-//! assembled by the reduce tactic from `((key_hash, value_id), time, diff)` deltas and
-//! handed back to the backend's `materialize` to become a real output batch.
-
-use std::collections::VecDeque;
-use std::rc::Rc;
-
-use timely::progress::{Antichain, Timestamp};
-use timely::progress::frontier::AntichainRef;
-
-use crate::difference::Semigroup;
-use crate::lattice::Lattice;
-
-use super::{pack, Chunk};
-
-/// The grading target. Records are four machine words plus time; small chunks would
-/// under-amortize per-chunk overhead, and the fueled merger wants to yield.
-const TARGET: usize = 8192;
-
-/// Shared, immutable chunk contents; `Clone` of an [`ProxyChunk`] is an `Rc` bump.
-struct Inner<T, R> {
-    /// Key hash column, aligned with the others, sorted by `(key, val, time)`.
-    keys: Vec<u64>,
-    /// Value id column.
-    vals: Vec<u64>,
-    /// Per-record times (the lattice algebra lives DD-side; ids never meet time).
-    times: Vec<T>,
-    /// Per-record diffs.
-    diffs: Vec<R>,
-}
-
-/// A sorted, consolidated run of `((key_hash, value_id), time, diff)`, shared via `Rc`.
-pub struct ProxyChunk<T, R>(Rc<Inner<T, R>>);
-
-impl<T, R> Clone for ProxyChunk<T, R> {
-    fn clone(&self) -> Self { ProxyChunk(Rc::clone(&self.0)) }
-}
-
-impl<T, R> Default for ProxyChunk<T, R> {
-    fn default() -> Self {
-        ProxyChunk(Rc::new(Inner { keys: Vec::new(), vals: Vec::new(), times: Vec::new(), diffs: Vec::new() }))
-    }
-}
-
-impl<T, R> ProxyChunk<T, R> {
-    /// The number of records.
-    pub fn len(&self) -> usize { self.0.times.len() }
-    /// True iff there are no records.
-    pub fn is_empty(&self) -> bool { self.len() == 0 }
-    /// The key hash column.
-    pub fn key_hashes(&self) -> &[u64] { &self.0.keys }
-    /// The value id column.
-    pub fn value_ids(&self) -> &[u64] { &self.0.vals }
-    /// The time column.
-    pub fn times(&self) -> &[T] { &self.0.times }
-    /// The diff column.
-    pub fn diffs(&self) -> &[R] { &self.0.diffs }
-}
-
-impl<T: Clone + Ord, R: Clone> ProxyChunk<T, R> {
-    /// Assemble a chunk from columns already sorted by `(key, val, time)` with no two
-    /// records equal in all three (i.e. consolidated).
-    pub fn from_sorted(keys: Vec<u64>, vals: Vec<u64>, times: Vec<T>, diffs: Vec<R>) -> Self {
-        debug_assert!(keys.len() == vals.len() && vals.len() == times.len() && times.len() == diffs.len());
-        debug_assert!((1..keys.len()).all(|i| {
-            (keys[i - 1], vals[i - 1], &times[i - 1]) < (keys[i], vals[i], &times[i])
-        }));
-        ProxyChunk(Rc::new(Inner { keys, vals, times, diffs }))
-    }
-
-    /// Extract the columns, copying only if the `Rc` is shared.
-    fn into_parts(self) -> (Vec<u64>, Vec<u64>, Vec<T>, Vec<R>) {
-        match Rc::try_unwrap(self.0) {
-            Ok(inner) => (inner.keys, inner.vals, inner.times, inner.diffs),
-            Err(rc) => (rc.keys.clone(), rc.vals.clone(), rc.times.clone(), rc.diffs.clone()),
-        }
-    }
-
-    /// The records at `idx`, as a new chunk (the integer `gather`).
-    fn gather(&self, idx: impl Iterator<Item = usize> + Clone) -> Self {
-        let inner = &*self.0;
-        ProxyChunk(Rc::new(Inner {
-            keys: idx.clone().map(|i| inner.keys[i]).collect(),
-            vals: idx.clone().map(|i| inner.vals[i]).collect(),
-            times: idx.clone().map(|i| inner.times[i].clone()).collect(),
-            diffs: idx.map(|i| inner.diffs[i].clone()).collect(),
-        }))
-    }
-}
-
-impl<T, R> ProxyChunk<T, R>
-where
-    T: Clone + Ord,
-    R: Semigroup + Clone,
-{
-    /// Sort columns by `(key, val, time)` and consolidate equal triples (summing diffs,
-    /// dropping zeros). Returns the chunk and, per retained record, the original index of
-    /// a *representative* input record — the link a backend needs to keep its real columns
-    /// aligned with the id run it presents (equal ids denote equal values, so any member
-    /// of a consolidated group serves).
-    pub fn from_unsorted(keys: Vec<u64>, vals: Vec<u64>, times: Vec<T>, diffs: Vec<R>) -> (Self, Vec<usize>) {
-        let n = times.len();
-        debug_assert!(keys.len() == n && vals.len() == n && diffs.len() == n);
-        let perm = sort_perm(&keys, &vals, &times);
-
-        let (mut ok, mut ov) = (Vec::new(), Vec::new());
-        let (mut ot, mut od) = (Vec::new(), Vec::new());
-        let mut reps = Vec::new();
-        let mut i = 0;
-        while i < n {
-            let r = perm[i];
-            let (k, v, t) = (keys[r], vals[r], &times[r]);
-            let mut d = diffs[r].clone();
-            let mut j = i + 1;
-            while j < n && {
-                let s = perm[j];
-                keys[s] == k && vals[s] == v && times[s] == *t
-            } {
-                d.plus_equals(&diffs[perm[j]]);
-                j += 1;
-            }
-            if !d.is_zero() {
-                ok.push(k);
-                ov.push(v);
-                ot.push(t.clone());
-                od.push(d);
-                reps.push(r);
-            }
-            i = j;
-        }
-        (ProxyChunk(Rc::new(Inner { keys: ok, vals: ov, times: ot, diffs: od })), reps)
-    }
-}
-
-/// The permutation sorting records by `(key_hash, value_id, time)`.
-///
-/// `key_hash` is a full 64-bit content hash (uniformly distributed), so a single MSD counting pass on
-/// its high byte splits the records into 256 near-equal buckets; each bucket is then finished by a
-/// comparison sort on the full `(key_hash, value_id, time)` key. That replaces most of the global
-/// `n log n` with one linear pass plus small local sorts — and degrades gracefully to the plain
-/// comparison sort when the hashes cluster (one bucket) or `n` is too small to amortize the pass.
-/// Stability is irrelevant: `from_unsorted` consolidates by full-key equality, order-blind within a
-/// group.
-fn sort_perm<T: Ord>(keys: &[u64], vals: &[u64], times: &[T]) -> Vec<usize> {
-    let n = keys.len();
-    let cmp = |&a: &usize, &b: &usize| (keys[a], vals[a], &times[a]).cmp(&(keys[b], vals[b], &times[b]));
-    if n < 512 {
-        let mut perm: Vec<usize> = (0..n).collect();
-        perm.sort_unstable_by(cmp);
-        return perm;
-    }
-    // MSD counting sort on the top byte of key_hash → contiguous, ascending buckets.
-    let bucket = |i: usize| (keys[i] >> 56) as usize;
-    let mut counts = [0usize; 256];
-    for i in 0..n { counts[bucket(i)] += 1; }
-    let mut starts = [0usize; 257];
-    for b in 0..256 { starts[b + 1] = starts[b] + counts[b]; }
-    let mut perm = vec![0usize; n];
-    let mut cursor = starts;
-    for i in 0..n {
-        let b = bucket(i);
-        perm[cursor[b]] = i;
-        cursor[b] += 1;
-    }
-    // Finish each bucket by the full key (all share the high byte, so ties on it are common).
-    for b in 0..256 {
-        perm[starts[b]..starts[b + 1]].sort_unstable_by(cmp);
-    }
-    perm
-}
-
-/// Column builders for one output chunk, emitted at `TARGET`.
-struct OutBuf<T, R> {
-    keys: Vec<u64>,
-    vals: Vec<u64>,
-    times: Vec<T>,
-    diffs: Vec<R>,
-}
-
-impl<T: Clone + Ord, R: Clone> OutBuf<T, R> {
-    fn new() -> Self {
-        OutBuf { keys: Vec::new(), vals: Vec::new(), times: Vec::new(), diffs: Vec::new() }
-    }
-    fn push(&mut self, k: u64, v: u64, t: T, d: R) {
-        self.keys.push(k);
-        self.vals.push(v);
-        self.times.push(t);
-        self.diffs.push(d);
-    }
-    fn len(&self) -> usize { self.times.len() }
-    /// Emit the buffered records if at `TARGET` (or `force` and non-empty).
-    fn flush(&mut self, force: bool, out: &mut VecDeque<ProxyChunk<T, R>>) {
-        if self.len() >= TARGET || (force && self.len() > 0) {
-            let full = std::mem::replace(self, OutBuf::new());
-            out.push_back(ProxyChunk(Rc::new(Inner {
-                keys: full.keys,
-                vals: full.vals,
-                times: full.times,
-                diffs: full.diffs,
-            })));
-        }
-    }
-}
-
-impl<T, R> Chunk for ProxyChunk<T, R>
-where
-    T: Timestamp + Lattice,
-    R: Semigroup + Clone + 'static,
-{
-    type Time = T;
-    const TARGET: usize = TARGET;
-
-    fn len(&self) -> usize { self.0.times.len() }
-
-    /// Two-pointer merge of the two front chunks through their shared horizon,
-    /// consolidating equal `((key, val), time)` triples. Processes only the two front
-    /// chunks per call (the `Chunk` contract permits it — "consume at least one input; the
-    /// harness may re-invoke"); the survivor's suffix is pushed back once.
-    fn merge(in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>) {
-        let c1 = in1.pop_front().unwrap();
-        let c2 = in2.pop_front().unwrap();
-        let (a, b) = (&*c1.0, &*c2.0);
-        let (n1, n2) = (a.times.len(), b.times.len());
-
-        let mut buf = OutBuf::new();
-        let (mut p1, mut p2) = (0usize, 0usize);
-        while p1 < n1 && p2 < n2 {
-            match (a.keys[p1], a.vals[p1], &a.times[p1]).cmp(&(b.keys[p2], b.vals[p2], &b.times[p2])) {
-                std::cmp::Ordering::Less => {
-                    buf.push(a.keys[p1], a.vals[p1], a.times[p1].clone(), a.diffs[p1].clone());
-                    p1 += 1;
-                }
-                std::cmp::Ordering::Greater => {
-                    buf.push(b.keys[p2], b.vals[p2], b.times[p2].clone(), b.diffs[p2].clone());
-                    p2 += 1;
-                }
-                std::cmp::Ordering::Equal => {
-                    let mut d = a.diffs[p1].clone();
-                    d.plus_equals(&b.diffs[p2]);
-                    if !d.is_zero() {
-                        buf.push(a.keys[p1], a.vals[p1], a.times[p1].clone(), d);
-                    }
-                    p1 += 1;
-                    p2 += 1;
-                }
-            }
-            buf.flush(false, out);
-        }
-        buf.flush(true, out);
-
-        // Push back the survivor's unconsumed suffix (all `>` the horizon).
-        if p1 < n1 { in1.push_front(c1.gather(p1..n1)); }
-        if p2 < n2 { in2.push_front(c2.gather(p2..n2)); }
-    }
-
-    fn extract(
-        input: &mut VecDeque<Self>,
-        frontier: AntichainRef<T>,
-        residual: &mut Antichain<T>,
-        keep: &mut VecDeque<Self>,
-        ship: &mut VecDeque<Self>,
-    ) {
-        // One input chunk per call: partition into keep (`>= frontier`) and ship pieces.
-        let Some(chunk) = input.pop_front() else { return };
-        let times = chunk.times();
-        let (mut ki, mut si) = (Vec::new(), Vec::new());
-        for (i, t) in times.iter().enumerate() {
-            if frontier.less_equal(t) {
-                residual.insert_ref(t);
-                ki.push(i);
-            } else {
-                si.push(i);
-            }
-        }
-        if !ki.is_empty() { keep.push_back(chunk.gather(ki.iter().copied())); }
-        if !si.is_empty() { ship.push_back(chunk.gather(si.iter().copied())); }
-    }
-
-    fn advance(
-        input: &mut VecDeque<Self>,
-        frontier: AntichainRef<T>,
-        done: bool,
-        out: &mut VecDeque<Self>,
-    ) {
-        // Concatenate the pushed-back carry with the newly-arrived chunks, then advance
-        // and consolidate each *complete* `(key, val)` group; withhold the trailing group
-        // as the carry unless `done`.
-        if input.is_empty() { return; }
-        let (mut keys, mut vals) = (Vec::new(), Vec::new());
-        let (mut times, mut diffs) = (Vec::new(), Vec::new());
-        for chunk in input.drain(..) {
-            let (mut k, mut v, mut t, mut d) = chunk.into_parts();
-            keys.append(&mut k);
-            vals.append(&mut v);
-            times.append(&mut t);
-            diffs.append(&mut d);
-        }
-        let n = times.len();
-        if n == 0 { return; }
-
-        // Giant-key case: the whole buffer is one `(key, val)` — no group provably complete.
-        if !done && (keys[0], vals[0]) == (keys[n - 1], vals[n - 1]) {
-            input.push_front(ProxyChunk(Rc::new(Inner { keys, vals, times, diffs })));
-            return;
-        }
-
-        // Withhold the trailing group as the carry unless `done`.
-        let end = if done {
-            n
-        } else {
-            let last = (keys[n - 1], vals[n - 1]);
-            let mut start = n;
-            while start > 0 && (keys[start - 1], vals[start - 1]) == last { start -= 1; }
-            start
-        };
-        if end < n {
-            input.push_front(ProxyChunk(Rc::new(Inner {
-                keys: keys[end..].to_vec(),
-                vals: vals[end..].to_vec(),
-                times: times[end..].to_vec(),
-                diffs: diffs[end..].to_vec(),
-            })));
-        }
-
-        // Advance + consolidate each complete group; emit `TARGET`-sized chunks.
-        let mut buf = OutBuf::new();
-        let mut i = 0;
-        while i < end {
-            let mut j = i;
-            while j < end && (keys[j], vals[j]) == (keys[i], vals[i]) { j += 1; }
-            let mut pairs: Vec<(T, R)> = (i..j)
-                .map(|k| {
-                    let mut t = times[k].clone();
-                    t.advance_by(frontier);
-                    (t, diffs[k].clone())
-                })
-                .collect();
-            // Advancing is lattice-monotone but not total-order-monotone; re-sort by time.
-            pairs.sort_by(|x, y| x.0.cmp(&y.0));
-            let mut k = 0;
-            while k < pairs.len() {
-                let t = pairs[k].0.clone();
-                let mut d = pairs[k].1.clone();
-                k += 1;
-                while k < pairs.len() && pairs[k].0 == t {
-                    d.plus_equals(&pairs[k].1);
-                    k += 1;
-                }
-                if !d.is_zero() {
-                    buf.push(keys[i], vals[i], t, d);
-                    buf.flush(false, out);
-                }
-            }
-            i = j;
-        }
-        buf.flush(true, out);
-    }
-
-    /// Maximal packing via the harness [`pack`]: coalesce by extending the columns in
-    /// place, split by copying the ranges, seal as a no-op.
-    fn settle(input: &mut VecDeque<Self>, done: bool, out: &mut VecDeque<Self>) {
-        pack(
-            input,
-            done,
-            out,
-            |acc, next| {
-                let (mut k, mut v, mut t, mut d) = std::mem::take(acc).into_parts();
-                let (mut k2, mut v2, mut t2, mut d2) = next.into_parts();
-                k.append(&mut k2);
-                v.append(&mut v2);
-                t.append(&mut t2);
-                d.append(&mut d2);
-                *acc = ProxyChunk(Rc::new(Inner { keys: k, vals: v, times: t, diffs: d }));
-            },
-            |chunk, m| {
-                let n = chunk.len();
-                let l = chunk.gather(0..m);
-                let r = chunk.gather(m..n);
-                (l, r)
-            },
-            |chunk| chunk,
-        );
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::collections::{BTreeMap, VecDeque};
-    use super::{Chunk, ProxyChunk};
-    use crate::trace::chunk::{is_graded, ChunkBatch, ChunkBatchMerger};
-    use crate::trace::{Description, Merger};
-    use timely::progress::Antichain;
-
-    fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-    /// Build a single sorted+consolidated chunk from `((key, val), time, diff)` rows.
-    fn chunk(rows: &[((u64, u64), u64, i64)]) -> ProxyChunk<u64, i64> {
-        let mut m: BTreeMap<((u64, u64), u64), i64> = BTreeMap::new();
-        for &(kv, t, d) in rows { *m.entry((kv, t)).or_insert(0) += d; }
-        m.retain(|_, d| *d != 0);
-        ProxyChunk::from_sorted(
-            m.keys().map(|((k, _), _)| *k).collect(),
-            m.keys().map(|((_, v), _)| *v).collect(),
-            m.keys().map(|(_, t)| *t).collect(),
-            m.values().copied().collect(),
-        )
-    }
-
-    fn read_batch(b: &ChunkBatch<ProxyChunk<u64, i64>>) -> BTreeMap<((u64, u64), u64), i64> {
-        let mut m = BTreeMap::new();
-        for ch in &b.chunks {
-            for i in 0..ProxyChunk::len(ch) {
-                *m.entry(((ch.key_hashes()[i], ch.value_ids()[i]), ch.times()[i])).or_insert(0) += ch.diffs()[i];
-            }
-        }
-        m.retain(|_, d| *d != 0);
-        m
-    }
-
-    fn reference(u1: &[((u64, u64), u64, i64)], u2: &[((u64, u64), u64, i64)], f: u64) -> BTreeMap<((u64, u64), u64), i64> {
-        let mut m = BTreeMap::new();
-        // `advance_by` on totally-ordered `u64` is `max`.
-        for u in u1.iter().chain(u2) { *m.entry((u.0, u.1.max(f))).or_insert(0) += u.2; }
-        m.retain(|_, d| *d != 0);
-        m
-    }
-
-    /// Cut a consolidated set into a batch of small chunks (globally sorted; groups straddle).
-    fn batch(rows: &[((u64, u64), u64, i64)], sz: usize) -> ChunkBatch<ProxyChunk<u64, i64>> {
-        let mut m: BTreeMap<((u64, u64), u64), i64> = BTreeMap::new();
-        for &(kv, t, d) in rows { *m.entry((kv, t)).or_insert(0) += d; }
-        m.retain(|_, d| *d != 0);
-        let all: Vec<((u64, u64), u64, i64)> = m.into_iter().map(|((kv, t), d)| (kv, t, d)).collect();
-        let chunks: Vec<_> = all.chunks(sz.max(1)).map(chunk).collect();
-        let desc = Description::new(Antichain::from_elem(0u64), Antichain::from_elem(10u64), Antichain::from_elem(0u64));
-        ChunkBatch::new(chunks, desc)
-    }
-
-    // The resumable merge→advance→settle pipeline, driven with tiny fuel so it suspends
-    // and settles on nearly every tick, must match a one-shot reference and stay graded.
-    #[test]
-    fn batch_merger_resumable_matches_reference() {
-        let mut seed = 0x9E3779B97F4A7C15u64;
-        for _ in 0..200 {
-            let gen = |seed: &mut u64| -> Vec<((u64, u64), u64, i64)> {
-                let n = (xorshift(seed) % 40) as usize + 1;
-                (0..n).map(|_| {
-                    let k = xorshift(seed) % 10;
-                    let v = xorshift(seed) % 3;
-                    let t = xorshift(seed) % 6;
-                    let d = if xorshift(seed) % 4 == 0 { -1 } else { 1 };
-                    ((k, v), t, d)
-                }).collect()
-            };
-            let u1 = gen(&mut seed);
-            let u2 = gen(&mut seed);
-            let sz = (xorshift(&mut seed) % 4) as usize + 1;
-            let f = xorshift(&mut seed) % 6;
-            let (s1, s2) = (batch(&u1, sz), batch(&u2, sz));
-            let frontier = Antichain::from_elem(f);
-
-            let mut merger = ChunkBatchMerger::new(&s1, &s2, frontier.borrow());
-            loop {
-                let mut fuel = 1isize; // tiny → many yields, each settling
-                merger.work(&s1, &s2, &mut fuel);
-                if fuel > 0 { break; }
-            }
-            let result = merger.done();
-            assert!(is_graded(&result.chunks), "ungraded: {:?}", result.chunks.iter().map(Chunk::len).collect::<Vec<_>>());
-            assert_eq!(read_batch(&result), reference(&u1, &u2, f), "u1={u1:?}\nu2={u2:?}\nf={f}");
-        }
-    }
-
-    // `from_unsorted` must sort by `(key, val, time)`, sum diffs of equal triples, drop
-    // zeros, and report a representative original index per retained record.
-    #[test]
-    fn from_unsorted_consolidates_with_provenance() {
-        let keys = vec![2, 1, 2, 1, 1];
-        let vals = vec![7, 5, 7, 5, 6];
-        let times = vec![0u64, 3, 0, 3, 1];
-        let diffs = vec![1i64, 1, 1, -1, 1];
-        let (chunk, reps) = ProxyChunk::from_unsorted(keys, vals, times, diffs);
-        // (1,5)@3 nets to zero and is dropped; (2,7)@0 consolidates to 2.
-        assert_eq!(chunk.key_hashes(), &[1, 2]);
-        assert_eq!(chunk.value_ids(), &[6, 7]);
-        assert_eq!(chunk.times(), &[1, 0]);
-        assert_eq!(chunk.diffs(), &[1, 2]);
-        // Representatives point at original records carrying those (key, val) pairs.
-        assert_eq!(reps.len(), 2);
-        assert_eq!(reps[0], 4); // the only (1,6) record
-        assert!(reps[1] == 0 || reps[1] == 2); // either (2,7) record serves
-    }
-
-    // Settling a run of undersized chunks yields a maximal packing with contents preserved.
-    #[test]
-    fn settle_grades_and_preserves() {
-        let n = 3 * super::TARGET as u64;
-        let mut input: VecDeque<_> = (0..n).map(|i| chunk(&[((i, 0), 0, 1)])).collect();
-        let mut out = VecDeque::new();
-        ProxyChunk::settle(&mut input, true, &mut out);
-        let chunks: Vec<_> = out.into();
-        assert!(is_graded(&chunks));
-        let total: usize = chunks.iter().map(Chunk::len).sum();
-        assert_eq!(total, n as usize);
-        let keys: Vec<u64> = chunks.iter().flat_map(|c| c.key_hashes().iter().copied()).collect();
-        assert!(keys.windows(2).all(|w| w[0] < w[1]));
-    }
-}
diff --git a/differential-dataflow/src/trace/chunk/mod.rs b/differential-dataflow/src/trace/chunk/mod.rs
index 04a6c0d0f..93a4d28aa 100644
--- a/differential-dataflow/src/trace/chunk/mod.rs
+++ b/differential-dataflow/src/trace/chunk/mod.rs
@@ -61,7 +61,6 @@ use crate::trace::{Batch, BatchReader, Description, Navigable};
 use crate::trace::cursor::Cursor;
 use crate::trace::implementations::BatchContainer;
 
-pub mod int_proxy;
 pub mod vec;
 
 /// A non-empty, bounded, consolidated, sorted sequence of `(data, time, diff)`.
diff --git a/differential-dataflow/tests/int_proxy.rs b/differential-dataflow/tests/int_proxy.rs
deleted file mode 100644
index d6cdb3bcd..000000000
--- a/differential-dataflow/tests/int_proxy.rs
+++ /dev/null
@@ -1,1143 +0,0 @@
-//! The integer-proxy chunk framework against the row-based operators.
-//!
-//! An equi-join and reductions (count, distinct) run twice over identical multi-round
-//! inputs with retractions: once through the proxy-space tactics over the in-memory
-//! reference backend (`operators::int_proxy`), once through the stock row-based operators.
-//! The update streams must agree exactly. A scripted `retire` sequence over
-//! partially-ordered `Product` times exercises the synthetic-time and pending machinery
-//! that totally-ordered dataflow rounds cannot reach.
-
-use std::collections::BTreeMap;
-use std::sync::mpsc::channel;
-
-use timely::container::CapacityContainerBuilder;
-use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::capture::Event;
-use timely::dataflow::operators::Capture;
-use timely::order::Product;
-use timely::PartialOrder;
-use timely::progress::Antichain;
-
-use differential_dataflow::consolidation::consolidate_updates;
-use differential_dataflow::input::Input;
-use differential_dataflow::operators::arrange::arrangement::arrange_core;
-use differential_dataflow::operators::int_proxy::reference::{RefBatch, VecJoinBackend, VecReduceBackend};
-use differential_dataflow::operators::int_proxy::{ProxyJoinTactic, ProxyReduceTactic};
-use differential_dataflow::operators::join::join_with_tactic;
-use differential_dataflow::operators::reduce::{reduce_with_tactic, ReduceTactic};
-use differential_dataflow::trace::chunk::vec::{ChunkBatcher, ChunkBuilder, ChunkSpine, VecChunk};
-use differential_dataflow::trace::implementations::chunker::ContainerChunker;
-use differential_dataflow::trace::cursor::Cursor;
-use differential_dataflow::trace::{Builder, Description, Navigable};
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-/// Rounds of `((key, val), diff)` updates: fresh insertions plus retractions of
-/// previously inserted records, so histories cancel and consolidate.
-fn gen_rounds(seed: u64, rounds: usize, per_round: usize) -> Vec<Vec<((u64, u64), isize)>> {
-    let mut s = seed;
-    let mut live: Vec<(u64, u64)> = Vec::new();
-    (0..rounds)
-        .map(|_| {
-            let mut round = Vec::new();
-            for _ in 0..per_round {
-                if !live.is_empty() && xorshift(&mut s) % 4 == 0 {
-                    let idx = (xorshift(&mut s) as usize) % live.len();
-                    round.push((live.swap_remove(idx), -1));
-                } else {
-                    let rec = (xorshift(&mut s) % 8, xorshift(&mut s) % 4);
-                    live.push(rec);
-                    round.push((rec, 1));
-                }
-            }
-            round
-        })
-        .collect()
-}
-
-/// Flatten captured events into a consolidated `(data, time) → diff` map.
-fn consolidated<D: Ord>(events: Vec<Event<u64, Vec<(D, u64, isize)>>>) -> BTreeMap<(D, u64), isize> {
-    let mut acc = BTreeMap::new();
-    for event in events {
-        if let Event::Messages(_, data) = event {
-            for (d, t, r) in data {
-                *acc.entry((d, t)).or_insert(0) += r;
-            }
-        }
-    }
-    acc.retain(|_, r| *r != 0);
-    acc
-}
-
-type Chunker<K, V> = ContainerChunker<VecChunk<K, V, u64, isize>>;
-type Batcher<K, V> = ChunkBatcher<K, V, u64, isize>;
-type Bldr<K, V> = ChunkBuilder<K, V, u64, isize>;
-type Spine<K, V> = ChunkSpine<K, V, u64, isize>;
-
-type JoinOut = (u64, (u64, u64));
-
-#[test]
-fn proxy_join_matches_row_join() {
-    let rounds0 = gen_rounds(0x853C49E6748FEA9B, 5, 12);
-    let rounds1 = gen_rounds(0xDA3E39CB94B95BDB, 5, 12);
-
-    // Id path: arranged chunk spines, joined by the id tactic over the reference backend.
-    let (tx, rx) = channel();
-    {
-        let (rounds0, rounds1) = (rounds0.clone(), rounds1.clone());
-        timely::execute_directly(move |worker| {
-            let (mut in0, mut in1) = worker.dataflow::<u64, _, _>(|scope| {
-                let (in0, c0) = scope.new_collection::<(u64, u64), isize>();
-                let (in1, c1) = scope.new_collection::<(u64, u64), isize>();
-                let a0 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c0.inner, Pipeline, "Arrange0");
-                let a1 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c1.inner, Pipeline, "Arrange1");
-                let tactic = ProxyJoinTactic::new(VecJoinBackend::new(|k: &u64, v0: &u64, v1: &u64| (*k, (*v0, *v1))));
-                let joined = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<(JoinOut, u64, isize)>>>(a0, a1, tactic);
-                joined.capture_into(tx);
-                (in0, in1)
-            });
-            for (t, (r0, r1)) in rounds0.iter().zip(rounds1.iter()).enumerate() {
-                for (rec, diff) in r0 { in0.update(*rec, *diff); }
-                for (rec, diff) in r1 { in1.update(*rec, *diff); }
-                in0.advance_to(t as u64 + 1);
-                in1.advance_to(t as u64 + 1);
-                in0.flush();
-                in1.flush();
-                worker.step();
-            }
-        });
-    }
-    let got = consolidated(rx.into_iter().collect());
-
-    // Row path: the stock join over the same inputs.
-    let (tx, rx) = channel();
-    {
-        timely::execute_directly(move |worker| {
-            let (mut in0, mut in1) = worker.dataflow::<u64, _, _>(|scope| {
-                let (in0, c0) = scope.new_collection::<(u64, u64), isize>();
-                let (in1, c1) = scope.new_collection::<(u64, u64), isize>();
-                c0.join(c1).inner.capture_into(tx);
-                (in0, in1)
-            });
-            for (t, (r0, r1)) in rounds0.iter().zip(rounds1.iter()).enumerate() {
-                for (rec, diff) in r0 { in0.update(*rec, *diff); }
-                for (rec, diff) in r1 { in1.update(*rec, *diff); }
-                in0.advance_to(t as u64 + 1);
-                in1.advance_to(t as u64 + 1);
-                in0.flush();
-                in1.flush();
-                worker.step();
-            }
-        });
-    }
-    let want = consolidated(rx.into_iter().collect());
-
-    assert!(!want.is_empty(), "trivial test: row join produced nothing");
-    assert_eq!(got, want);
-}
-
-/// Drive the same rounds through the proxy-space reduce and the row reduce with the same
-/// user logic, and compare the output update streams.
-fn check_reduce<V2, L>(logic: L)
-where
-    V2: differential_dataflow::Data + std::hash::Hash + Send + Sync,
-    L: FnMut(&u64, &[(&u64, isize)], &mut Vec<(V2, isize)>) + Clone + Send + Sync + 'static,
-{
-    let rounds = gen_rounds(0xC0FFEE0DDBA11, 6, 10);
-
-    // Id path.
-    let (tx, rx) = channel();
-    {
-        let rounds = rounds.clone();
-        let logic = logic.clone();
-        timely::execute_directly(move |worker| {
-            let mut input = worker.dataflow::<u64, _, _>(|scope| {
-                let (input, c) = scope.new_collection::<(u64, u64), isize>();
-                let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
-                let tactic = ProxyReduceTactic::new(VecReduceBackend::new(logic));
-                let reduced = reduce_with_tactic::<_, Spine<u64, V2>, _>(arranged, "IdReduce", tactic);
-                reduced.as_collection(|k, v| (*k, v.clone())).inner.capture_into(tx);
-                input
-            });
-            for (t, round) in rounds.iter().enumerate() {
-                for (rec, diff) in round { input.update(*rec, *diff); }
-                input.advance_to(t as u64 + 1);
-                input.flush();
-                worker.step();
-            }
-        });
-    }
-    let got = consolidated(rx.into_iter().collect());
-
-    // Row path.
-    let (tx, rx) = channel();
-    {
-        let rounds = rounds.clone();
-        let logic = logic.clone();
-        timely::execute_directly(move |worker| {
-            let mut input = worker.dataflow::<u64, _, _>(|scope| {
-                let (input, c) = scope.new_collection::<(u64, u64), isize>();
-                let mut logic = logic.clone();
-                c.reduce(move |k, input, output| logic(k, input, output)).inner.capture_into(tx);
-                input
-            });
-            for (t, round) in rounds.iter().enumerate() {
-                for (rec, diff) in round { input.update(*rec, *diff); }
-                input.advance_to(t as u64 + 1);
-                input.flush();
-                worker.step();
-            }
-        });
-    }
-    let want = consolidated(rx.into_iter().collect());
-
-    assert!(!want.is_empty(), "trivial test: row reduce produced nothing");
-    assert_eq!(got, want);
-}
-
-#[test]
-fn proxy_reduce_count_matches_row_reduce() {
-    check_reduce::<isize, _>(|_k, input, output| {
-        let count: isize = input.iter().map(|(_, d)| *d).sum();
-        if count > 0 {
-            output.push((count, 1));
-        }
-    });
-}
-
-#[test]
-fn proxy_reduce_distinct_matches_row_reduce() {
-    check_reduce::<(), _>(|_k, input, output| {
-        if input.iter().any(|(_, d)| *d > 0) {
-            output.push(((), 1));
-        }
-    });
-}
-
-#[test]
-fn proxy_reduce_min_matches_row_reduce() {
-    // Order-sensitive reduction: `value_id`s are hash-ordered, so min MUST come from the
-    // value callback (the design's ordering decision); this pins that path.
-    check_reduce::<u64, _>(|_k, input, output| {
-        if let Some(m) = input.iter().filter(|(_, d)| *d > 0).map(|(v, _)| **v).min() {
-            output.push((m, 1));
-        }
-    });
-}
-
-// ---------------------------------------------------------------------------
-// Partially ordered times: a scripted retire sequence over `Product<u64, u64>`.
-// ---------------------------------------------------------------------------
-
-type PT = Product<u64, u64>;
-type PBatch<V> = RefBatch<u64, V, PT, isize>;
-
-fn pt(a: u64, b: u64) -> PT {
-    Product::new(a, b)
-}
-
-/// Build a reference-backend batch from rows (sorted+consolidated internally).
-fn pbatch<V: Ord + Clone + 'static>(mut rows: Vec<((u64, V), PT, isize)>, lower: Vec<PT>, upper: Vec<PT>) -> PBatch<V> {
-    use timely::container::PushInto;
-    consolidate_updates(&mut rows);
-    let mut chunk = VecChunk::default();
-    for row in rows {
-        chunk.push_into(row);
-    }
-    let description = Description::new(
-        Antichain::from_iter(lower),
-        Antichain::from_iter(upper),
-        Antichain::from_elem(pt(0, 0)),
-    );
-    let mut builder = ChunkBuilder::<u64, V, PT, isize>::with_capacity(0, 0, 0);
-    builder.push(&mut chunk);
-    builder.done(description)
-}
-
-fn pbatch_rows<V: Ord + Clone + 'static>(batch: &PBatch<V>) -> Vec<((u64, V), PT, isize)> {
-    let mut rows = Vec::new();
-    let mut cursor = batch.cursor();
-    while let Some(k) = cursor.get_key(batch) {
-        while let Some(v) = cursor.get_val(batch) {
-            cursor.map_times(batch, |t, d| rows.push(((*k, v.clone()), t.clone(), *d)));
-            cursor.step_val(batch);
-        }
-        cursor.step_key(batch);
-    }
-    consolidate_updates(&mut rows);
-    rows
-}
-
-/// Updates at `(0, 1)` and `(1, 0)` must produce a correction at their join `(1, 1)` —
-/// synthesized by the tactic in one interval when `(1, 1)` lies inside it, and *pended*
-/// across retires when it does not. Three scripted retires walk a count reduction
-/// through arrival at `(0, 1)`, arrival at `(1, 0)` with `(1, 1)` beyond the interval
-/// (so it pends), and the pending-driven correction with no new input at all.
-#[test]
-fn proxy_reduce_synthesizes_and_pends_product_times() {
-    let count = |_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
-        let count: isize = input.iter().map(|(_, d)| *d).sum();
-        if count > 0 {
-            output.push((count, 1));
-        }
-    };
-    let mut tactic = ProxyReduceTactic::new(VecReduceBackend::new(count));
-
-    // Retire 1: value 10 arrives at (0, 1); interval [(0,0), {(0,2),(1,0)}).
-    let batch1 = pbatch(vec![((1u64, 10u64), pt(0, 1), 1)], vec![pt(0, 0)], vec![pt(0, 2), pt(1, 0)]);
-    let lower1 = Antichain::from_elem(pt(0, 0));
-    let upper1 = Antichain::from_iter([pt(0, 2), pt(1, 0)]);
-    let held1 = Antichain::from_elem(pt(0, 0));
-    let (produced1, frontier1) = tactic.retire(vec![], vec![], vec![batch1.clone()], &lower1, &upper1, &held1);
-    assert_eq!(produced1.len(), 1);
-    assert_eq!(produced1[0].0, pt(0, 0));
-    assert_eq!(pbatch_rows(&produced1[0].1), vec![((1, 1isize), pt(0, 1), 1)]);
-    assert!(frontier1.is_empty()); // nothing pended
-
-    // Retire 2: value 20 arrives at (1, 0); interval [{(0,2),(1,0)}, {(1,1)}). The
-    // synthetic join (0,1) ∨ (1,0) = (1,1) is at the upper bound, so it must PEND.
-    let batch2 = pbatch(vec![((1u64, 20u64), pt(1, 0), 1)], vec![pt(0, 2), pt(1, 0)], vec![pt(1, 1)]);
-    let lower2 = upper1.clone();
-    let upper2 = Antichain::from_elem(pt(1, 1));
-    let held2 = Antichain::from_elem(pt(1, 0));
-    let (produced2, frontier2) = tactic.retire(
-        vec![batch1.clone()],
-        vec![produced1[0].1.clone()],
-        vec![batch2.clone()],
-        &lower2,
-        &upper2,
-        &held2,
-    );
-    assert_eq!(produced2.len(), 1);
-    assert_eq!(produced2[0].0, pt(1, 0));
-    // At (1, 0) only value 20 is visible ((0,1) is incomparable): count 1.
-    assert_eq!(pbatch_rows(&produced2[0].1), vec![((1, 1isize), pt(1, 0), 1)]);
-    assert_eq!(frontier2, Antichain::from_elem(pt(1, 1))); // (1,1) pended
-
-    // Retire 3: no new input; the pended (1,1) drives the correction. Both values are
-    // now visible (count 2), while the accumulated output claims two counts of 1.
-    let lower3 = upper2.clone();
-    let upper3 = Antichain::new(); // the closed interval: nothing lies beyond
-    let held3 = Antichain::from_elem(pt(1, 1));
-    let (produced3, frontier3) = tactic.retire(
-        vec![batch1, batch2],
-        vec![produced1[0].1.clone(), produced2[0].1.clone()],
-        vec![],
-        &lower3,
-        &upper3,
-        &held3,
-    );
-    assert_eq!(produced3.len(), 1);
-    assert_eq!(produced3[0].0, pt(1, 1));
-    assert_eq!(
-        pbatch_rows(&produced3[0].1),
-        vec![((1, 1isize), pt(1, 1), -2), ((1, 2isize), pt(1, 1), 1)]
-    );
-    assert!(frontier3.is_empty());
-}
-
-// ---------------------------------------------------------------------------
-// Asymptotics: presented work must track the delta, not the accumulated trace.
-// ---------------------------------------------------------------------------
-//
-// The cursor tactics touch an arrangement only at the keys a fresh batch names
-// (plus, for reduce, pending keys), at logarithmic seek cost. The proxy tactics
-// must not be asymptotically worse: the changed-key filter (reduce) and the
-// fresh-side filter (join) exist precisely so a backend can seek rather than
-// scan. These tests pin that: with `N` arranged keys and rounds touching one
-// key, the number of *presented* records — a deterministic work measure the
-// backend observes directly — must stay far below `N`, where a scanning
-// implementation would present `Ω(rounds · N)`.
-
-use std::sync::Arc;
-use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
-
-use differential_dataflow::operators::int_proxy::{ProxyChunk, ProxyJoinBackend, ProxyReduceBackend};
-use differential_dataflow::trace::BatchReader;
-
-/// A reduce backend wrapper counting records presented by the inner backend.
-struct CountingReduce<B> {
-    inner: B,
-    presented: Arc<AtomicUsize>,
-}
-
-impl<B1, B2, B> ProxyReduceBackend<B1, B2> for CountingReduce<B>
-where
-    B1: BatchReader,
-    B2: BatchReader<Time = B1::Time>,
-    B: ProxyReduceBackend<B1, B2>,
-{
-    type RIn = B::RIn;
-    type ROut = B::ROut;
-
-    fn seed_times(&self, novel: &[B1]) -> Vec<(u64, B1::Time)> {
-        let seeds = self.inner.seed_times(novel);
-        self.presented.fetch_add(seeds.len(), AtomicOrdering::SeqCst);
-        seeds
-    }
-    fn present_input(&mut self, history: &[B1], novel: &[B1], keys: &[u64]) -> ProxyChunk<B1::Time, B::RIn> {
-        let chunk = self.inner.present_input(history, novel, keys);
-        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
-        chunk
-    }
-    fn present_output(&mut self, batches: &[B2], keys: &[u64]) -> ProxyChunk<B1::Time, B::ROut> {
-        let chunk = self.inner.present_output(batches, keys);
-        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
-        chunk
-    }
-    fn reduce(&mut self, key_hash: u64, input: &[(usize, B::RIn)]) -> Vec<(u64, B::ROut)> {
-        self.inner.reduce(key_hash, input)
-    }
-    fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, B::RIn)]) -> (Vec<(u64, B::ROut)>, Vec<usize>) {
-        self.inner.reduce_many(keys, ends, input)
-    }
-    fn materialize(&mut self, records: ProxyChunk<B1::Time, B::ROut>, description: Description<B1::Time>) -> B2 {
-        self.inner.materialize(records, description)
-    }
-}
-
-/// A join backend wrapper counting records presented by the inner backend.
-struct CountingJoin<B> {
-    inner: B,
-    presented: Arc<AtomicUsize>,
-}
-
-impl<B0, B1, B> ProxyJoinBackend<B0, B1> for CountingJoin<B>
-where
-    B0: BatchReader,
-    B1: BatchReader<Time = B0::Time>,
-    B: ProxyJoinBackend<B0, B1>,
-{
-    type R0 = B::R0;
-    type R1 = B::R1;
-    type ROut = B::ROut;
-    type Output = B::Output;
-
-    fn present0(&mut self, batches: &[B0], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, B::R0> {
-        let chunk = self.inner.present0(batches, filter);
-        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
-        chunk
-    }
-    fn present1(&mut self, batches: &[B1], filter: Option<&[u64]>) -> ProxyChunk<B0::Time, B::R1> {
-        let chunk = self.inner.present1(batches, filter);
-        self.presented.fetch_add(chunk.len(), AtomicOrdering::SeqCst);
-        chunk
-    }
-    fn cross(&mut self, left: &[usize], right: &[usize], times: Vec<B0::Time>, diffs: Vec<B::ROut>) -> B::Output {
-        self.inner.cross(left, right, times, diffs)
-    }
-}
-
-#[test]
-fn proxy_reduce_work_is_delta_proportional() {
-    use timely::dataflow::operators::probe::{Handle, Probe};
-
-    const N: u64 = 20_000;
-    const ROUNDS: u64 = 5;
-    let presented = Arc::new(AtomicUsize::new(0));
-    let counter = Arc::clone(&presented);
-
-    timely::execute_directly(move |worker| {
-        let probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, c) = scope.new_collection::<(u64, u64), isize>();
-            let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
-            let backend = CountingReduce {
-                inner: VecReduceBackend::new(|_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
-                    let count: isize = input.iter().map(|(_, d)| *d).sum();
-                    if count > 0 {
-                        output.push((count, 1));
-                    }
-                }),
-                presented: counter,
-            };
-            let reduced = reduce_with_tactic::<_, Spine<u64, isize>, _>(arranged, "ProxyReduce", ProxyReduceTactic::new(backend));
-            reduced.stream.probe_with(&probe);
-            input
-        });
-
-        // Round 0: a large arrangement. This work is inherently O(N); let it drain.
-        for k in 0..N {
-            input.update((k, k % 5), 1);
-        }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) {
-            worker.step();
-        }
-        let after_load = presented.load(AtomicOrdering::SeqCst);
-
-        // Rounds 1..: touch ONE key per round. Presented work must track that key's
-        // history, independent of N; a scanning backend would present ≥ ROUNDS · N.
-        for t in 1..=ROUNDS {
-            input.update((7, 100 + t), 1);
-            input.advance_to(t + 1);
-            input.flush();
-            while probe.less_than(input.time()) {
-                worker.step();
-            }
-        }
-        let total = presented.load(AtomicOrdering::SeqCst);
-        let incremental = total - after_load;
-        assert!(incremental > 0, "the incremental rounds presented nothing");
-        assert!(
-            incremental < (N as usize) / 4,
-            "presented {incremental} records over {ROUNDS} single-key rounds against {N} keys: not delta-proportional"
-        );
-    });
-}
-
-#[test]
-fn proxy_join_work_is_delta_proportional() {
-    use timely::dataflow::operators::probe::{Handle, Probe};
-
-    const N: u64 = 20_000;
-    const ROUNDS: u64 = 5;
-    let presented = Arc::new(AtomicUsize::new(0));
-    let counter = Arc::clone(&presented);
-
-    timely::execute_directly(move |worker| {
-        let probe = Handle::new();
-        let (mut left, mut right) = worker.dataflow::<u64, _, _>(|scope| {
-            let (left, c0) = scope.new_collection::<(u64, u64), isize>();
-            let (right, c1) = scope.new_collection::<(u64, u64), isize>();
-            let a0 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c0.inner, Pipeline, "Arrange0");
-            let a1 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c1.inner, Pipeline, "Arrange1");
-            let backend = CountingJoin {
-                inner: VecJoinBackend::new(|k: &u64, v0: &u64, v1: &u64| (*k, (*v0, *v1))),
-                presented: counter,
-            };
-            let joined = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<(JoinOut, u64, isize)>>>(a0, a1, ProxyJoinTactic::new(backend));
-            joined.probe_with(&probe);
-            (left, right)
-        });
-
-        // Round 0: a large accumulated right side. Inherently O(N); let it drain.
-        for k in 0..N {
-            right.update((k, k), 1);
-        }
-        left.advance_to(1);
-        right.advance_to(1);
-        left.flush();
-        right.flush();
-        while probe.less_than(left.time()) {
-            worker.step();
-        }
-        let after_load = presented.load(AtomicOrdering::SeqCst);
-
-        // Rounds 1..: one fresh left record per round. The unit joins it against the
-        // accumulated right trace; the fresh-side filter must keep presented work at
-        // the matched key's records, independent of N.
-        for t in 1..=ROUNDS {
-            left.update((7, 100 + t), 1);
-            left.advance_to(t + 1);
-            right.advance_to(t + 1);
-            left.flush();
-            right.flush();
-            while probe.less_than(left.time()) {
-                worker.step();
-            }
-        }
-        let total = presented.load(AtomicOrdering::SeqCst);
-        let incremental = total - after_load;
-        assert!(incremental > 0, "the incremental rounds presented nothing");
-        assert!(
-            incremental < (N as usize) / 4,
-            "presented {incremental} records over {ROUNDS} single-record rounds against {N} keys: not delta-proportional"
-        );
-    });
-}
-
-// ---------------------------------------------------------------------------
-// The minimal self-contained assessment: the framework closed over itself.
-// ---------------------------------------------------------------------------
-//
-// The tactics are operator-side: they demand only `BatchReader` of the trace, so the
-// minimal arrangement is a batch of `ProxyChunk` itself — the proxy data IS the data.
-// The `IdentityReduce` backend makes the loop close: values are `u64`s and the id
-// function is the identity, so there is no hashing, no resolution machinery, and no
-// collision possibility. What remains under test is exactly the framework's own
-// contribution — the interesting-time logic, desired-vs-current deltas, pending, and
-// held-time routing — which a brute-force oracle checks at EVERY point of a
-// partially-ordered time grid: the accumulated output must equal the reduction of the
-// accumulated input, everywhere, under randomized inputs and randomized retire
-// boundaries (diagonal frontiers, so synthetic joins pend across retires).
-
-mod identity {
-    use std::rc::Rc;
-    use differential_dataflow::operators::int_proxy::{ProxyChunk, ProxyReduceBackend};
-    use differential_dataflow::trace::Description;
-    use differential_dataflow::trace::chunk::ChunkBatch;
-    use differential_dataflow::lattice::Lattice;
-    use timely::progress::Timestamp;
-
-    pub type Batch<T> = Rc<ChunkBatch<ProxyChunk<T, isize>>>;
-
-    /// The identity backend: batches are proxy chunks, values are the ids themselves.
-    pub struct IdentityReduce<T, L> {
-        pub logic: L,
-        /// The live input presentation, for representative-index → id resolution.
-        current: ProxyChunk<T, isize>,
-    }
-
-    impl<T: Timestamp + Lattice, L> IdentityReduce<T, L> {
-        pub fn new(logic: L) -> Self {
-            IdentityReduce { logic, current: ProxyChunk::default() }
-        }
-    }
-
-    fn records<T: Timestamp + Lattice>(batches: &[Batch<T>], keys: Option<&[u64]>) -> (Vec<u64>, Vec<u64>, Vec<T>, Vec<isize>) {
-        let (mut ks, mut vs) = (Vec::new(), Vec::new());
-        let (mut ts, mut ds) = (Vec::new(), Vec::new());
-        for batch in batches {
-            for chunk in &batch.chunks {
-                for i in 0..chunk.len() {
-                    let k = chunk.key_hashes()[i];
-                    if keys.is_none_or(|f| f.binary_search(&k).is_ok()) {
-                        ks.push(k);
-                        vs.push(chunk.value_ids()[i]);
-                        ts.push(chunk.times()[i].clone());
-                        ds.push(chunk.diffs()[i]);
-                    }
-                }
-            }
-        }
-        (ks, vs, ts, ds)
-    }
-
-    impl<T, L> ProxyReduceBackend<Batch<T>, Batch<T>> for IdentityReduce<T, L>
-    where
-        T: Timestamp + Lattice,
-        L: FnMut(&[(u64, isize)]) -> Vec<(u64, isize)>,
-    {
-        type RIn = isize;
-        type ROut = isize;
-
-        fn seed_times(&self, novel: &[Batch<T>]) -> Vec<(u64, T)> {
-            // Raw (key_hash, time) support, sorted by key_hash — no value work.
-            let (ks, _vs, ts, _ds) = records(novel, None);
-            let mut out: Vec<(u64, T)> = ks.into_iter().zip(ts).collect();
-            out.sort_by_key(|(k, _)| *k);
-            out
-        }
-
-        fn present_input(&mut self, history: &[Batch<T>], novel: &[Batch<T>], keys: &[u64]) -> ProxyChunk<T, isize> {
-            let (mut ks, mut vs, mut ts, mut ds) = records(history, Some(keys));
-            let (k2, v2, t2, d2) = records(novel, Some(keys));
-            ks.extend(k2);
-            vs.extend(v2);
-            ts.extend(t2);
-            ds.extend(d2);
-            let (chunk, _reps) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
-            self.current = chunk.clone();
-            chunk
-        }
-
-        fn present_output(&mut self, batches: &[Batch<T>], keys: &[u64]) -> ProxyChunk<T, isize> {
-            let (ks, vs, ts, ds) = records(batches, Some(keys));
-            ProxyChunk::from_unsorted(ks, vs, ts, ds).0
-        }
-
-        fn reduce(&mut self, _key_hash: u64, input: &[(usize, isize)]) -> Vec<(u64, isize)> {
-            // Resolve representative indices to ids; the ids are the values.
-            let pairs: Vec<(u64, isize)> = input.iter().map(|&(i, d)| (self.current.value_ids()[i], d)).collect();
-            (self.logic)(&pairs)
-        }
-
-        // Override the batched form (a stand-in for one bulk crossing into columnar
-        // logic), asserting the bracket protocol from the backend's seat, so the fuzz
-        // exercises the wave-batched path rather than the per-key default.
-        fn reduce_many(&mut self, keys: &[u64], ends: &[usize], input: &[(usize, isize)]) -> (Vec<(u64, isize)>, Vec<usize>) {
-            assert_eq!(keys.len(), ends.len(), "one bracket end per key");
-            assert!(ends.windows(2).all(|w| w[0] < w[1]), "brackets non-empty and increasing");
-            assert_eq!(ends.last().copied().unwrap_or(0), input.len(), "brackets cover the input");
-            let mut outs = Vec::new();
-            let mut out_ends = Vec::with_capacity(keys.len());
-            let mut start = 0;
-            for &end in ends {
-                let pairs: Vec<(u64, isize)> = input[start..end].iter().map(|&(i, d)| (self.current.value_ids()[i], d)).collect();
-                outs.extend((self.logic)(&pairs));
-                out_ends.push(outs.len());
-                start = end;
-            }
-            (outs, out_ends)
-        }
-
-        fn materialize(&mut self, chunk: ProxyChunk<T, isize>, description: Description<T>) -> Batch<T> {
-            // The proxy records ARE the output records: the output arrangement is proxy
-            // chunks (incidentally exercising `ChunkBatch<ProxyChunk>` as a real batch).
-            let chunks = if chunk.is_empty() { Vec::new() } else { vec![chunk] };
-            Rc::new(ChunkBatch::new(chunks, description))
-        }
-    }
-}
-
-/// Drive `ProxyReduceTactic` over the identity backend through a sequence of retires,
-/// emulating the driver protocol: `lower` chases `upper`, `held` is the previous
-/// returned frontier joined with the round's input times (the batch capabilities),
-/// and source/output batch lists accumulate.
-/// Drive `ProxyReduceTactic` over the identity backend through a sequence of retires,
-/// emulating the driver protocol. With `compact`, plays the COMPACTION ADVERSARY: before
-/// each retire, every accumulated source and output batch has its times advanced to the
-/// interval's lower bound and is re-consolidated — accumulation-preserving (the model's
-/// `acc_mapDomain`), and exactly the move that can cancel a stored record against a
-/// novel one in a merged view. A correct tactic's output must not change.
-fn drive_identity_reduce_compacting<L>(
-    rounds: &[(Antichain<PT>, Vec<((u64, u64), PT, isize)>)],
-    logic: L,
-    compact: bool,
-) -> Vec<((u64, u64), PT, isize)>
-where
-    L: FnMut(&[(u64, isize)]) -> Vec<(u64, isize)>,
-{
-    use differential_dataflow::operators::int_proxy::ProxyChunk;
-    use differential_dataflow::trace::chunk::ChunkBatch;
-
-    #[allow(unused_imports)]
-    use differential_dataflow::trace::BatchReader as _;
-
-    let mut tactic = ProxyReduceTactic::new(identity::IdentityReduce::new(logic));
-    let mut lower = Antichain::from_elem(pt(0, 0));
-    let mut frontier: Antichain<PT> = Antichain::new();
-    let mut source: Vec<identity::Batch<PT>> = Vec::new();
-    let mut outputs: Vec<identity::Batch<PT>> = Vec::new();
-    let mut produced_records = Vec::new();
-
-    for (upper, updates) in rounds {
-        let input: Vec<identity::Batch<PT>> = if updates.is_empty() {
-            Vec::new()
-        } else {
-            let (ks, vs): (Vec<u64>, Vec<u64>) = updates.iter().map(|((k, v), _, _)| (*k, *v)).unzip();
-            let ts: Vec<PT> = updates.iter().map(|(_, t, _)| t.clone()).collect();
-            let ds: Vec<isize> = updates.iter().map(|(_, _, d)| *d).collect();
-            let (chunk, _) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
-            let desc = Description::new(lower.clone(), upper.clone(), Antichain::from_elem(pt(0, 0)));
-            let chunks = if chunk.is_empty() { Vec::new() } else { vec![chunk] };
-            vec![std::rc::Rc::new(ChunkBatch::new(chunks, desc))]
-        };
-
-        // Held capabilities: what the driver would hold — previously returned frontier
-        // plus the capabilities that arrived with this round's batches.
-        let mut held = frontier.clone();
-        for (_, t, _) in updates {
-            held.insert(t.clone());
-        }
-
-        if compact {
-            use differential_dataflow::lattice::Lattice;
-            let advance = |batches: &mut Vec<identity::Batch<PT>>| {
-                for batch in batches.iter_mut() {
-                    let (mut ks, mut vs) = (Vec::new(), Vec::new());
-                    let (mut ts, mut ds) = (Vec::new(), Vec::new());
-                    for chunk in &batch.chunks {
-                        for i in 0..chunk.len() {
-                            ks.push(chunk.key_hashes()[i]);
-                            vs.push(chunk.value_ids()[i]);
-                            let mut t = chunk.times()[i].clone();
-                            t.advance_by(lower.borrow());
-                            ts.push(t);
-                            ds.push(chunk.diffs()[i]);
-                        }
-                    }
-                    let (chunk, _) = ProxyChunk::from_unsorted(ks, vs, ts, ds);
-                    let chunks = if chunk.is_empty() { Vec::new() } else { vec![chunk] };
-                    *batch = std::rc::Rc::new(ChunkBatch::new(chunks, batch.description().clone()));
-                }
-            };
-            advance(&mut source);
-            advance(&mut outputs);
-        }
-
-        let (produced, new_frontier) = tactic.retire(source.clone(), outputs.clone(), input.clone(), &lower, upper, &held);
-        for (_, batch) in produced {
-            for chunk in &batch.chunks {
-                for i in 0..chunk.len() {
-                    produced_records.push((
-                        (chunk.key_hashes()[i], chunk.value_ids()[i]),
-                        chunk.times()[i].clone(),
-                        chunk.diffs()[i],
-                    ));
-                }
-            }
-            outputs.push(batch);
-        }
-        source.extend(input);
-        frontier = new_frontier;
-        lower = upper.clone();
-    }
-    assert!(frontier.is_empty(), "everything retired, but times remain pending");
-    produced_records
-}
-
-
-/// Randomized closure test of the reduce tactic alone, over partially ordered times:
-/// random updates on a `Product` grid, retired through random diagonal frontiers (so
-/// synthetic joins arise inside and across intervals and must pend), checked against a
-/// brute-force oracle at EVERY grid point — the accumulated output there must equal the
-/// reduction of the accumulated input.
-#[test]
-fn proxy_reduce_identity_fuzz_matches_grid_oracle() {
-    const T: u64 = 3; // times range over the (T+1)×(T+1) grid
-    let mut seed = 0x853C49E6748FEA9Bu64;
-
-    // Reducers over ids (values are ids; the id order is the value order here).
-    type Logic = fn(&[(u64, isize)]) -> Vec<(u64, isize)>;
-    let reducers: Vec<Logic> = vec![
-        // count: the number of present records, as a value.
-        |acc| {
-            let s: isize = acc.iter().map(|(_, d)| *d).sum();
-            if s > 0 { vec![(s as u64, 1)] } else { Vec::new() }
-        },
-        // distinct: the unit value if anything is present.
-        |acc| {
-            if acc.iter().any(|(_, d)| *d > 0) { vec![(0, 1)] } else { Vec::new() }
-        },
-        // min: the least present id.
-        |acc| {
-            acc.iter().filter(|(_, d)| *d > 0).map(|(v, _)| *v).min().map(|m| vec![(m, 1)]).unwrap_or_default()
-        },
-    ];
-
-    for iteration in 0..300 {
-        let logic = reducers[iteration % reducers.len()];
-
-        // Random updates over a small key/value space and the time grid.
-        let n = (xorshift(&mut seed) % 12) as usize + 1;
-        let updates: Vec<((u64, u64), PT, isize)> = (0..n)
-            .map(|_| {
-                let k = xorshift(&mut seed) % 2;
-                let v = xorshift(&mut seed) % 3;
-                let t = pt(xorshift(&mut seed) % (T + 1), xorshift(&mut seed) % (T + 1));
-                let d = if xorshift(&mut seed) % 3 == 0 { -1 } else { 1 };
-                ((k, v), t, d)
-            })
-            .collect();
-
-        // Random increasing diagonal frontiers: upper_r = { p : |p| = s_r } for an
-        // increasing random set of diagonals, closed by the empty frontier (retire all).
-        let mut cuts: Vec<u64> = (1..=2 * T).filter(|_| xorshift(&mut seed) % 2 == 0).collect();
-        cuts.dedup();
-        let mut rounds: Vec<(Antichain<PT>, Vec<((u64, u64), PT, isize)>)> = Vec::new();
-        let mut prev = 0u64;
-        for &s in &cuts {
-            let upper = Antichain::from_iter((0..=s).map(|x| pt(x, s - x)));
-            let batch = updates.iter().filter(|(_, t, _)| {
-                let sum = t.outer + t.inner;
-                prev <= sum && sum < s
-            }).cloned().collect();
-            rounds.push((upper, batch));
-            prev = s;
-        }
-        let tail = updates.iter().filter(|(_, t, _)| t.outer + t.inner >= prev).cloned().collect();
-        rounds.push((Antichain::new(), tail));
-
-        let compact = iteration % 2 == 1;
-        let produced = drive_identity_reduce_compacting(&rounds, logic, compact);
-
-        // The oracle: at every grid point, per key, the accumulated output equals the
-        // reduction of the accumulated input.
-        for x in 0..=T {
-            for y in 0..=T {
-                let p = pt(x, y);
-                for key in 0..2u64 {
-                    let mut acc: BTreeMap<u64, isize> = BTreeMap::new();
-                    for ((k, v), t, d) in &updates {
-                        if *k == key && t.less_equal(&p) {
-                            *acc.entry(*v).or_insert(0) += d;
-                        }
-                    }
-                    acc.retain(|_, d| *d != 0);
-                    let pairs: Vec<(u64, isize)> = acc.into_iter().collect();
-                    let mut want: BTreeMap<u64, isize> = BTreeMap::new();
-                    if !pairs.is_empty() {
-                        for (v, d) in (logic)(&pairs) {
-                            *want.entry(v).or_insert(0) += d;
-                        }
-                        want.retain(|_, d| *d != 0);
-                    }
-                    let mut got: BTreeMap<u64, isize> = BTreeMap::new();
-                    for ((k, v), t, d) in &produced {
-                        if *k == key && t.less_equal(&p) {
-                            *got.entry(*v).or_insert(0) += d;
-                        }
-                    }
-                    got.retain(|_, d| *d != 0);
-                    assert_eq!(
-                        got, want,
-                        "iteration {iteration}, key {key}, point {p:?}\nupdates: {updates:?}\nrounds: {:?}\nproduced: {produced:?}",
-                        rounds.iter().map(|(u, b)| (u.elements().to_vec(), b.len())).collect::<Vec<_>>()
-                    );
-                }
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Wall clock: the proxy stack against the stock row stack.
-// ---------------------------------------------------------------------------
-//
-// Not run by default. Run with:
-//   cargo test --release -p differential-dataflow --test int_proxy -- --ignored --nocapture
-//
-// Compares full stacks end to end — the stock row operators (their own arrangements
-// included) against chunk arrangements plus the proxy tactics over the reference
-// backend — for a bulk load of `n` keys and an incremental phase of single-key rounds.
-// The counting tests above pin the asymptotics; this reports the constants.
-
-fn bench_reduce(n: u64, rounds: u64, proxy: bool) -> (std::time::Duration, std::time::Duration) {
-    use std::time::Instant;
-    use timely::dataflow::operators::probe::{Handle, Probe};
-
-    timely::execute_directly(move |worker| {
-        let probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, c) = scope.new_collection::<(u64, u64), isize>();
-            let count = |_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
-                let count: isize = input.iter().map(|(_, d)| *d).sum();
-                if count > 0 {
-                    output.push((count, 1));
-                }
-            };
-            if proxy {
-                let arranged = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c.inner, Pipeline, "Arrange");
-                let reduced = reduce_with_tactic::<_, Spine<u64, isize>, _>(arranged, "ProxyReduce", ProxyReduceTactic::new(VecReduceBackend::new(count)));
-                reduced.stream.probe_with(&probe);
-            } else {
-                c.reduce(count).inner.probe_with(&probe);
-            }
-            input
-        });
-
-        let start = Instant::now();
-        for k in 0..n {
-            input.update((k, k % 5), 1);
-        }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) {
-            worker.step();
-        }
-        let load = start.elapsed();
-
-        // Warm up with unmeasured incremental rounds: the load leaves amortized
-        // trace-maintenance debt (compaction-driven merges) that the first couple
-        // thousand rounds pay down; the measured phase is steady state.
-        let warmup = 5_000;
-        let mut timer = Instant::now();
-        for t in 1..=(warmup + rounds) {
-            if t == warmup + 1 { timer = Instant::now(); }
-            input.update((t % 97, 100 + t), 1);
-            input.advance_to(t + 1);
-            input.flush();
-            while probe.less_than(input.time()) {
-                worker.step();
-            }
-        }
-        (load, timer.elapsed())
-    })
-}
-
-fn bench_join(n: u64, rounds: u64, proxy: bool) -> (std::time::Duration, std::time::Duration) {
-    use std::time::Instant;
-    use timely::dataflow::operators::probe::{Handle, Probe};
-
-    timely::execute_directly(move |worker| {
-        let probe = Handle::new();
-        let (mut left, mut right) = worker.dataflow::<u64, _, _>(|scope| {
-            let (left, c0) = scope.new_collection::<(u64, u64), isize>();
-            let (right, c1) = scope.new_collection::<(u64, u64), isize>();
-            if proxy {
-                let a0 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c0.inner, Pipeline, "Arrange0");
-                let a1 = arrange_core::<_, _, Chunker<u64, u64>, Batcher<u64, u64>, Bldr<u64, u64>, Spine<u64, u64>>(c1.inner, Pipeline, "Arrange1");
-                let tactic = ProxyJoinTactic::new(VecJoinBackend::new(|k: &u64, v0: &u64, v1: &u64| (*k, (*v0, *v1))));
-                let joined = join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<(JoinOut, u64, isize)>>>(a0, a1, tactic);
-                joined.probe_with(&probe);
-            } else {
-                c0.join(c1).inner.probe_with(&probe);
-            }
-            (left, right)
-        });
-
-        let start = Instant::now();
-        for k in 0..n {
-            left.update((k, k), 1);
-            right.update((k, 2 * k), 1);
-        }
-        left.advance_to(1);
-        right.advance_to(1);
-        left.flush();
-        right.flush();
-        while probe.less_than(left.time()) {
-            worker.step();
-        }
-        let load = start.elapsed();
-
-        // Warm up with unmeasured incremental rounds (see bench_reduce).
-        let warmup = 5_000;
-        let mut timer = Instant::now();
-        for t in 1..=(warmup + rounds) {
-            if t == warmup + 1 { timer = Instant::now(); }
-            left.update((t % 97, 100 + t), 1);
-            left.advance_to(t + 1);
-            right.advance_to(t + 1);
-            left.flush();
-            right.flush();
-            while probe.less_than(left.time()) {
-                worker.step();
-            }
-        }
-        (load, timer.elapsed())
-    })
-}
-
-#[test]
-#[ignore = "wall-clock benchmark; run --release with --ignored --nocapture"]
-fn bench_wall_clock_vs_row() {
-    for &n in &[10_000u64, 100_000, 1_000_000] {
-        let rounds = 1_000;
-        let (row_l, row_i) = bench_reduce(n, rounds, false);
-        let (px_l, px_i) = bench_reduce(n, rounds, true);
-        eprintln!(
-            "reduce n={n:>9}: load row {row_l:>10.2?} proxy {px_l:>10.2?} ({:>5.2}x) | {rounds} steady single-key rounds row {row_i:>10.2?} proxy {px_i:>10.2?} ({:>5.2}x)",
-            px_l.as_secs_f64() / row_l.as_secs_f64(),
-            px_i.as_secs_f64() / row_i.as_secs_f64(),
-        );
-        let (row_l, row_i) = bench_join(n, rounds, false);
-        let (px_l, px_i) = bench_join(n, rounds, true);
-        eprintln!(
-            "join   n={n:>9}: load row {row_l:>10.2?} proxy {px_l:>10.2?} ({:>5.2}x) | {rounds} steady single-key rounds row {row_i:>10.2?} proxy {px_i:>10.2?} ({:>5.2}x)",
-            px_l.as_secs_f64() / row_l.as_secs_f64(),
-            px_i.as_secs_f64() / row_i.as_secs_f64(),
-        );
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Scaling: one key, many distinct times, in a single batch (the shapes of the
-// row suite's `reduce_scaling` / `join_scaling` tests). These are linear-ish
-// only if the tactics replay histories with meet-advancement; a per-moment
-// rescan or a naive per-key cross product is quadratic and would hang here.
-// ---------------------------------------------------------------------------
-
-#[test]
-fn proxy_reduce_scaling() {
-    use timely::dataflow::operators::ToStream;
-    use timely::dataflow::operators::capture::Extract;
-    use timely::dataflow::operators::vec::Map;
-    use differential_dataflow::AsCollection;
-
-    let scale = 100_000u64;
-    let data = timely::example(move |scope| {
-        let arranged = arrange_core::<_, _, Chunker<(), ()>, Batcher<(), ()>, Bldr<(), ()>, Spine<(), ()>>(
-            (0..1)
-                .to_stream(scope)
-                .flat_map(move |_| (0..scale).map(|i| ((((), ())), i, 1)))
-                .as_collection()
-                .inner,
-            Pipeline,
-            "Arrange",
-        );
-        let count = |_k: &(), input: &[(&(), isize)], output: &mut Vec<(isize, isize)>| {
-            let c: isize = input.iter().map(|(_, d)| *d).sum();
-            if c > 0 {
-                output.push((c, 1));
-            }
-        };
-        let tactic = ProxyReduceTactic::new(VecReduceBackend::new(count));
-        let reduced = reduce_with_tactic::<_, Spine<(), isize>, _>(arranged, "ProxyReduce", tactic);
-        reduced.as_collection(|_k, v| *v).inner.capture()
-    });
-    let extracted: Vec<_> = data.extract();
-    assert_eq!(extracted.len(), 1);
-}
-
-#[test]
-fn proxy_join_scaling() {
-    use timely::dataflow::operators::ToStream;
-    use timely::dataflow::operators::capture::Extract;
-    use timely::dataflow::operators::vec::Map;
-    use differential_dataflow::AsCollection;
-
-    let scale = 100_000u64;
-    let data = timely::example(move |scope| {
-        let counts = (0..1)
-            .to_stream(scope)
-            .flat_map(move |_| (0..scale).map(|i| ((), i, 1)))
-            .as_collection()
-            .count();
-        let odds = counts.clone().filter(|x| x.1 % 2 == 1).inner;
-        let evens = counts.filter(|x| x.1 % 2 == 0).inner;
-        let a0 = arrange_core::<_, _, Chunker<(), isize>, Batcher<(), isize>, Bldr<(), isize>, Spine<(), isize>>(odds, Pipeline, "Odds");
-        let a1 = arrange_core::<_, _, Chunker<(), isize>, Batcher<(), isize>, Bldr<(), isize>, Spine<(), isize>>(evens, Pipeline, "Evens");
-        let tactic = ProxyJoinTactic::new(VecJoinBackend::new(|_k: &(), v0: &isize, v1: &isize| (*v0, *v1)));
-        join_with_tactic::<_, _, _, CapacityContainerBuilder<Vec<((isize, isize), u64, isize)>>>(a0, a1, tactic).capture()
-    });
-    // Odd and even counts are never simultaneously present: the join is empty.
-    let total: isize = data
-        .extract()
-        .iter()
-        .flat_map(|(_, v)| v.iter().map(|(_, _, d)| *d))
-        .sum();
-    assert_eq!(total, 0);
-}
-
-/// The formal model's `scenario1_cancels`, realized against a compacted trace (the SCC
-/// field bug): compaction legally advances a stored `+1` onto a novel `−1`'s exact
-/// `(value, time)`, so the two cancel in the merged input presentation — but the batch
-/// still owes a change there (the standing output must be retracted). Interesting-time
-/// seeds must come from the batch's own support (`seedSet = b.support ∪ pending`), never
-/// from a time-filter over the merged view.
-#[test]
-fn proxy_reduce_seeds_survive_compaction_cancellation() {
-    let count = |_k: &u64, input: &[(&u64, isize)], output: &mut Vec<(isize, isize)>| {
-        let c: isize = input.iter().map(|(_, d)| *d).sum();
-        if c > 0 {
-            output.push((c, 1));
-        }
-    };
-    let mut tactic = ProxyReduceTactic::new(VecReduceBackend::new(count));
-
-    // Retire 1: (key 1, value 10) +1 at (0,1); interval [(0,0), {(1,1)}).
-    let batch1 = pbatch(vec![((1u64, 10u64), pt(0, 1), 1)], vec![pt(0, 0)], vec![pt(1, 1)]);
-    let lower1 = Antichain::from_elem(pt(0, 0));
-    let upper1 = Antichain::from_elem(pt(1, 1));
-    let held1 = Antichain::from_elem(pt(0, 1));
-    let (produced1, _) = tactic.retire(vec![], vec![], vec![batch1], &lower1, &upper1, &held1);
-    assert_eq!(produced1.len(), 1);
-    assert_eq!(pbatch_rows(&produced1[0].1), vec![((1, 1isize), pt(0, 1), 1)]);
-
-    // Between retires the trace compacts to since = {(1,1)} — legal, since every later
-    // evaluation time is at or beyond it. advance_by maps (0,1) → (1,1) in both the
-    // source and the output trace.
-    let source_compacted = pbatch(vec![((1u64, 10u64), pt(1, 1), 1)], vec![pt(0, 0)], vec![pt(1, 1)]);
-    let output_compacted = pbatch(vec![((1u64, 1isize), pt(1, 1), 1)], vec![pt(0, 0)], vec![pt(1, 1)]);
-
-    // Retire 2: the novel batch retracts the input at exactly (1,1) — the time the
-    // compacted stored record now occupies. Merged and consolidated, they cancel; the
-    // batch support still holds (1,1), and the owed output retraction hangs on it.
-    let batch2 = pbatch(vec![((1u64, 10u64), pt(1, 1), -1)], vec![pt(1, 1)], vec![]);
-    let lower2 = upper1.clone();
-    let upper2 = Antichain::new();
-    let held2 = Antichain::from_elem(pt(1, 1));
-    let (produced2, frontier2) = tactic.retire(
-        vec![source_compacted],
-        vec![output_compacted],
-        vec![batch2],
-        &lower2,
-        &upper2,
-        &held2,
-    );
-    let rows: Vec<_> = produced2.iter().flat_map(|(_, b)| pbatch_rows(b)).collect();
-    assert_eq!(
-        rows,
-        vec![((1, 1isize), pt(1, 1), -1)],
-        "the standing count must be retracted at (1,1); an empty result means the seed was cancelled out of the merged presentation"
-    );
-    assert!(frontier2.is_empty());
-}
diff --git a/differential-dataflow/tests/reduce_reference.rs b/differential-dataflow/tests/reduce_reference.rs
index 9bb3c2c4c..6046660ae 100644
--- a/differential-dataflow/tests/reduce_reference.rs
+++ b/differential-dataflow/tests/reduce_reference.rs
@@ -96,42 +96,6 @@ where
     .as_collection(|k, v| (k.clone(), v.clone()))
 }
 
-// Same shape as `reduce_reference`, but driven by the INT_PROXY `ProxyReduceTactic` + the reference
-// (Vec) value backend over `VecChunk` arrangements — i.e. the int_proxy reduce with NO corgi. Used to
-// isolate the int_proxy tactic from the corgi backend on SCC.
-fn reduce_int_proxy<'scope, Ti, K, V, R, V2, R2, L>(
-    collection: VecCollection<'scope, Ti, (K, V), R>,
-    logic: L,
-) -> VecCollection<'scope, Ti, (K, V2), R2>
-where
-    Ti: timely::progress::Timestamp + Lattice + Ord,
-    K: ExchangeData + Hashable + std::hash::Hash + Ord,
-    V: ExchangeData + std::hash::Hash + Ord,
-    R: ExchangeData + Semigroup + Ord,
-    V2: Data + std::hash::Hash + Ord,
-    R2: ExchangeData + Ord + Abelian,
-    L: FnMut(&K, &[(&V, R)], &mut Vec<(V2, R2)>) + 'static,
-{
-    use differential_dataflow::operators::arrange::arrangement::arrange_core;
-    use differential_dataflow::operators::int_proxy::ProxyReduceTactic;
-    use differential_dataflow::operators::int_proxy::reference::VecReduceBackend;
-    use differential_dataflow::operators::reduce::reduce_with_tactic;
-    use differential_dataflow::trace::chunk::vec::{ChunkBatcher, ChunkBuilder, ChunkSpine, VecChunk};
-    use differential_dataflow::trace::implementations::chunker::ContainerChunker;
-    use timely::dataflow::channels::pact::Pipeline;
-
-    let arranged = arrange_core::<
-        _, _,
-        ContainerChunker<VecChunk<K, V, Ti, R>>,
-        ChunkBatcher<K, V, Ti, R>,
-        ChunkBuilder<K, V, Ti, R>,
-        ChunkSpine<K, V, Ti, R>,
-    >(collection.inner, Pipeline, "Arrange: IntProxy");
-    let tactic = ProxyReduceTactic::new(VecReduceBackend::new(logic));
-    let reduced = reduce_with_tactic::<_, ChunkSpine<K, V2, Ti, R2>, _>(arranged, "IntProxyReduce", tactic);
-    reduced.as_collection(|k, v| (k.clone(), v.clone()))
-}
-
 // A random input: `((key, val), Pair(a, b), diff)`, diffs ±1 so updates cancel.
 fn random_input(seed: usize, n: usize, keys: u64, vals: u64, span: u64) -> Vec<((u64, u64), Time, isize)> {
     let s: &[usize] = &[seed, 7, 13, 29];
@@ -266,8 +230,8 @@ fn bfs_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
         let (mut roots, mut edges) = worker.dataflow::<usize, _, _>(|scope| {
             let (root_input, roots) = scope.new_collection();
             let (edge_input, edges) = scope.new_collection();
-            let via_cursor    = bfs(edges.clone(), roots.clone(), 0);
-            let via_reference = bfs(edges, roots, 1);
+            let via_cursor    = bfs(edges.clone(), roots.clone(), false);
+            let via_reference = bfs(edges, roots, true);
             via_cursor.assert_eq(via_reference);
             (root_input, edge_input)
         });
@@ -284,7 +248,7 @@ fn bfs_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
     });
 }
 
-fn bfs<'scope, T>(edges: VecCollection<'scope, T, Edge>, roots: VecCollection<'scope, T, Node>, mode: u8) -> VecCollection<'scope, T, (Node, usize)>
+fn bfs<'scope, T>(edges: VecCollection<'scope, T, Edge>, roots: VecCollection<'scope, T, Node>, reference: bool) -> VecCollection<'scope, T, (Node, usize)>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
@@ -293,9 +257,7 @@ where
         let edges = edges.enter(scope);
         let nodes = nodes.enter(scope);
         let combined = inner.join_map(edges, |_k, l, d| (*d, l + 1)).concat(nodes);
-        if mode == 2 {
-            reduce_int_proxy(combined, |_, s, t| t.push((*s[0].0, 1)))
-        } else if mode == 1 {
+        if reference {
             reduce_reference(combined, |_, s, t| t.push((*s[0].0, 1)))
         } else {
             combined.reduce(|_, s, t| t.push((*s[0].0, 1)))
@@ -308,19 +270,12 @@ where
 // iterative label propagation whose `reduce` is the tactic under test. The doubly-nested product
 // time produces far more synthetic interesting times than BFS, over joins / concats / filters.
 
-#[test] fn scc_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4], 1); }
-#[test] fn scc_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8], 1); }
-#[test] fn scc_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8], 1); }
-#[test] fn scc_sweep()  { for s in 0u8 .. 6 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29], 1); } }
+#[test] fn scc_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4]); }
+#[test] fn scc_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8]); }
+#[test] fn scc_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8]); }
+#[test] fn scc_sweep()  { for s in 0u8 .. 6 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29]); } }
 
-// int_proxy reduce (no corgi) vs cursor: does the int_proxy TACTIC diverge on SCC depth?
-#[test] fn scc_int_proxy_tiny_a() { scc_differential(6, 12, 4, &[1, 2, 3, 4], 2); }
-#[test] fn scc_int_proxy_tiny_b() { scc_differential(8, 16, 4, &[5, 6, 7, 8], 2); }
-#[test] fn scc_int_proxy_12_24()  { scc_differential(12, 24, 5, &[2, 4, 6, 8], 2); }
-#[test] fn scc_int_proxy_sweep()  { for s in 0u8 .. 12 { scc_differential(15, 30, 5, &[s as usize, (s as usize) + 7, 13, 29], 2); } }
-#[test] fn scc_int_proxy_big()    { for s in 0u8 .. 20 { scc_differential(50, 120, 8, &[s as usize, 3, 11, 23], 2); } }
-
-fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize], mode: u8) {
+fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize]) {
     let mut rng1: StdRng = SeedableRng::from_seed(seed);
     let mut rng2: StdRng = SeedableRng::from_seed(seed);
     let mut edge_list: Vec<((usize, usize), usize, isize)> = Vec::new();
@@ -334,9 +289,9 @@ fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize], m
         let mut edges_list = edge_list.clone();
         let mut edges = worker.dataflow::<usize, _, _>(|scope| {
             let (edge_input, edges) = scope.new_collection();
-            let via_cursor = scc(edges.clone(), 0);
-            let via_mode   = scc(edges, mode);
-            via_cursor.assert_eq(via_mode);
+            let via_cursor    = scc(edges.clone(), false);
+            let via_reference = scc(edges, true);
+            via_cursor.assert_eq(via_reference);
             edge_input
         });
         edges_list.sort_by(|x, y| y.1.cmp(&x.1));
@@ -351,7 +306,7 @@ fn scc_differential(nodes: usize, edges: usize, rounds: usize, seed: &[usize], m
 
 // The subset of edges within a strongly connected component, mirroring
 // `algorithms::graphs::scc::strongly_connected` but with the propagation `reduce` swappable.
-fn scc<'scope, T>(graph: VecCollection<'scope, T, Edge>, mode: u8) -> VecCollection<'scope, T, Edge>
+fn scc<'scope, T>(graph: VecCollection<'scope, T, Edge>, reference: bool) -> VecCollection<'scope, T, Edge>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
@@ -359,19 +314,19 @@ where
     graph.iterate(move |scope, inner| {
         let edges = graph2.enter(scope);
         let trans = edges.clone().map(|(a, b)| (b, a));
-        let trimmed = trim_edges(inner, edges, mode);
-        trim_edges(trimmed, trans, mode)
+        let trimmed = trim_edges(inner, edges, reference);
+        trim_edges(trimmed, trans, reference)
     })
 }
 
 // Keep only edges whose endpoints propagate to the same label; run twice (forward then transposed)
 // this converges on the SCC edges.
-fn trim_edges<'scope, T>(cycle: VecCollection<'scope, T, Edge>, edges: VecCollection<'scope, T, Edge>, mode: u8) -> VecCollection<'scope, T, Edge>
+fn trim_edges<'scope, T>(cycle: VecCollection<'scope, T, Edge>, edges: VecCollection<'scope, T, Edge>, reference: bool) -> VecCollection<'scope, T, Edge>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
     let nodes = edges.clone().map(|(_a, b)| (b, b));
-    let labels = propagate(cycle, nodes, mode);
+    let labels = propagate(cycle, nodes, reference);
     edges.join_map(labels.clone(), |&src, &dst, &l1| (dst, (src, l1)))
          .join_map(labels, |&dst, &(src, l1), &l2| ((src, dst), (l1, l2)))
          .filter(|(_, (l1, l2))| l1 == l2)
@@ -380,7 +335,7 @@ where
 
 // Forward min-label propagation along `edges` from per-node seed labels; the inner `reduce` (min
 // label per node) is the tactic under test.
-fn propagate<'scope, T>(edges: VecCollection<'scope, T, Edge>, nodes: VecCollection<'scope, T, (Node, Node)>, mode: u8) -> VecCollection<'scope, T, (Node, Node)>
+fn propagate<'scope, T>(edges: VecCollection<'scope, T, Edge>, nodes: VecCollection<'scope, T, (Node, Node)>, reference: bool) -> VecCollection<'scope, T, (Node, Node)>
 where
     T: timely::progress::Timestamp + Lattice + Ord,
 {
@@ -389,9 +344,7 @@ where
         let edges = edges.enter(scope);
         let seed = seed.enter(scope);
         let combined = inner.join_map(edges, |&_n, &l, &d| (d, l)).concat(seed);
-        if mode == 2 {
-            reduce_int_proxy(combined, |_, s, t| t.push((*s[0].0, 1)))
-        } else if mode == 1 {
+        if reference {
             reduce_reference(combined, |_, s, t| t.push((*s[0].0, 1)))
         } else {
             combined.reduce(|_, s, t| t.push((*s[0].0, 1)))
diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index 82d40e1df..afb904bca 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -212,7 +212,7 @@ impl Backend for CorgiBackend {
         // corgi columns directly into a `CorgiContainer` (via `give_container`) — the output stream is
         // column-native, so there is no row round-trip / no `JoinToCorgi` unary.
         let tactic = CorgiJoinTactic::new(projection.key.clone(), projection.val.clone());
-        join_with_tactic::<_, _, _, CapacityContainerBuilder<CC>>(l, r, tactic).as_collection()
+        join_with_tactic::<_, _, _, CC>(l, r, tactic).as_collection()
     }
 
     fn reduce<'s>(a: Self::Arr<'s>, reducer: &Reducer) -> Self::Arr<'s> {
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi_join.rs
index 96dcbbdeb..40a3417c1 100644
--- a/interactive/src/corgi_join.rs
+++ b/interactive/src/corgi_join.rs
@@ -9,16 +9,12 @@
 //! THIS ITERATION: struct + `defer` + a stub `work`, compiling as a valid `JoinTactic` (validates the
 //! generic-bound wiring). The join COMPUTE is already validated in `examples/corgi_join_mechanism.rs`.
 
-use std::collections::VecDeque;
 use std::rc::Rc;
 
-use timely::ContainerBuilder;
-use timely::dataflow::operators::generic::OutputBuilderSession;
-use timely::dataflow::operators::Capability;
 use timely::progress::Timestamp;
 
 use differential_dataflow::lattice::Lattice;
-use differential_dataflow::operators::join::{EffortBuilder, Fresh, JoinTactic};
+use differential_dataflow::operators::join::{Fresh, JoinTactic};
 
 use corgi::arrange::{find_ranges, gather};
 use corgi::Value as CValue;
@@ -32,66 +28,38 @@ use crate::ir::Diff;
 use crate::parse::Term;
 type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 
-/// A deferred bilinear join unit: a fresh batch list joined against the accumulated other side.
-/// (The accumulated-side advance-by-meet — an output-neutral consolidation optimization — is deferred;
-/// `merge_one` consolidates each side without advancing, which is correct.)
-struct CorgiDeferred<T: Timestamp + Lattice> {
-    left: Vec<CBatch<T>>,
-    right: Vec<CBatch<T>>,
-    /// Which side carried the fresh batch; the other (accumulated) side is restricted to the fresh
-    /// side's keys rather than fully flattened.
-    fresh: Fresh,
-    capability: Capability<T>,
-}
-
 /// Cursor-less corgi join tactic. Holds the projection `Term`s (`Var(0)=key`, `Var(1)=val0`,
 /// `Var(2)=val1`); compiled to a corgi graph per work-unit using the matched columns' shapes (so
 /// `Spread` resolves against the actual key/val arities).
 pub struct CorgiJoinTactic<T: Timestamp + Lattice> {
     key: Term,
     val: Term,
-    todo0: VecDeque<CorgiDeferred<T>>, // fresh on input0
-    todo1: VecDeque<CorgiDeferred<T>>, // fresh on input1
+    _t: std::marker::PhantomData<T>,
 }
 
 impl<T: Timestamp + Lattice> CorgiJoinTactic<T> {
     pub fn new(key: Term, val: Term) -> Self {
-        CorgiJoinTactic { key, val, todo0: VecDeque::new(), todo1: VecDeque::new() }
+        CorgiJoinTactic { key, val, _t: std::marker::PhantomData }
     }
 }
 
-impl<T, CB> JoinTactic<CBatch<T>, CBatch<T>, CB> for CorgiJoinTactic<T>
+impl<T> JoinTactic<CBatch<T>, CBatch<T>, CorgiContainer<T, Diff>> for CorgiJoinTactic<T>
 where
     T: Timestamp + Lattice,
-    CB: ContainerBuilder<Container = CorgiContainer<T, Diff>>,
 {
-    fn defer(&mut self, input0: Vec<CBatch<T>>, input1: Vec<CBatch<T>>, fresh: Fresh, capability: Capability<T>) {
-        let queue = match &fresh {
-            Fresh::Input0 => &mut self.todo0,
-            Fresh::Input1 => &mut self.todo1,
-        };
-        queue.push_back(CorgiDeferred { left: input0, right: input1, fresh, capability });
-    }
-
-    fn work(&mut self, fuel: &mut isize, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>) {
-        // Eager (correctness-first): run every queued unit fully. Fuel budgeting is a later
-        // refinement; leaving `fuel` non-negative signals "complete" to the operator.
-        while let Some(unit) = self.todo0.pop_front() {
-            run_unit(unit, &self.key, &self.val, output);
-        }
-        while let Some(unit) = self.todo1.pop_front() {
-            run_unit(unit, &self.key, &self.val, output);
-        }
-        *fuel = 0;
+    /// One bilinear unit → its output container. The operator (`join_with_tactic`) drives capabilities
+    /// and fuel by draining the returned iterator; `meet` (compaction) is ignored (correctness-first,
+    /// like the reference identity backend — output times are just less compact, never wrong).
+    fn prep(&mut self, input0: Vec<CBatch<T>>, input1: Vec<CBatch<T>>, fresh: Fresh, _meet: T) -> Box<dyn Iterator<Item = CorgiContainer<T, Diff>>> {
+        Box::new(run_unit(input0, input1, fresh, &self.key, &self.val).into_iter())
     }
 }
 
 /// Join one deferred bilinear unit: merge-join the two runs by key over corgi columns, cross-product
 /// matched val runs (lattice time-join + diff-multiply), project via corgi, emit at the capability.
-fn run_unit<T, CB>(unit: CorgiDeferred<T>, key: &Term, val: &Term, output: &mut OutputBuilderSession<T, EffortBuilder<CB>>)
+fn run_unit<T>(left_b: Vec<CBatch<T>>, right_b: Vec<CBatch<T>>, fresh: Fresh, key: &Term, val: &Term) -> Option<CorgiContainer<T, Diff>>
 where
     T: Timestamp + Lattice,
-    CB: ContainerBuilder<Container = CorgiContainer<T, Diff>>,
 {
     // Materialize the FRESH (delta-sized) side whole; then present the ACCUMULATED side. When it is
     // meaningfully larger than the fresh delta (recursive joins against a built-up trace), probe it
@@ -106,15 +74,15 @@ where
             flatten_batches(acc)
         }
     };
-    let (left, right) = match unit.fresh {
+    let (left, right) = match fresh {
         Fresh::Input0 => {
-            let Some(left) = flatten_batches(&unit.left) else { return };
-            let Some(right) = accumulated(&unit.right, &left) else { return };
+            let left = flatten_batches(&left_b)?;
+            let right = accumulated(&right_b, &left)?;
             (left, right)
         }
         Fresh::Input1 => {
-            let Some(right) = flatten_batches(&unit.right) else { return };
-            let Some(left) = accumulated(&unit.left, &right) else { return };
+            let right = flatten_batches(&right_b)?;
+            let left = accumulated(&left_b, &right)?;
             (left, right)
         }
     };
@@ -135,7 +103,7 @@ where
         }
     }
     if li.is_empty() {
-        return;
+        return None;
     }
 
     // gather matched (key, val0, val1) columns, run the projection corgi program, untranscode.
@@ -148,8 +116,6 @@ where
     let mut cols = projected.into_prod("corgi join projection");
     let nv = cols.pop().unwrap();
     let nk = cols.pop().unwrap();
-    // Emit the projection's corgi columns directly as a CorgiContainer via `give_container` — no
-    // untranscode-to-rows + re-transcode. The output stream is column-native.
-    let mut container = CorgiContainer { keys: nk, vals: nv, times: ot, diffs: od };
-    output.session_with_builder(&unit.capability).give_container(&mut container);
+    // The projection's corgi columns directly as a column-native CorgiContainer (no untranscode).
+    Some(CorgiContainer { keys: nk, vals: nv, times: ot, diffs: od })
 }
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 7bd1e4998..d275a6805 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -33,10 +33,11 @@ use std::rc::Rc;
 use timely::progress::Timestamp;
 
 use differential_dataflow::lattice::Lattice;
+use differential_dataflow::consolidation::consolidate_updates;
 use differential_dataflow::trace::Description;
 use differential_dataflow::trace::chunk::ChunkBatch;
-use differential_dataflow::trace::chunk::int_proxy::ProxyChunk;
-use differential_dataflow::operators::int_proxy::ProxyReduceBackend;
+use differential_dataflow::operators::int_proxy::ProxyBridge;
+use differential_dataflow::operators::int_proxy::reduce::{ProxyReduceBackend, ReduceInstance, ReduceWindow};
 
 use corgi::arrange::{gather, gather_lanes, hash_rows, sort_blocks};
 use corgi::{Bounds, Value as CValue};
@@ -67,10 +68,15 @@ type IdMap = HashMap<u64, usize, BuildHasherDefault<IdHasher>>;
 /// id→row-index maps; nothing carries a `DValue`.
 pub struct CorgiReduceBackend<T> {
     reducer: Reducer,
-    /// Input value column aligned with the current input presentation's records (for Min/Collect).
+    /// Input value column for the current window, indexed by `in_index` (for Min/Collect resolution).
     in_vals: CValue,
-    /// The input presentation's `value_id` per record (Min reuses an input value's id).
-    in_value_ids: Vec<u64>,
+    /// Input `value_id → row` in `in_vals` for the current window (reduce-time resolution; first row
+    /// wins, so equal values — which share a content-hash `value_id` — resolve to one representative).
+    in_index: IdMap,
+    /// Output tiling for `begin`/`emit`/`finish`: the tile descriptions, and per-tile accumulated
+    /// output rows `(key row, value row, time, diff)` (pool indices, gathered into columns at `finish`).
+    tiles: Vec<Description<T>>,
+    tile_rows: Vec<(Vec<usize>, Vec<usize>, Vec<T>, Vec<Diff>)>,
     /// Key-resolution pool for the current retire: `key_hash → row index` into the concatenation of
     /// `key_blocks` (representative keys from the input + output presentations).
     key_index: IdMap,
@@ -89,7 +95,9 @@ impl<T> CorgiReduceBackend<T> {
         CorgiReduceBackend {
             reducer,
             in_vals: CValue::Unit(0),
-            in_value_ids: Vec::new(),
+            in_index: IdMap::default(),
+            tiles: Vec::new(),
+            tile_rows: Vec::new(),
             key_index: IdMap::default(),
             key_blocks: Vec::new(),
             key_len: 0,
@@ -100,7 +108,7 @@ impl<T> CorgiReduceBackend<T> {
         }
     }
 
-    /// Clear the resolution pools at the start of a retire.
+    /// Clear the resolution pools at the start of a retire (called from `next_window`'s first call).
     fn reset_pools(&mut self) {
         self.key_index.clear();
         self.key_blocks.clear();
@@ -275,7 +283,7 @@ where
                 let (perm, _) = sort_blocks(&labels, &cand_col);
                 let min_reps: Vec<usize> = block_starts.iter().map(|&lo| cand_reps[perm[lo]]).collect();
                 let col = gather(&self.in_vals, &min_reps);
-                out_ids = min_reps.iter().map(|&r| self.in_value_ids[r]).collect();
+                out_ids = hash_rows(&col);
                 self.register_vals(col, &out_ids);
             }
             Reducer::Collect => {
@@ -335,13 +343,12 @@ where
     type RIn = Diff;
     type ROut = Diff;
 
-    fn seed_times(&self, novel: &[CBatch<T>]) -> Vec<(u64, T)> {
-        // The batch's raw (key_hash, time) support — hash the novel KEY columns only (no value work,
-        // no consolidation), one entry per record, sorted by key_hash. Seeds may over-derive (a
-        // non-changing seed yields a zero delta), so this superset of b.support suffices; the tactic
-        // reads only the times. Never merged with stored history, so no compacted record cancels a seed.
+    fn seed_times(&self, instance: &ReduceInstance<'_, CBatch<T>, CBatch<T>>) -> Vec<(u64, T)> {
+        // The batch's raw (key_hash, time) support — hash the novel KEY columns only, one entry per
+        // record, sorted by key_hash. Seeds may over-derive (a non-changing seed yields a zero delta),
+        // so this superset of b.support suffices; `instance.lower` is not applied (see ReduceInstance).
         let mut out: Vec<(u64, T)> = Vec::new();
-        for ch in chunks_of(novel) {
+        for ch in chunks_of(instance.input_batches) {
             let kh = hash_rows(ch.keys());
             for (h, t) in kh.into_iter().zip(ch.times()) {
                 out.push((h, t.clone()));
@@ -351,67 +358,118 @@ where
         out
     }
 
-    fn present_input(&mut self, history: &[CBatch<T>], novel: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
+    fn begin(&mut self, tiles: &[Description<T>]) {
+        // Open a tiled output session for this retire; reset the per-retire resolution pools.
         self.reset_pools();
+        self.tiles = tiles.to_vec();
+        self.tile_rows = (0..tiles.len()).map(|_| (Vec::new(), Vec::new(), Vec::new(), Vec::new())).collect();
+    }
 
-        // History ∪ novel, restricted to the changed keys (a columnar semijoin). Novel keys are all in
-        // `keys` (the delta's keys, as `present_novel` reports them), so this keeps the novel side whole
-        // and filters the accumulated history to the changed keys. The seeds come from `present_novel`;
-        // this merged run is used only for accumulation (compaction here is accumulation-preserving).
-        let mut chunks = chunks_of(novel);
-        chunks.extend(chunks_of(history));
-        let (keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| keys.binary_search(&h).is_ok());
+    fn next_window(&mut self, instance: &ReduceInstance<'_, CBatch<T>, CBatch<T>>, changed: &[u64], cursor: &mut usize) -> Option<ReduceWindow<T, Diff, Diff>> {
+        // Single window: present ALL remaining changed keys at once (bounded-memory windowing is a
+        // later refinement). `changed` is ascending, so `binary_search` is the changed-key filter.
+        if *cursor >= changed.len() {
+            return None;
+        }
+        let keys: Vec<u64> = changed[*cursor..].to_vec();
+        *cursor = changed.len();
+        let present = |chunks: &[&CorgiChunk<T, Diff>]| collect_present(chunks, |h| keys.binary_search(&h).is_ok());
 
-        if khs.is_empty() {
+        // Input presentation: accumulated history ∪ novel delta, restricted to the window's keys.
+        // value_id = content hash of the value (equal values share an id → the tactic nets them);
+        // `in_index` resolves an id back to a representative in_vals row for `reduce_corrections`.
+        let mut in_chunks = chunks_of(instance.input_batches);
+        in_chunks.extend(chunks_of(instance.source_batches));
+        let (in_keys, in_vals, in_khs, in_times, in_diffs) = present(&in_chunks);
+        self.in_index = IdMap::default();
+        let input: ProxyBridge<T, Diff> = if in_khs.is_empty() {
             self.in_vals = CValue::Unit(0);
-            self.in_value_ids = Vec::new();
-            return ProxyChunk::default();
-        }
-        let vids = hash_rows(&vals_col);
-        let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
-        self.in_vals = gather(&vals_col, &reps);
-        self.in_value_ids = chunk.value_ids().to_vec();
-        // Register representative keys (aligned with the sorted presentation) for materialize.
-        let rep_keys = gather(&keys_col, &reps);
-        self.register_keys(rep_keys, chunk.key_hashes());
-        chunk
-    }
+            Vec::new()
+        } else {
+            let vids = hash_rows(&in_vals);
+            for (r, &vid) in vids.iter().enumerate() { self.in_index.entry(vid).or_insert(r); }
+            self.in_vals = in_vals;
+            self.register_keys(in_keys, &in_khs);
+            let mut b: ProxyBridge<T, Diff> =
+                (0..in_khs.len()).map(|i| ((in_khs[i], vids[i]), in_times[i].clone(), in_diffs[i])).collect();
+            consolidate_updates(&mut b);
+            b
+        };
 
-    fn present_output(&mut self, batches: &[CBatch<T>], keys: &[u64]) -> ProxyChunk<T, Diff> {
-        let chunks = chunks_of(batches);
-        let (keys_col, vals_col, khs, times, diffs) = collect_present(&chunks, |h| keys.binary_search(&h).is_ok());
-        if khs.is_empty() {
-            return ProxyChunk::default();
-        }
-        let vids = hash_rows(&vals_col);
-        let (chunk, reps) = ProxyChunk::from_unsorted(khs, vids, times, diffs);
-        // Register representative output keys and values (aligned with the sorted presentation).
-        let rep_keys = gather(&keys_col, &reps);
-        let rep_vals = gather(&vals_col, &reps);
-        self.register_keys(rep_keys, chunk.key_hashes());
-        self.register_vals(rep_vals, chunk.value_ids());
-        chunk
+        // Output-history presentation, same keys (register keys + values for correction resolution).
+        let (o_keys, o_vals, o_khs, o_times, o_diffs) = present(&chunks_of(instance.output_batches));
+        let output: ProxyBridge<T, Diff> = if o_khs.is_empty() {
+            Vec::new()
+        } else {
+            let vids = hash_rows(&o_vals);
+            self.register_keys(o_keys, &o_khs);
+            self.register_vals(o_vals, &vids);
+            let mut b: ProxyBridge<T, Diff> =
+                (0..o_khs.len()).map(|i| ((o_khs[i], vids[i]), o_times[i].clone(), o_diffs[i])).collect();
+            consolidate_updates(&mut b);
+            b
+        };
+
+        Some(ReduceWindow { keys, input, output })
     }
 
-    fn reduce(&mut self, _key_hash: u64, input: &[(usize, Diff)]) -> Vec<(u64, Diff)> {
-        self.reduce_brackets(&[input.len()], input).0
+    fn reduce_corrections(&mut self, keys: &[u64], in_ends: &[usize], input: &[(u64, Diff)], out_ends: &[usize], output: &[(u64, Diff)]) -> (Vec<(u64, Diff)>, Vec<usize>) {
+        // Resolve input value_ids to `in_vals` rows, reduce (desired output), then difference the
+        // desired against the presented current output per key: correction = desired − current.
+        let in_rows: Vec<(usize, Diff)> = input.iter()
+            .map(|&(vid, d)| (*self.in_index.get(&vid).expect("input value_id presented this window"), d))
+            .collect();
+        let (desired, desired_ends) = self.reduce_brackets(in_ends, &in_rows);
+
+        let mut corr: Vec<(u64, Diff)> = Vec::new();
+        let mut corr_ends: Vec<usize> = Vec::with_capacity(keys.len());
+        let (mut ds, mut os) = (0usize, 0usize);
+        for i in 0..keys.len() {
+            let (de, oe) = (desired_ends[i], out_ends[i]);
+            // Net by value_id: desired (+) minus current output (−); keep non-zero, in first-seen order.
+            let mut net: HashMap<u64, Diff, BuildHasherDefault<IdHasher>> = Default::default();
+            let mut order: Vec<u64> = Vec::new();
+            for &(vid, d) in &desired[ds..de] {
+                if let Some(x) = net.get_mut(&vid) { *x += d; } else { net.insert(vid, d); order.push(vid); }
+            }
+            for &(vid, d) in &output[os..oe] {
+                if let Some(x) = net.get_mut(&vid) { *x -= d; } else { net.insert(vid, -d); order.push(vid); }
+            }
+            for vid in order {
+                let d = net[&vid];
+                if d != 0 { corr.push((vid, d)); }
+            }
+            corr_ends.push(corr.len());
+            ds = de;
+            os = oe;
+        }
+        (corr, corr_ends)
     }
 
-    fn reduce_many(&mut self, _keys: &[u64], ends: &[usize], input: &[(usize, Diff)]) -> (Vec<(u64, Diff)>, Vec<usize>) {
-        self.reduce_brackets(ends, input)
+    fn emit(&mut self, tile: usize, records: &[((u64, u64), T, Diff)]) {
+        // Resolve each correction's key/value proxies to pool rows and accumulate into the tile.
+        for rec in records {
+            let ((kh, vid), t, d) = (rec.0, &rec.1, rec.2);
+            let kr = *self.key_index.get(&kh).expect("key resolvable this retire");
+            let vr = *self.val_index.get(&vid).expect("value resolvable this retire");
+            let (krows, vrows, times, diffs) = &mut self.tile_rows[tile];
+            krows.push(kr);
+            vrows.push(vr);
+            times.push(t.clone());
+            diffs.push(d);
+        }
     }
 
-    fn materialize(&mut self, records: ProxyChunk<T, Diff>, description: Description<T>) -> CBatch<T> {
+    fn finish(&mut self) -> Vec<CBatch<T>> {
+        // Seal each tile: gather its accumulated (key, val) pool rows into columns, one CorgiChunk batch.
         let key_pool = concat_columns(&self.key_blocks);
         let val_pool = concat_columns(&self.val_blocks);
-        let kidx: Vec<usize> = (0..records.len())
-            .map(|i| *self.key_index.get(&records.key_hashes()[i]).expect("key presented this retire"))
-            .collect();
-        let vidx: Vec<usize> = (0..records.len())
-            .map(|i| *self.val_index.get(&records.value_ids()[i]).expect("value presented or minted this retire"))
-            .collect();
-        let keys = gather(&key_pool, &kidx);
-        let vals = gather(&val_pool, &vidx);
-        Rc::new(columns_to_batch(keys, vals, records.times().to_vec(), records.diffs().to_vec(), description))
+        let tiles = std::mem::take(&mut self.tiles);
+        let tile_rows = std::mem::take(&mut self.tile_rows);
+        tiles.into_iter().zip(tile_rows).map(|(desc, (krows, vrows, times, diffs))| {
+            let keys = gather(&key_pool, &krows);
+            let vals = gather(&val_pool, &vrows);
+            Rc::new(columns_to_batch(keys, vals, times, diffs, desc))
+        }).collect()
     }
 }

From 67186d0cc13024d0dd6381b7b91277c4adc0c637 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 10 Jul 2026 19:53:23 -0400
Subject: [PATCH 40/68] Value-as-id for primitive keys/values in the reduce
 (skip hash_rows)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

For a primitive column — a bare Prim(64) or a 1-field Prod([Prim(64)]) — the
value itself is already a collision-free id (i64 as u64 is a bijection), so pass
it through directly instead of content-hashing. Compound shapes still hash. The
id is used only as an identity for netting/dedup — its numeric order is never
relied on — so the raw two's-complement u64 is correct even for negatives; no
order-preserving swizzle needed.

Applied CONSISTENTLY at every id site (both value presentations AND the
reduce_brackets output values), so desired-current still nets by matching ids.

Gate: corgi_progs 6/6 (all programs match vec). Scorecard: reduce_distinct
1.18x->1.07x, reduce_count 1.17x->1.07x, reach 1.26x->1.20x. join unchanged
(the Phase 2a join is already hash-free). SCC flat within single-run noise
(allocation-bound, not hashing-bound) — confirming columnar times is the SCC lever.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 37 +++++++++++++++++++------
 1 file changed, 28 insertions(+), 9 deletions(-)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index d275a6805..179ea0cc2 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -40,7 +40,7 @@ use differential_dataflow::operators::int_proxy::ProxyBridge;
 use differential_dataflow::operators::int_proxy::reduce::{ProxyReduceBackend, ReduceInstance, ReduceWindow};
 
 use corgi::arrange::{gather, gather_lanes, hash_rows, sort_blocks};
-use corgi::{Bounds, Value as CValue};
+use corgi::{Bounds, Shape, Value as CValue};
 
 use crate::corgi_chunk::{columns_to_batch, CorgiChunk};
 use crate::ir::Diff;
@@ -158,6 +158,25 @@ fn concat_columns(blocks: &[CValue]) -> CValue {
     }
 }
 
+/// Id column for a key/value column. For a PRIMITIVE column — a bare 64-bit `Prim`, or a 1-field
+/// `Prod([Prim(64)])` — the value itself is already a collision-free id (`i64 as u64` is a bijection),
+/// so pass it straight through and skip the `hash_rows` content hash. Compound shapes (Unit / List /
+/// Sum / multi-field `Prod`) still hash. The id is used ONLY as an identity for netting/dedup — its
+/// numeric order is never relied upon — so the raw two's-complement `u64` is correct even for negative
+/// ints (no order-preserving swizzle needed). Must be applied CONSISTENTLY at every id site (both
+/// value presentations AND the freshly-produced `reduce_brackets` outputs), else `desired − current`
+/// nets across mismatched ids for the same value.
+fn ids(col: &CValue) -> Vec<u64> {
+    match corgi::shape_of_value(col) {
+        Shape::Prim(64) => col.clone().into_u64("ids"),
+        Shape::Prod(ref fs) if fs.len() == 1 && matches!(fs[0], Shape::Prim(64)) => match col {
+            CValue::Prod(fields) => fields[0].clone().into_u64("ids"),
+            _ => unreachable!("shape Prod but value not Prod"),
+        },
+        _ => hash_rows(col),
+    }
+}
+
 /// Concatenate selected records across a run of chunks into parallel `(keys_col, vals_col)` corgi
 /// columns plus per-record `(key_hash, time, diff)`. `keep(kh)` decides inclusion by key hash.
 fn collect_present<T, F>(chunks: &[&CorgiChunk<T, Diff>], mut keep: F) -> (CValue, CValue, Vec<u64>, Vec<T>, Vec<Diff>)
@@ -170,7 +189,7 @@ where
     let (mut tags, mut offs) = (Vec::new(), Vec::new());
     let (mut khs, mut times, mut diffs) = (Vec::new(), Vec::new(), Vec::new());
     for (ci, ch) in chunks.iter().enumerate() {
-        let kh = hash_rows(ch.keys());
+        let kh = ids(ch.keys());
         for i in 0..kh.len() {
             if keep(kh[i]) {
                 tags.push(ci);
@@ -228,7 +247,7 @@ where
                     return (Vec::new(), out_ends);
                 }
                 let col = CValue::Prod(vec![CValue::u64(sums)]);
-                out_ids = hash_rows(&col);
+                out_ids = ids(&col);
                 self.register_vals(col, &out_ids);
             }
             Reducer::Distinct => {
@@ -247,7 +266,7 @@ where
                     return (Vec::new(), out_ends);
                 }
                 let col = CValue::Unit(present);
-                out_ids = hash_rows(&col); // all equal (unit content hash)
+                out_ids = ids(&col); // all equal (unit content hash)
                 self.register_vals(col, &out_ids);
             }
             Reducer::Min => {
@@ -283,7 +302,7 @@ where
                 let (perm, _) = sort_blocks(&labels, &cand_col);
                 let min_reps: Vec<usize> = block_starts.iter().map(|&lo| cand_reps[perm[lo]]).collect();
                 let col = gather(&self.in_vals, &min_reps);
-                out_ids = hash_rows(&col);
+                out_ids = ids(&col);
                 self.register_vals(col, &out_ids);
             }
             Reducer::Collect => {
@@ -326,7 +345,7 @@ where
                 }
                 let elems = if elem_reps.is_empty() { CValue::Unit(0) } else { gather(&self.in_vals, &elem_reps) };
                 let col = CValue::List(Bounds::Offsets(bracket_ends), Box::new(elems));
-                out_ids = hash_rows(&col);
+                out_ids = ids(&col);
                 self.register_vals(col, &out_ids);
             }
         }
@@ -349,7 +368,7 @@ where
         // so this superset of b.support suffices; `instance.lower` is not applied (see ReduceInstance).
         let mut out: Vec<(u64, T)> = Vec::new();
         for ch in chunks_of(instance.input_batches) {
-            let kh = hash_rows(ch.keys());
+            let kh = ids(ch.keys());
             for (h, t) in kh.into_iter().zip(ch.times()) {
                 out.push((h, t.clone()));
             }
@@ -386,7 +405,7 @@ where
             self.in_vals = CValue::Unit(0);
             Vec::new()
         } else {
-            let vids = hash_rows(&in_vals);
+            let vids = ids(&in_vals);
             for (r, &vid) in vids.iter().enumerate() { self.in_index.entry(vid).or_insert(r); }
             self.in_vals = in_vals;
             self.register_keys(in_keys, &in_khs);
@@ -401,7 +420,7 @@ where
         let output: ProxyBridge<T, Diff> = if o_khs.is_empty() {
             Vec::new()
         } else {
-            let vids = hash_rows(&o_vals);
+            let vids = ids(&o_vals);
             self.register_keys(o_keys, &o_khs);
             self.register_vals(o_vals, &vids);
             let mut b: ProxyBridge<T, Diff> =

From 27e9bd09e6c30a828b6c80f3719b90964ad01522 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 10 Jul 2026 20:24:38 -0400
Subject: [PATCH 41/68] =?UTF-8?q?Add=20ColTimes<T>:=20SoA=20per-tuple=20ti?=
 =?UTF-8?q?me=20column=20(T:=20Columnar)=20=E2=80=94=20foundation?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Introduces columnar times for CorgiChunk without a DD change. Our
Time = Product<u64, PointStamp<u64>> already derives columnar::Columnar at every
layer (Product, PointStamp, u64), with the container's Ref deriving Ord/PartialOrd
(#[columnar(derive(Ord, PartialOrd))] on both Product and PointStamp). So the same
per-tuple times that were Vec<T> (one PointStamp SmallVec per row — the dominant
SCC allocation) live in <T as Columnar>::Container as SoA (offsets + values), one
allocation pair per column instead of n.

ColTimes exposes exactly what the CorgiChunk consumers need: push(&T) / push_ref
(Ref straight across, no T), get(i)->T (materialize only for Lattice ops + emit),
len, and cmp/cmp_cross (in-place ordering via the derived Ref: Ord, HRTB-bounded).

Not yet wired — Inner.times stays Vec<T> this commit. Containment rationale: the
Chunk trait boundary is whole-chunk + frontier-antichain only (CorgiChunk is Chunk
but NOT NavigableChunk, so no cursor TimeContainer/TimeGat), and the batcher/spine
move whole Rc<ChunkBatch> — so every O(data) per-tuple T is Inner.times, ours.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/col_times.rs | 99 ++++++++++++++++++++++++++++++++++++
 interactive/src/lib.rs       |  1 +
 2 files changed, 100 insertions(+)
 create mode 100644 interactive/src/col_times.rs

diff --git a/interactive/src/col_times.rs b/interactive/src/col_times.rs
new file mode 100644
index 000000000..95ea11ccb
--- /dev/null
+++ b/interactive/src/col_times.rs
@@ -0,0 +1,99 @@
+//! Columnar per-tuple times for `CorgiChunk`.
+//!
+//! `Inner.times` was `Vec<T>` — one heap-ish `PointStamp` (`SmallVec`) per row, the dominant SCC
+//! allocation (~40% of the profile). Since our `T = Product<u64, PointStamp<u64>>` already derives
+//! `columnar::Columnar` (Product, PointStamp, and u64 all do), the same times live in SoA form in
+//! `<T as Columnar>::Container` — one pair of allocations (offsets + values) for the whole column
+//! instead of `n` `SmallVec`s.
+//!
+//! Times are compared IN PLACE via the container's derived `Ord` on `Ref` (both `Product` and
+//! `PointStamp` carry `#[columnar(derive(Ord, PartialOrd))]`), so merge/sort never materialize a
+//! `T`. An owned `T` is reconstructed (`get`) only where a `Lattice` op is unavoidable — `join` in
+//! the join cross-product, `advance_by` in compaction — or at the emit boundary handing `T` back to
+//! DD. Range copies (`emit`/`concat`) push `Ref`s straight across (`push_ref`), also no `T`.
+//!
+//! This is the O(data) time store; DD's `Chunk` boundary only ever sees whole chunks + frontier
+//! antichains (control complexity), so this stays entirely inside the backend — no DD change.
+
+use std::cmp::Ordering;
+
+use columnar::{Borrow, Columnar, Index, Len, Push};
+
+/// SoA column of per-tuple times, backed by `<T as Columnar>::Container`.
+#[derive(Default)]
+pub struct ColTimes<T: Columnar> {
+    store: <T as Columnar>::Container,
+}
+
+impl<T: Columnar> ColTimes<T> {
+    #[inline]
+    pub fn new() -> Self {
+        ColTimes { store: Default::default() }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.store.borrow().len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Append an owned time (columnar `Push<&T>`); the value is stored SoA, not cloned whole.
+    #[inline]
+    pub fn push(&mut self, t: &T) {
+        self.store.push(t);
+    }
+
+    /// Append `other`'s row `i` by pushing its `Ref` straight across — no `T` materialized. Used by
+    /// the range copies in `emit`/`concat` (`Container: Push<Self::Ref>`).
+    #[inline]
+    pub fn push_ref(&mut self, other: &ColTimes<T>, i: usize) {
+        self.store.push(other.store.borrow().get(i));
+    }
+
+    /// The owned time at row `i` — materializes a `T`. Reserve for `Lattice` ops and the emit
+    /// boundary; use `cmp`/`cmp_cross` for ordering.
+    #[inline]
+    pub fn get(&self, i: usize) -> T {
+        <T as Columnar>::into_owned(self.store.borrow().get(i))
+    }
+
+    /// Order rows `i` and `j` within this column, via the derived `Ref` `Ord` (no `T`).
+    #[inline]
+    pub fn cmp(&self, i: usize, j: usize) -> Ordering
+    where
+        for<'a> columnar::Ref<'a, T>: Ord,
+    {
+        let b = self.store.borrow();
+        let ri = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(b.get(i));
+        let rj = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(b.get(j));
+        ri.cmp(&rj)
+    }
+
+    /// Order this column's row `i` against `other`'s row `j` (the two-pointer merge compare).
+    #[inline]
+    pub fn cmp_cross(&self, i: usize, other: &ColTimes<T>, j: usize) -> Ordering
+    where
+        for<'a> columnar::Ref<'a, T>: Ord,
+    {
+        let ba = self.store.borrow();
+        let bb = other.store.borrow();
+        let ri = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(ba.get(i));
+        let rj = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(bb.get(j));
+        ri.cmp(&rj)
+    }
+}
+
+/// Build a column from an iterator of owned times (the `FromIterator` path used at construction).
+impl<T: Columnar> FromIterator<T> for ColTimes<T> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut store: <T as Columnar>::Container = Default::default();
+        for t in iter {
+            store.push(&t);
+        }
+        ColTimes { store }
+    }
+}
diff --git a/interactive/src/lib.rs b/interactive/src/lib.rs
index 776d9f606..e7c52264b 100644
--- a/interactive/src/lib.rs
+++ b/interactive/src/lib.rs
@@ -1,5 +1,6 @@
 pub mod parse;
 pub mod ir;
+pub mod col_times;
 pub mod corgi_logic;
 pub mod corgi_backend;
 pub mod corgi_chunk;

From 3c7027761bbb45eaf080add916294222dcc20855 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 10 Jul 2026 20:43:09 -0400
Subject: [PATCH 42/68] Wire columnar times: Inner.times Vec<T> -> ColTimes<T>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CorgiChunk's resident per-tuple times are now SoA (ColTimes over
<T as Columnar>::Container) instead of Vec<T> — killing the per-row PointStamp
SmallVec allocation that dominated the SCC profile (~40%). The hot maintenance
paths (merge/emit/extract/advance/settle/concat) build and read times columnar:
compares go through the derived Ref: Ord in place (no T materialized), range
copies push Refs straight across, and an owned T is reconstructed only where a
Lattice op is unavoidable (advance_by in compaction) or at the egress boundary
(SortedRun for the join, CorgiContainer for as_collection — both want owned T).

Bounds: a ColTime alias (Timestamp + Lattice + Columnar) bundles the constraint;
the viral HRTB `for<'a> Ref<'a,T>: Ord` is discharged once in ColTime's blanket
impl behind ColTime::cmp_refs, so downstream code needs only T: ColTime. Ingress
paths (sort_consolidate, CorgiChunker accumulator, flatten_restricted) stay Vec<T>
(they already hold owned T), converting at from_columns.

No DD change. Gate: corgi_progs 6/6; 29 lib tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/col_times.rs            |  70 ++++++++++--
 interactive/src/corgi_chunk.rs          | 145 ++++++++++++++----------
 interactive/src/corgi_join.rs           |   9 +-
 interactive/src/corgi_reduce_backend.rs |  16 +--
 4 files changed, 156 insertions(+), 84 deletions(-)

diff --git a/interactive/src/col_times.rs b/interactive/src/col_times.rs
index 95ea11ccb..01d3cb313 100644
--- a/interactive/src/col_times.rs
+++ b/interactive/src/col_times.rs
@@ -17,7 +17,38 @@
 
 use std::cmp::Ordering;
 
-use columnar::{Borrow, Columnar, Index, Len, Push};
+use columnar::{Borrow, Clear, Columnar, Index, Len, Push};
+
+use differential_dataflow::lattice::Lattice;
+use timely::progress::Timestamp;
+
+/// A timestamp usable as a columnar time column: `Timestamp + Lattice` (DD's algebra) plus
+/// `Columnar` with an *ordered* `Ref` (so times compare in their SoA form). Our
+/// `Product<u64, PointStamp<u64>>` satisfies it — every layer derives `Columnar` with
+/// `#[columnar(derive(Ord, PartialOrd))]`.
+///
+/// The `Ref: Ord` requirement is an HRTB on a projection (`for<'a> Ref<'a, Self>: Ord`), which Rust
+/// does NOT imply from a plain `T: ColTime` bound at use sites — so it would otherwise go viral
+/// across every fn driving the `Chunk` methods. We discharge it ONCE here, in the blanket impl,
+/// behind [`ColTime::cmp_refs`]; downstream code compares times through that method and needs only
+/// `T: ColTime`.
+pub trait ColTime: Timestamp + Lattice + Columnar {
+    /// Order two SoA time references (via the derived `Ref: Ord`, lifetimes reborrowed to unify).
+    fn cmp_refs(a: columnar::Ref<'_, Self>, b: columnar::Ref<'_, Self>) -> Ordering;
+}
+
+impl<T> ColTime for T
+where
+    T: Timestamp + Lattice + Columnar,
+    for<'a> columnar::Ref<'a, T>: Ord,
+{
+    #[inline]
+    fn cmp_refs(a: columnar::Ref<'_, T>, b: columnar::Ref<'_, T>) -> Ordering {
+        let a = <<T as Columnar>::Container as Borrow>::reborrow_ref(a);
+        let b = <<T as Columnar>::Container as Borrow>::reborrow_ref(b);
+        a.cmp(&b)
+    }
+}
 
 /// SoA column of per-tuple times, backed by `<T as Columnar>::Container`.
 #[derive(Default)]
@@ -41,6 +72,12 @@ impl<T: Columnar> ColTimes<T> {
         self.len() == 0
     }
 
+    /// Empty the column, retaining allocation (the emit-flush reuse in `advance`).
+    #[inline]
+    pub fn clear(&mut self) {
+        self.store.clear();
+    }
+
     /// Append an owned time (columnar `Push<&T>`); the value is stored SoA, not cloned whole.
     #[inline]
     pub fn push(&mut self, t: &T) {
@@ -61,29 +98,42 @@ impl<T: Columnar> ColTimes<T> {
         <T as Columnar>::into_owned(self.store.borrow().get(i))
     }
 
-    /// Order rows `i` and `j` within this column, via the derived `Ref` `Ord` (no `T`).
+    /// Append rows `[s, e)` of `other`, pushing `Ref`s straight across — no `T` materialized. The
+    /// range copy used by `emit`/`concat`/merge-suffix.
+    #[inline]
+    pub fn push_range(&mut self, other: &ColTimes<T>, s: usize, e: usize) {
+        let b = other.store.borrow();
+        for i in s..e {
+            self.store.push(b.get(i));
+        }
+    }
+
+    /// Materialize the whole column to `Vec<T>` — the egress boundary (`SortedRun` for the join,
+    /// `CorgiContainer` for `as_collection`), where owned `T` is wanted anyway.
+    pub fn to_vec(&self) -> Vec<T> {
+        let b = self.store.borrow();
+        (0..b.len()).map(|i| <T as Columnar>::into_owned(b.get(i))).collect()
+    }
+
+    /// Order rows `i` and `j` within this column, in place via [`ColTime::cmp_refs`] (no `T`).
     #[inline]
     pub fn cmp(&self, i: usize, j: usize) -> Ordering
     where
-        for<'a> columnar::Ref<'a, T>: Ord,
+        T: ColTime,
     {
         let b = self.store.borrow();
-        let ri = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(b.get(i));
-        let rj = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(b.get(j));
-        ri.cmp(&rj)
+        T::cmp_refs(b.get(i), b.get(j))
     }
 
     /// Order this column's row `i` against `other`'s row `j` (the two-pointer merge compare).
     #[inline]
     pub fn cmp_cross(&self, i: usize, other: &ColTimes<T>, j: usize) -> Ordering
     where
-        for<'a> columnar::Ref<'a, T>: Ord,
+        T: ColTime,
     {
         let ba = self.store.borrow();
         let bb = other.store.borrow();
-        let ri = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(ba.get(i));
-        let rj = <<T as Columnar>::Container as columnar::Borrow>::reborrow_ref(bb.get(j));
-        ri.cmp(&rj)
+        T::cmp_refs(ba.get(i), bb.get(j))
     }
 }
 
diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index d8cf4eb69..a4b06bab6 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -1,5 +1,7 @@
 //! `CorgiChunk`: a [`Chunk`](differential_dataflow::trace::chunk::Chunk) whose key/val payload is a
-//! pair of corgi columns (time/diff stay Rust `Vec`s). It is a **`Chunk` but NOT `NavigableChunk`**:
+//! pair of corgi columns, with per-tuple times held columnar in a [`ColTimes`] (SoA over
+//! `<T as Columnar>::Container`, killing the per-row `PointStamp` allocation); diffs stay a `Vec`.
+//! It is a **`Chunk` but NOT `NavigableChunk`**:
 //! it exposes no `Ord` key, no cursor, no sorted-trie layout — the merge/advance/settle transducers
 //! drive everything through corgi's own structural order (`compare_at`) and gather primitives
 //! (`gather`, `gather_lanes`). Consumption is the tactics' job (they read the columns in bulk), which
@@ -31,6 +33,9 @@ use differential_dataflow::trace::Description;
 use corgi::arrange::{compare_at, compare_idx, find_ranges, gather, gather_lanes, sort_perm};
 use corgi::Value as CValue;
 
+use columnar::Columnar;
+
+use crate::col_times::{ColTime, ColTimes};
 use crate::ir::Value as DValue;
 
 use std::cmp::Ordering;
@@ -44,27 +49,27 @@ pub type Upd<T, R> = ((DValue, DValue), T, R);
 const TARGET: usize = 1 << 18;
 
 /// Shared, immutable chunk contents. `Clone` of a `CorgiChunk` is an `Rc` bump.
-struct Inner<T, R> {
+struct Inner<T: Columnar, R> {
     /// Key column (corgi), aligned with `vals`/`times`/`diffs`, sorted by `(key, val, time)`.
     keys: CValue,
     /// Val column (corgi).
     vals: CValue,
-    /// Per-update times (the lattice algebra lives here; corgi never sees time).
-    times: Vec<T>,
+    /// Per-update times, SoA-columnar (the lattice algebra lives here; corgi never sees time).
+    times: ColTimes<T>,
     /// Per-update diffs.
     diffs: Vec<R>,
 }
 
 /// A sorted, consolidated run of `((key, val), time, diff)` with corgi-columnar key/val, shared via `Rc`.
-pub struct CorgiChunk<T, R>(Rc<Inner<T, R>>);
+pub struct CorgiChunk<T: Columnar, R>(Rc<Inner<T, R>>);
 
-impl<T, R> Clone for CorgiChunk<T, R> {
+impl<T: Columnar, R> Clone for CorgiChunk<T, R> {
     fn clone(&self) -> Self { CorgiChunk(Rc::clone(&self.0)) }
 }
 
-impl<T, R> Default for CorgiChunk<T, R> {
+impl<T: Columnar, R> Default for CorgiChunk<T, R> {
     fn default() -> Self {
-        CorgiChunk(Rc::new(Inner { keys: CValue::Unit(0), vals: CValue::Unit(0), times: Vec::new(), diffs: Vec::new() }))
+        CorgiChunk(Rc::new(Inner { keys: CValue::Unit(0), vals: CValue::Unit(0), times: ColTimes::new(), diffs: Vec::new() }))
     }
 }
 
@@ -76,31 +81,25 @@ fn split_kv(kv: CValue) -> (CValue, CValue) {
     (keys, vals)
 }
 
-impl<T: Clone, R: Clone> CorgiChunk<T, R> {
-    fn from_parts(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
+impl<T: Columnar + Clone, R: Clone> CorgiChunk<T, R> {
+    fn from_parts(keys: CValue, vals: CValue, times: ColTimes<T>, diffs: Vec<R>) -> Self {
         CorgiChunk(Rc::new(Inner { keys, vals, times, diffs }))
     }
     /// The `(key, val)` sort payload as one corgi `Prod` column (cheap `Arc` bumps).
     fn kv(&self) -> CValue { CValue::Prod(vec![self.0.keys.clone(), self.0.vals.clone()]) }
-    fn from_kv(kv: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
+    fn from_kv(kv: CValue, times: ColTimes<T>, diffs: Vec<R>) -> Self {
         let (keys, vals) = split_kv(kv);
         Self::from_parts(keys, vals, times, diffs)
     }
     pub fn keys(&self) -> &CValue { &self.0.keys }
     pub fn vals(&self) -> &CValue { &self.0.vals }
-    pub fn times(&self) -> &[T] { &self.0.times }
+    pub fn times(&self) -> &ColTimes<T> { &self.0.times }
     pub fn diffs(&self) -> &[R] { &self.0.diffs }
 }
 
-/// Total order used throughout: `(key, val)` structurally, then `time`.
-#[inline]
-fn cmp_at<T: Ord>(a_kv: &CValue, ai: usize, at: &T, b_kv: &CValue, bi: usize, bt: &T) -> Ordering {
-    compare_at(a_kv, ai, b_kv, bi).then_with(|| at.cmp(bt))
-}
-
 impl<T, R> CorgiChunk<T, R>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     /// Materialize `[start, end)` of accumulated `(tag → src, off, time, diff)` into `TARGET`-sized
@@ -109,7 +108,7 @@ where
         srcs: &[Option<&CValue>],
         tags: &[usize],
         offs: &[usize],
-        times: &[T],
+        times: &ColTimes<T>,
         diffs: &[R],
         out: &mut VecDeque<Self>,
     ) {
@@ -118,21 +117,23 @@ where
         while s < n {
             let e = (s + TARGET).min(n);
             let kv = gather_lanes(srcs, &tags[s..e], &offs[s..e]);
-            out.push_back(Self::from_kv(kv, times[s..e].to_vec(), diffs[s..e].to_vec()));
+            let mut t = ColTimes::new();
+            t.push_range(times, s, e);
+            out.push_back(Self::from_kv(kv, t, diffs[s..e].to_vec()));
             s = e;
         }
     }
 
     /// Concatenate a run of (globally-sorted) chunks into one combined `(kv, times, diffs)`.
-    fn concat(chunks: &[Self]) -> (CValue, Vec<T>, Vec<R>) {
+    fn concat(chunks: &[Self]) -> (CValue, ColTimes<T>, Vec<R>) {
         let kvs: Vec<CValue> = chunks.iter().map(Self::kv).collect();
         let srcs: Vec<Option<&CValue>> = kvs.iter().map(Some).collect();
         let total: usize = chunks.iter().map(Self::len_).sum();
         let (mut tags, mut offs) = (Vec::with_capacity(total), Vec::with_capacity(total));
-        let (mut times, mut diffs) = (Vec::with_capacity(total), Vec::with_capacity(total));
+        let (mut times, mut diffs) = (ColTimes::new(), Vec::with_capacity(total));
         for (ti, ch) in chunks.iter().enumerate() {
             for o in 0..ch.len_() { tags.push(ti); offs.push(o); }
-            times.extend_from_slice(ch.times());
+            times.push_range(ch.times(), 0, ch.len_());
             diffs.extend_from_slice(ch.diffs());
         }
         let kv = if total == 0 { CValue::Unit(0) } else { gather_lanes(&srcs, &tags, &offs) };
@@ -144,7 +145,7 @@ where
 
 impl<T, R> Chunk for CorgiChunk<T, R>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     type Time = T;
@@ -164,16 +165,18 @@ where
         let (t2, d2) = (c2.times(), c2.diffs());
 
         let (mut tags, mut offs) = (Vec::new(), Vec::new());
-        let (mut times, mut diffs) = (Vec::new(), Vec::new());
+        let (mut times, mut diffs) = (ColTimes::new(), Vec::new());
         let (mut p1, mut p2) = (0usize, 0usize);
         while p1 < n1 && p2 < n2 {
-            match cmp_at(&kv1, p1, &t1[p1], &kv2, p2, &t2[p2]) {
-                Ordering::Less => { tags.push(0); offs.push(p1); times.push(t1[p1].clone()); diffs.push(d1[p1].clone()); p1 += 1; }
-                Ordering::Greater => { tags.push(1); offs.push(p2); times.push(t2[p2].clone()); diffs.push(d2[p2].clone()); p2 += 1; }
+            // `(key, val)` structurally, then `time` in place via the columnar `Ref: Ord`.
+            let ord = compare_at(&kv1, p1, &kv2, p2).then_with(|| t1.cmp_cross(p1, t2, p2));
+            match ord {
+                Ordering::Less => { tags.push(0); offs.push(p1); times.push_ref(t1, p1); diffs.push(d1[p1].clone()); p1 += 1; }
+                Ordering::Greater => { tags.push(1); offs.push(p2); times.push_ref(t2, p2); diffs.push(d2[p2].clone()); p2 += 1; }
                 Ordering::Equal => {
                     let mut d = d1[p1].clone();
                     d.plus_equals(&d2[p2]);
-                    if !d.is_zero() { tags.push(0); offs.push(p1); times.push(t1[p1].clone()); diffs.push(d); }
+                    if !d.is_zero() { tags.push(0); offs.push(p1); times.push_ref(t1, p1); diffs.push(d); }
                     p1 += 1; p2 += 1;
                 }
             }
@@ -185,11 +188,15 @@ where
         // Push back the survivor's unconsumed suffix (all `>` the horizon), ahead of its deque.
         if p1 < n1 {
             let idx: Vec<usize> = (p1..n1).collect();
-            in1.push_front(Self::from_kv(gather(&kv1, &idx), t1[p1..].to_vec(), d1[p1..].to_vec()));
+            let mut t = ColTimes::new();
+            t.push_range(t1, p1, n1);
+            in1.push_front(Self::from_kv(gather(&kv1, &idx), t, d1[p1..].to_vec()));
         }
         if p2 < n2 {
             let idx: Vec<usize> = (p2..n2).collect();
-            in2.push_front(Self::from_kv(gather(&kv2, &idx), t2[p2..].to_vec(), d2[p2..].to_vec()));
+            let mut t = ColTimes::new();
+            t.push_range(t2, p2, n2);
+            in2.push_front(Self::from_kv(gather(&kv2, &idx), t, d2[p2..].to_vec()));
         }
     }
 
@@ -206,15 +213,18 @@ where
         let (times, diffs) = (chunk.times(), chunk.diffs());
         let (mut ki, mut si) = (Vec::new(), Vec::new());
         for i in 0..chunk.len_() {
-            if frontier.less_equal(&times[i]) { residual.insert_ref(&times[i]); ki.push(i); } else { si.push(i); }
+            let ti = times.get(i);
+            if frontier.less_equal(&ti) { residual.insert_ref(&ti); ki.push(i); } else { si.push(i); }
         }
         if !ki.is_empty() {
-            let t: Vec<T> = ki.iter().map(|&i| times[i].clone()).collect();
+            let mut t = ColTimes::new();
+            for &i in &ki { t.push_ref(times, i); }
             let d: Vec<R> = ki.iter().map(|&i| diffs[i].clone()).collect();
             keep.push_back(Self::from_kv(gather(&kv, &ki), t, d));
         }
         if !si.is_empty() {
-            let t: Vec<T> = si.iter().map(|&i| times[i].clone()).collect();
+            let mut t = ColTimes::new();
+            for &i in &si { t.push_ref(times, i); }
             let d: Vec<R> = si.iter().map(|&i| diffs[i].clone()).collect();
             ship.push_back(Self::from_kv(gather(&kv, &si), t, d));
         }
@@ -250,20 +260,24 @@ where
         };
         if end < n {
             let idx: Vec<usize> = (end..n).collect();
-            input.push_front(Self::from_kv(gather(&ckv, &idx), ctimes[end..].to_vec(), cdiffs[end..].to_vec()));
+            let mut ct = ColTimes::new();
+            ct.push_range(&ctimes, end, n);
+            input.push_front(Self::from_kv(gather(&ckv, &idx), ct, cdiffs[end..].to_vec()));
         }
 
         // Advance + consolidate each complete group; emit `TARGET`-sized chunks. All rows of a group
-        // share `(key, val)`, so one representative offset materializes each output row's kv.
+        // share `(key, val)`, so one representative offset materializes each output row's kv. Times are
+        // materialized here (owned `T`) because `advance_by` mutates and the tiebreak re-sort is a Rust
+        // sort — the compaction path, not the merge hot path.
         let srcs = [Some(&ckv)];
         let (mut tags, mut offs) = (Vec::new(), Vec::new());
-        let (mut otimes, mut odiffs) = (Vec::new(), Vec::new());
+        let (mut otimes, mut odiffs): (ColTimes<T>, Vec<R>) = (ColTimes::new(), Vec::new());
         let mut i = 0;
         while i < end {
             let mut j = i;
             while j < end && compare_at(&ckv, i, &ckv, j) == Ordering::Equal { j += 1; }
             let mut pairs: Vec<(T, R)> = (i..j)
-                .map(|k| { let mut t = ctimes[k].clone(); t.advance_by(frontier); (t, cdiffs[k].clone()) })
+                .map(|k| { let mut t = ctimes.get(k); t.advance_by(frontier); (t, cdiffs[k].clone()) })
                 .collect();
             pairs.sort_by(|a, b| a.0.cmp(&b.0));
             let mut k = 0;
@@ -273,7 +287,7 @@ where
                 k += 1;
                 while k < pairs.len() && pairs[k].0 == t { d.plus_equals(&pairs[k].1); k += 1; }
                 if !d.is_zero() {
-                    tags.push(0); offs.push(i); otimes.push(t); odiffs.push(d);
+                    tags.push(0); offs.push(i); otimes.push(&t); odiffs.push(d);
                     if otimes.len() >= TARGET {
                         Self::emit(&srcs, &tags, &offs, &otimes, &odiffs, out);
                         tags.clear(); offs.clear(); otimes.clear(); odiffs.clear();
@@ -301,18 +315,23 @@ where
                 for o in 0..na { tags.push(0); offs.push(o); }
                 for o in 0..nb { tags.push(1); offs.push(o); }
                 let kv = gather_lanes(&srcs, &tags, &offs);
-                let mut times = acc.times().to_vec();
-                times.extend_from_slice(next.times());
+                let mut times = ColTimes::new();
+                times.push_range(acc.times(), 0, na);
+                times.push_range(next.times(), 0, nb);
                 let mut diffs = acc.diffs().to_vec();
                 diffs.extend_from_slice(next.diffs());
                 *acc = Self::from_kv(kv, times, diffs);
             },
             |chunk, m| {
                 let kv = chunk.kv();
+                let n = chunk.len_();
                 let left: Vec<usize> = (0..m).collect();
-                let right: Vec<usize> = (m..chunk.len_()).collect();
-                let l = Self::from_kv(gather(&kv, &left), chunk.times()[..m].to_vec(), chunk.diffs()[..m].to_vec());
-                let r = Self::from_kv(gather(&kv, &right), chunk.times()[m..].to_vec(), chunk.diffs()[m..].to_vec());
+                let right: Vec<usize> = (m..n).collect();
+                let (mut lt, mut rt) = (ColTimes::new(), ColTimes::new());
+                lt.push_range(chunk.times(), 0, m);
+                rt.push_range(chunk.times(), m, n);
+                let l = Self::from_kv(gather(&kv, &left), lt, chunk.diffs()[..m].to_vec());
+                let r = Self::from_kv(gather(&kv, &right), rt, chunk.diffs()[m..].to_vec());
                 (l, r)
             },
             |chunk| chunk,
@@ -328,7 +347,7 @@ where
 /// (time is not a corgi type). No per-pair `compare_at`.
 fn sort_consolidate<T, R>(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> (CValue, CValue, Vec<T>, Vec<R>)
 where
-    T: Ord + Clone,
+    T: Ord + Clone + Columnar,
     R: Semigroup + Clone,
 {
     let n = times.len();
@@ -384,14 +403,14 @@ where
 
 impl<T, R> CorgiChunk<T, R>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     /// One sorted+consolidated chunk from columns already in corgi form (the column-native arrange
     /// ingest — no transcode).
     pub fn from_columns(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>) -> Self {
         let (keys, vals, times, diffs) = sort_consolidate(keys, vals, times, diffs);
-        Self::from_parts(keys, vals, times, diffs)
+        Self::from_parts(keys, vals, ColTimes::from_iter(times), diffs)
     }
 
 }
@@ -401,7 +420,7 @@ where
 /// `CorgiContainer`), instead of untranscoding to rows and re-transcoding.
 pub fn chunks_to_columns<T, R>(chunks: &[CorgiChunk<T, R>]) -> (CValue, CValue, Vec<T>, Vec<R>)
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     if chunks.iter().all(|c| c.len_() == 0) {
@@ -409,7 +428,7 @@ where
     }
     let (kv, times, diffs) = CorgiChunk::concat(chunks);
     let (keys, vals) = split_kv(kv);
-    (keys, vals, times, diffs)
+    (keys, vals, times.to_vec(), diffs)
 }
 
 /// Build a `ChunkBatch<CorgiChunk>` from corgi key/val COLUMNS directly (no transcode): sort +
@@ -417,7 +436,7 @@ where
 /// output with (it resolves proxy ids to real columns by `gather` and hands them here).
 pub fn columns_to_batch<T, R>(keys: CValue, vals: CValue, times: Vec<T>, diffs: Vec<R>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     let chunk = CorgiChunk::from_columns(keys, vals, times, diffs);
@@ -427,7 +446,7 @@ where
 /// Grade one chunk into a `ChunkBatch` (shared tail of `rows_to_batch`/`columns_to_batch`).
 fn settle_one<T, R>(chunk: CorgiChunk<T, R>, description: Description<T>) -> ChunkBatch<CorgiChunk<T, R>>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     let mut input = VecDeque::new();
@@ -445,7 +464,7 @@ where
 /// Crucially it **accumulates to `TARGET`** before consolidating (like `ContainerChunker`), so it
 /// emits few large chunks rather than one tiny chunk per input container — otherwise the columnar
 /// per-chunk set-up (`gather`/`sort_perm`) dominates when input arrives as many small batches.
-pub struct CorgiChunker<T, R> {
+pub struct CorgiChunker<T: Columnar, R> {
     /// Un-consolidated key/val column blocks (one per absorbed container), flat time/diff.
     k_blocks: Vec<CValue>,
     v_blocks: Vec<CValue>,
@@ -455,7 +474,7 @@ pub struct CorgiChunker<T, R> {
     current: Option<CorgiChunk<T, R>>,
 }
 
-impl<T, R> Default for CorgiChunker<T, R> {
+impl<T: Columnar, R> Default for CorgiChunker<T, R> {
     fn default() -> Self {
         CorgiChunker { k_blocks: Vec::new(), v_blocks: Vec::new(), times: Vec::new(), diffs: Vec::new(), ready: VecDeque::new(), current: None }
     }
@@ -476,7 +495,7 @@ fn concat_blocks(blocks: &[CValue]) -> CValue {
 
 impl<T, R> CorgiChunker<T, R>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     /// Consolidate the accumulated blocks into one graded chunk (concat columns, then sort+consolidate).
@@ -499,7 +518,7 @@ where
 
 impl<T, R> timely::container::PushInto<&mut crate::corgi_backend::CorgiContainer<T, R>> for CorgiChunker<T, R>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     fn push_into(&mut self, c: &mut crate::corgi_backend::CorgiContainer<T, R>) {
@@ -518,7 +537,7 @@ where
 
 impl<T, R> timely::container::ContainerBuilder for CorgiChunker<T, R>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     type Container = CorgiChunk<T, R>;
@@ -550,7 +569,7 @@ pub struct SortedRun<T, R> {
 /// if empty. This replaces an earlier concat+full-sort that dominated recursive (reach) cost.
 pub fn flatten_batches<T, R>(batches: &[Rc<ChunkBatch<CorgiChunk<T, R>>>]) -> Option<SortedRun<T, R>>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     let mut merged: VecDeque<CorgiChunk<T, R>> = VecDeque::new();
@@ -568,7 +587,7 @@ where
     let chunks: Vec<CorgiChunk<T, R>> = merged.into();
     let (kv, times, diffs) = CorgiChunk::concat(&chunks);
     let (keys, vals) = split_kv(kv);
-    Some(SortedRun { keys, vals, times, diffs })
+    Some(SortedRun { keys, vals, times: times.to_vec(), diffs })
 }
 
 /// A DELTA-PROPORTIONAL flatten of the accumulated side of a bilinear join: instead of merging the
@@ -579,7 +598,7 @@ where
 /// trace — replacing the O(trace)-per-work-unit `flatten_batches` that dominated recursive joins.
 pub fn flatten_restricted<T, R>(acc: &[Rc<ChunkBatch<CorgiChunk<T, R>>>], needles: &CValue) -> Option<SortedRun<T, R>>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     R: Semigroup + Clone + 'static,
 {
     let (mut kblocks, mut vblocks): (Vec<CValue>, Vec<CValue>) = (Vec::new(), Vec::new());
@@ -597,7 +616,7 @@ where
             kblocks.push(gather(ch.keys(), &idx));
             vblocks.push(gather(ch.vals(), &idx));
             for &j in &idx {
-                times.push(ch.times()[j].clone());
+                times.push(ch.times().get(j));
                 diffs.push(ch.diffs()[j].clone());
             }
         }
@@ -626,7 +645,7 @@ mod test {
         m.retain(|_, d| *d != 0);
         let keys = CValue::u64(m.keys().map(|((k, _), _)| *k).collect());
         let vals = CValue::u64(m.keys().map(|((_, v), _)| *v).collect());
-        let times = m.keys().map(|(_, t)| *t).collect();
+        let times: ColTimes<u64> = m.keys().map(|(_, t)| *t).collect();
         let diffs = m.values().copied().collect();
         CorgiChunk::from_parts(keys, vals, times, diffs)
     }
@@ -636,7 +655,7 @@ mod test {
         for ch in &b.chunks {
             let ks = ch.keys().clone().into_u64("k");
             let vs = ch.vals().clone().into_u64("v");
-            for i in 0..ch.len_() { *m.entry(((ks[i], vs[i]), ch.times()[i])).or_insert(0) += ch.diffs()[i]; }
+            for i in 0..ch.len_() { *m.entry(((ks[i], vs[i]), ch.times().get(i))).or_insert(0) += ch.diffs()[i]; }
         }
         m.retain(|_, d| *d != 0);
         m
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi_join.rs
index 40a3417c1..49f2610f6 100644
--- a/interactive/src/corgi_join.rs
+++ b/interactive/src/corgi_join.rs
@@ -22,6 +22,7 @@ use corgi::Value as CValue;
 use differential_dataflow::trace::chunk::{Chunk, ChunkBatch};
 
 use crate::corgi_backend::CorgiContainer;
+use crate::col_times::ColTime;
 use crate::corgi_chunk::{flatten_batches, flatten_restricted, CorgiChunk};
 use crate::corgi_logic::compile_join_projection;
 use crate::ir::Diff;
@@ -31,13 +32,13 @@ type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
 /// Cursor-less corgi join tactic. Holds the projection `Term`s (`Var(0)=key`, `Var(1)=val0`,
 /// `Var(2)=val1`); compiled to a corgi graph per work-unit using the matched columns' shapes (so
 /// `Spread` resolves against the actual key/val arities).
-pub struct CorgiJoinTactic<T: Timestamp + Lattice> {
+pub struct CorgiJoinTactic<T: ColTime> {
     key: Term,
     val: Term,
     _t: std::marker::PhantomData<T>,
 }
 
-impl<T: Timestamp + Lattice> CorgiJoinTactic<T> {
+impl<T: ColTime> CorgiJoinTactic<T> {
     pub fn new(key: Term, val: Term) -> Self {
         CorgiJoinTactic { key, val, _t: std::marker::PhantomData }
     }
@@ -45,7 +46,7 @@ impl<T: Timestamp + Lattice> CorgiJoinTactic<T> {
 
 impl<T> JoinTactic<CBatch<T>, CBatch<T>, CorgiContainer<T, Diff>> for CorgiJoinTactic<T>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
 {
     /// One bilinear unit → its output container. The operator (`join_with_tactic`) drives capabilities
     /// and fuel by draining the returned iterator; `meet` (compaction) is ignored (correctness-first,
@@ -59,7 +60,7 @@ where
 /// matched val runs (lattice time-join + diff-multiply), project via corgi, emit at the capability.
 fn run_unit<T>(left_b: Vec<CBatch<T>>, right_b: Vec<CBatch<T>>, fresh: Fresh, key: &Term, val: &Term) -> Option<CorgiContainer<T, Diff>>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
 {
     // Materialize the FRESH (delta-sized) side whole; then present the ACCUMULATED side. When it is
     // meaningfully larger than the fresh delta (recursive joins against a built-up trace), probe it
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 179ea0cc2..c42084713 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -42,6 +42,7 @@ use differential_dataflow::operators::int_proxy::reduce::{ProxyReduceBackend, Re
 use corgi::arrange::{gather, gather_lanes, hash_rows, sort_blocks};
 use corgi::{Bounds, Shape, Value as CValue};
 
+use crate::col_times::ColTime;
 use crate::corgi_chunk::{columns_to_batch, CorgiChunk};
 use crate::ir::Diff;
 use crate::parse::Reducer;
@@ -181,7 +182,7 @@ fn ids(col: &CValue) -> Vec<u64> {
 /// columns plus per-record `(key_hash, time, diff)`. `keep(kh)` decides inclusion by key hash.
 fn collect_present<T, F>(chunks: &[&CorgiChunk<T, Diff>], mut keep: F) -> (CValue, CValue, Vec<u64>, Vec<T>, Vec<Diff>)
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
     F: FnMut(u64) -> bool,
 {
     let key_srcs: Vec<Option<&CValue>> = chunks.iter().map(|c| Some(c.keys())).collect();
@@ -195,7 +196,7 @@ where
                 tags.push(ci);
                 offs.push(i);
                 khs.push(kh[i]);
-                times.push(ch.times()[i].clone());
+                times.push(ch.times().get(i));
                 diffs.push(ch.diffs()[i]);
             }
         }
@@ -211,14 +212,14 @@ where
 /// All chunks of a batch list, flattened (empty chunks included — `hash_rows` yields nothing for them).
 fn chunks_of<T>(batches: &[CBatch<T>]) -> Vec<&CorgiChunk<T, Diff>>
 where
-    T: Timestamp + Lattice,
+    T: ColTime,
 {
     batches.iter().flat_map(|b| b.chunks.iter()).collect()
 }
 
 impl<T> CorgiReduceBackend<T>
 where
-    T: Timestamp + Lattice + Ord,
+    T: ColTime + Ord,
 {
     /// The one value crossing for a retire: every `(key, time)` bracket at once. Builds the output
     /// value COLUMN directly per reducer, registers it (id → row) into the val pool, and returns the
@@ -357,7 +358,7 @@ where
 
 impl<T> ProxyReduceBackend<CBatch<T>, CBatch<T>> for CorgiReduceBackend<T>
 where
-    T: Timestamp + Lattice + Ord,
+    T: ColTime + Ord,
 {
     type RIn = Diff;
     type ROut = Diff;
@@ -369,8 +370,9 @@ where
         let mut out: Vec<(u64, T)> = Vec::new();
         for ch in chunks_of(instance.input_batches) {
             let kh = ids(ch.keys());
-            for (h, t) in kh.into_iter().zip(ch.times()) {
-                out.push((h, t.clone()));
+            let times = ch.times();
+            for (i, h) in kh.into_iter().enumerate() {
+                out.push((h, times.get(i)));
             }
         }
         out.sort_by_key(|(k, _)| *k);

From 8681e1931b7fd027a7af760d00e8323a953f6bec Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Fri, 10 Jul 2026 20:49:26 -0400
Subject: [PATCH 43/68] Drop unused Timestamp/Lattice imports (subsumed by
 ColTime bound)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_chunk.rs          | 3 +--
 interactive/src/corgi_join.rs           | 2 --
 interactive/src/corgi_reduce_backend.rs | 2 --
 3 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index a4b06bab6..b5d2144fc 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -22,11 +22,10 @@
 use std::collections::VecDeque;
 use std::rc::Rc;
 
-use timely::progress::{Antichain, Timestamp};
+use timely::progress::Antichain;
 use timely::progress::frontier::AntichainRef;
 
 use differential_dataflow::difference::Semigroup;
-use differential_dataflow::lattice::Lattice;
 use differential_dataflow::trace::chunk::{merge_chains, pack, Chunk, ChunkBatch};
 use differential_dataflow::trace::Description;
 
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi_join.rs
index 49f2610f6..0d5db50ae 100644
--- a/interactive/src/corgi_join.rs
+++ b/interactive/src/corgi_join.rs
@@ -11,9 +11,7 @@
 
 use std::rc::Rc;
 
-use timely::progress::Timestamp;
 
-use differential_dataflow::lattice::Lattice;
 use differential_dataflow::operators::join::{Fresh, JoinTactic};
 
 use corgi::arrange::{find_ranges, gather};
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index c42084713..8e3d4b371 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -30,9 +30,7 @@ use std::collections::HashMap;
 use std::hash::{BuildHasherDefault, Hasher};
 use std::rc::Rc;
 
-use timely::progress::Timestamp;
 
-use differential_dataflow::lattice::Lattice;
 use differential_dataflow::consolidation::consolidate_updates;
 use differential_dataflow::trace::Description;
 use differential_dataflow::trace::chunk::ChunkBatch;

From 17ff06d00df9cbf23dc2e3c580d6bca5a00f4b0f Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 07:40:23 -0400
Subject: [PATCH 44/68] =?UTF-8?q?Adopt=20corgi=20survey=20(merge)=20+=20gr?=
 =?UTF-8?q?oup=5Fbounds=20(advance)=20=E2=80=94=20bump=20to=20f556868?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CorgiChunk::merge now drives off corgi `survey(kv1, kv2)`: one bidirectional
gallop over the (key,val) columns yields Runs — maximal exclusive A/B ranges
(bulk-copied, no per-row compare) + single Both matched pairs (time-ordered /
consolidated here, since corgi owns no time). Replaces the per-pair two-pointer
compare_at (the 22%-and-growing merge-compare tax). CorgiChunk::advance uses
`group_bounds(ckv)` for the group-boundary scan (one pass) instead of per-row
compare_at. Bumped corgi pin 9b41cdc -> f556868 (survey/group_bounds + hash_order
reverted).

Note on times: survey's Both is a positional (key,val) match, so it can
transiently mis-order/under-consolidate the out-of-band times; advance re-sorts +
re-consolidates each (key,val) group before any consumer reads the chunk, so it's
correct end-to-end (gate 6/6 + 29 lib tests incl. merge/advance/is_graded oracle).

SCC: 1.94x -> 1.62x vec (n=100k 6.55s -> 5.43s, ~17% off corgi). Branch
corgi-survey-merge.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 corgi-kernel-findings-scc.md   | 120 +++++++++++++++++++++++++++++++++
 interactive/Cargo.toml         |   2 +-
 interactive/src/corgi_chunk.rs |  91 +++++++++++++------------
 3 files changed, 166 insertions(+), 47 deletions(-)
 create mode 100644 corgi-kernel-findings-scc.md

diff --git a/corgi-kernel-findings-scc.md b/corgi-kernel-findings-scc.md
new file mode 100644
index 000000000..586c5ab79
--- /dev/null
+++ b/corgi-kernel-findings-scc.md
@@ -0,0 +1,120 @@
+# Corgi kernel findings — SCC on the DDIR corgi backend (2026-07-11)
+
+Profile-grounded asks for the corgi kernel, from an `samply` capture of `interactive`'s SCC
+(`corgi_scc_prof`, N=1000, ITERS=200, corgi backend, baseline `corgi-on-mn @ 8681e193`, arm64).
+19,537 samples @ 1kHz. The corgi backend is a cursor-less `Chunk` arrangement: keys/vals are corgi
+`Value` columns (`Prod([keys, vals])`), and merge/advance/sort drive ordering through corgi's
+structural-compare + discrimination-sort kernels.
+
+**Headline:** on SCC (corgi's worst case — control-heavy, compute-light, tiny integer keys, unit
+values), the dominant *corgi* cost is **structural comparison + discrimination sort**, not compute
+and not (as I'd earlier guessed) column allocation. Numbers below are the honest split.
+
+---
+
+## 1. Structural compare / discrimination sort — the big corgi lever (~20% of total)
+
+| corgi fn | self % | total % | driven from |
+|---|---|---|---|
+| `ops::cmp::order::compare::compare_idx` | 4.0 | **14.7** | `CorgiChunk::merge` (merge_batcher) + `CorgiChunk::advance` (spine compaction) |
+| `ops::cmp::order::discriminate::sort_blocks` | 0.1 | 6.0 | `sort_consolidate` → `sort_perm` |
+| `ops::cmp::order::discriminate::sort_leaf_blocks` | 3.2 | 5.4 | (under `sort_blocks`) |
+| `value::Prim::cmp_idx` | 1.4 | 3.2 | (leaf under `compare_idx`) |
+| `ops::cmp::CmpOp::eval` | 1.4 | 3.5 | |
+
+Call context (from stacks): `compare_idx` is almost entirely **arrangement maintenance** —
+`CorgiChunk::merge` (the two-pointer merge's per-pair `(key,val)` compare) and `CorgiChunk::advance`
+(the compaction's group-boundary scan). It **recurses through the `Prod([key,val])` structure per
+comparison** (`compare_idx → compare_idx → Prim::cmp_idx`), i.e. it re-walks the product shape and
+re-dispatches to the leaf on every comparison. For SCC the keys are a single `Prim(64)` (a graph
+node id), so this is a lot of shape-walking to reach one `u64` compare.
+
+**Ask — radix / flat sort-key at the leaves.** This is the known "compare_idx interpreted-comparison
+tax" axis. Precompute a **flat, radix-friendly sort-key column once** per chunk (or expose a kernel
+that does), so that:
+- merge run-head compares read a `u64`/byte directly instead of re-walking `Prod` + dispatching per
+  comparison, and
+- `from_unsorted` / `sort_perm` can **radix-sort** (O(n), skip comparison) instead of
+  comparison-sort (`sort_leaf_blocks` + `compare_idx`).
+
+For primitive keys this could go from ~20% to near-nothing (a `u64` radix), and it's a general win
+(not SCC-specific): every arrangement merge/consolidate in every DDIR program pays this tax. The
+backend already leans on `compare_idx`/`sort_perm`/`sort_blocks` as the ordering primitives, so a
+flat-sort-key variant (or a `radix_sort_perm(col) -> perm` + `compare_prekey(prekey, ia, ib)`)
+slots in without a backend redesign.
+
+**Confirmed to GROW with scale (N=100000 profile, /tmp/scc_corgi_bigN.json.gz, 42.8k samples):**
+`compare_idx` rises **14.7% → 21.9%** total (5.2% self), now driven overwhelmingly by
+**`CorgiChunk::merge` = 22% total** (the arrangement merge, which was not even top-10 at N=1000).
+`sort_leaf_blocks` 5.4% → 6.3%. So the structural-order machinery is ~28% of total at N=100k and
+climbing — this is *the* corgi lever, and it gets bigger at the sizes Frank actually runs (n=1m).
+
+## 2. Column re-gather — real but smaller (~4–5% of total)
+
+| corgi fn | self % | total % |
+|---|---|---|
+| `engine::gather_lanes` | 0.1 | 3.0 |
+| `value::Prim::gather_lanes` | 1.0 | 1.3 |
+| `engine::gather` / `Prim::gather` | 0.5 | 0.6 |
+
+Every `merge`/`advance`/`present`/`settle` builds a **new** column via `gather`/`gather_lanes`
+(fresh `Arc<Vec>`), re-materializing the repeated key column. This is the "flat SoA re-gathered per
+merge" axis. It's a smaller bucket than I'd initially estimated — **not** the dominant allocation
+(see the correction below) — but it's pure churn: the merge output's key column is a permutation/
+concatenation of inputs we already hold.
+
+**Ask (secondary):** cheap column *views*/*slices* and/or in-place gather, so the merge/advance
+paths can reorder/concatenate without allocating a fresh backing `Vec` each time. Lower priority
+than (1).
+
+## Allocation attribution (malloc ≈ 43% of samples)
+
+An earlier note of mine attributed ~32% of runtime to "corgi column churn." **The profile does not
+support that** — corgi's own `gather*` is only ~4–5%. The `malloc` is not diffuse once attributed;
+it's a handful of identifiable sites (percentages are *total* samples; they overlap in their
+descendant `malloc`, so they don't sum to 43%):
+
+| allocating site | total % | owner | notes |
+|---|---|---|---|
+| `SmallVec::extend` (PointStamp materialization) | 10.7 | backend/framework | timestamps; partly addressed by `ColTimes`, rest is reduce/compaction |
+| `corgi_chunk::sort_consolidate` | 7.7 | **backend (ours)** | fresh perm + reordered `times_s`/`diffs_s`/`keep` per consolidate; **same code that pays item-1 compare/sort CPU** |
+| `consolidate_updates_slice_slow` (reduce **bridge**) | 7.7 | **tactic-facing** | the `Vec<((u64,u64),T,R)>` consolidation — replaced by the columnar `ProxyBridgeBuilder`/`from_unsorted` |
+| `ValueHistory::build` (replay) | 3.4 | **tactic** | columnarized in `fm/int-proxy-columnar` `history.rs` |
+| `gather` / `gather_lanes` (corgi columns) | ~4–5 | **corgi** | item 2 above |
+| `register_keys`/`register_vals` + hashbrown rehash | <1 | backend | IdMaps |
+
+`RawVec::finish_grow` (6.8%) + `grow_one` (5.9%) are the `malloc`-under-Vec-growth *inside* the rows
+above, not a separate bucket.
+
+**Reading for each owner:**
+- **corgi:** biggest lever is compare/sort CPU (item 1), not allocation (gather is ~4–5%). A radix
+  sort-key (item 1) also removes `sort_consolidate`'s permutation allocation — the one place the
+  corgi ask and a backend cleanup compound.
+- **tactic (int_proxy):** the reduce-bridge `consolidate_updates` (7.7%) and `ValueHistory` (3.4%)
+  are *exactly* what the columnar bridge (`fm/int-proxy-columnar`) already targets. Nothing new to
+  build — but the payoff is **N- and workload-dependent**: at N=1000 (this profile) they're ~11%
+  combined; at large N the arrangement dominates and they shrink; on shallow-time programs the
+  columnar machinery's overhead outweighs the alloc removed. A shallow-time fast-path is the open
+  item there. **Confirmed at N=100000:** the bridge `consolidate_updates` shrinks 7.7% → 5.4% and
+  `ValueHistory::build` 3.4% → 1.9% (combined 11% → 7.3%) as the arrangement merge (22%) takes over
+  — so the columnar bridge's payoff genuinely fades with scale, and a shallow-time fast-path (not
+  more columnar machinery) is the right investment for the tactic. Also new at scale:
+  `collect_present` (OUR reduce present's changed-key scan over accumulated history) rises to 10.8%
+  total / **8.3% self** — a backend O(history) semijoin cost worth its own look.
+- **backend (ours):** `sort_consolidate` (7.7%) is ours to cut via buffer reuse (and it rides the
+  corgi radix-key win).
+
+## What NOT to change (backend-side, not corgi's problem)
+
+- Timestamp materialization (`PointStamp` `try_grow`, ~11%) is the DDIR backend's job — already
+  partly addressed by columnar times (`ColTimes`), the rest is reduce-tactic/compaction work.
+- `CorgiChunk::advance` (13.3% total) and the reduce `retire` (50% total) are backend/framework;
+  corgi appears inside them only via items 1 & 2 above.
+
+## Reference
+
+- Backend: `interactive/src/corgi_chunk.rs` (merge/advance/sort_consolidate — the `compare_idx` /
+  `sort_perm` callers), `interactive/src/corgi_reduce_backend.rs`.
+- Kernels of interest: `compare_idx`, `sort_perm`, `sort_blocks`, `sort_leaf_blocks`, `gather`,
+  `gather_lanes` in the corgi crate.
+- Profile: `/tmp/scc_corgi.json.gz` (Firefox format; `samply load` or pollard).
diff --git a/interactive/Cargo.toml b/interactive/Cargo.toml
index c4c64434d..0cb3fd4ba 100644
--- a/interactive/Cargo.toml
+++ b/interactive/Cargo.toml
@@ -15,7 +15,7 @@ workspace = true
 columnar = { workspace = true }
 # Local dev: `path = "../../wip/corgi"`. Pinned to a git rev so the branch builds standalone
 # (frankmcsherry/wip @ dd-arrange-api) — see int-proxy-columnar-findings.md.
-corgi = { git = "https://github.com/frankmcsherry/wip", rev = "9b41cdc4cd070a98f5a82d412cf19ac48f8e88cb" }
+corgi = { git = "https://github.com/frankmcsherry/wip", rev = "f556868b7b13de19b969bb0eb810c7ffacbb515f" }
 differential-dataflow = { workspace = true }
 mimalloc = "0.1.48"
 serde = { version = "1.0", features = ["derive"] }
diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index b5d2144fc..c50ca9f96 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -29,7 +29,7 @@ use differential_dataflow::difference::Semigroup;
 use differential_dataflow::trace::chunk::{merge_chains, pack, Chunk, ChunkBatch};
 use differential_dataflow::trace::Description;
 
-use corgi::arrange::{compare_at, compare_idx, find_ranges, gather, gather_lanes, sort_perm};
+use corgi::arrange::{compare_idx, find_ranges, gather, gather_lanes, group_bounds, sort_perm, survey, Run};
 use corgi::Value as CValue;
 
 use columnar::Columnar;
@@ -152,51 +152,54 @@ where
 
     fn len(&self) -> usize { self.0.times.len() }
 
-    /// Two-pointer merge of the two front chunks through their shared horizon, consolidating equal
-    /// `(key, val, time)` triples. Accumulates `(tag, off)` against the two stable source kv columns
-    /// and materializes output via `gather_lanes`; the survivor's suffix is pushed back once.
+    /// Merge the two front chunks via corgi `survey`: one bidirectional gallop over the `(key, val)`
+    /// columns yields `Run`s — maximal exclusive ranges (`A`/`B`, bulk-copied, no per-row compare) and
+    /// single matched pairs (`Both`, ordered/consolidated by `time` here, since corgi owns no time).
+    /// Both chunks are consumed fully into one output run (no suffix push-back).
+    ///
+    /// NOTE on times: `Both(ia, ib)` is a *positional* `(key, val)` match. For a `(key, val)` that
+    /// recurs at multiple times with unequal per-side counts, positional pairing can mis-order the
+    /// out-of-band times — this is the survey/time composition edge the gate is checking.
     fn merge(in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>) {
         let c1 = in1.pop_front().unwrap();
         let c2 = in2.pop_front().unwrap();
         let (kv1, kv2) = (c1.kv(), c2.kv());
-        let (n1, n2) = (c1.len_(), c2.len_());
         let (t1, d1) = (c1.times(), c1.diffs());
         let (t2, d2) = (c2.times(), c2.diffs());
 
         let (mut tags, mut offs) = (Vec::new(), Vec::new());
         let (mut times, mut diffs) = (ColTimes::new(), Vec::new());
-        let (mut p1, mut p2) = (0usize, 0usize);
-        while p1 < n1 && p2 < n2 {
-            // `(key, val)` structurally, then `time` in place via the columnar `Ref: Ord`.
-            let ord = compare_at(&kv1, p1, &kv2, p2).then_with(|| t1.cmp_cross(p1, t2, p2));
-            match ord {
-                Ordering::Less => { tags.push(0); offs.push(p1); times.push_ref(t1, p1); diffs.push(d1[p1].clone()); p1 += 1; }
-                Ordering::Greater => { tags.push(1); offs.push(p2); times.push_ref(t2, p2); diffs.push(d2[p2].clone()); p2 += 1; }
-                Ordering::Equal => {
-                    let mut d = d1[p1].clone();
-                    d.plus_equals(&d2[p2]);
-                    if !d.is_zero() { tags.push(0); offs.push(p1); times.push_ref(t1, p1); diffs.push(d); }
-                    p1 += 1; p2 += 1;
+        for run in survey(&kv1, &kv2) {
+            match run {
+                Run::A(lo, hi) => {
+                    for p in lo..hi { tags.push(0); offs.push(p); times.push_ref(t1, p); diffs.push(d1[p].clone()); }
+                }
+                Run::B(lo, hi) => {
+                    for p in lo..hi { tags.push(1); offs.push(p); times.push_ref(t2, p); diffs.push(d2[p].clone()); }
+                }
+                Run::Both(ia, ib) => {
+                    // Equal `(key, val)`; order/consolidate by time.
+                    match t1.cmp_cross(ia, t2, ib) {
+                        Ordering::Less => {
+                            tags.push(0); offs.push(ia); times.push_ref(t1, ia); diffs.push(d1[ia].clone());
+                            tags.push(1); offs.push(ib); times.push_ref(t2, ib); diffs.push(d2[ib].clone());
+                        }
+                        Ordering::Greater => {
+                            tags.push(1); offs.push(ib); times.push_ref(t2, ib); diffs.push(d2[ib].clone());
+                            tags.push(0); offs.push(ia); times.push_ref(t1, ia); diffs.push(d1[ia].clone());
+                        }
+                        Ordering::Equal => {
+                            let mut d = d1[ia].clone();
+                            d.plus_equals(&d2[ib]);
+                            if !d.is_zero() { tags.push(0); offs.push(ia); times.push_ref(t1, ia); diffs.push(d); }
+                        }
+                    }
                 }
             }
         }
 
         let srcs = [Some(&kv1), Some(&kv2)];
         Self::emit(&srcs, &tags, &offs, &times, &diffs, out);
-
-        // Push back the survivor's unconsumed suffix (all `>` the horizon), ahead of its deque.
-        if p1 < n1 {
-            let idx: Vec<usize> = (p1..n1).collect();
-            let mut t = ColTimes::new();
-            t.push_range(t1, p1, n1);
-            in1.push_front(Self::from_kv(gather(&kv1, &idx), t, d1[p1..].to_vec()));
-        }
-        if p2 < n2 {
-            let idx: Vec<usize> = (p2..n2).collect();
-            let mut t = ColTimes::new();
-            t.push_range(t2, p2, n2);
-            in2.push_front(Self::from_kv(gather(&kv2, &idx), t, d2[p2..].to_vec()));
-        }
     }
 
     fn extract(
@@ -243,20 +246,17 @@ where
         let n = ctimes.len();
         if n == 0 { return; }
 
-        // Giant-key case: whole buffer is one `(key, val)` → no group provably complete.
-        if !done && compare_at(&ckv, 0, &ckv, n - 1) == Ordering::Equal {
+        // Group boundaries in ONE pass (corgi `group_bounds`) instead of a per-row `compare_at` scan.
+        let bounds = group_bounds(&ckv); // exclusive group ends, ascending, `bounds.last() == n`
+
+        // Giant-key case: a single group spanning the whole buffer → no group provably complete.
+        if !done && bounds.len() == 1 {
             input.push_front(Self::from_kv(ckv, ctimes, cdiffs));
             return;
         }
 
-        // Withhold the trailing group as the carry unless `done`.
-        let end = if done {
-            n
-        } else {
-            let mut start = n;
-            while start > 0 && compare_at(&ckv, start - 1, &ckv, n - 1) == Ordering::Equal { start -= 1; }
-            start
-        };
+        // Withhold the trailing group as the carry unless `done` (its start = the 2nd-to-last end).
+        let end = if done { n } else { bounds[bounds.len() - 2] };
         if end < n {
             let idx: Vec<usize> = (end..n).collect();
             let mut ct = ColTimes::new();
@@ -272,10 +272,9 @@ where
         let (mut tags, mut offs) = (Vec::new(), Vec::new());
         let (mut otimes, mut odiffs): (ColTimes<T>, Vec<R>) = (ColTimes::new(), Vec::new());
         let mut i = 0;
-        while i < end {
-            let mut j = i;
-            while j < end && compare_at(&ckv, i, &ckv, j) == Ordering::Equal { j += 1; }
-            let mut pairs: Vec<(T, R)> = (i..j)
+        for &g_end in &bounds {
+            if g_end > end { break; }
+            let mut pairs: Vec<(T, R)> = (i..g_end)
                 .map(|k| { let mut t = ctimes.get(k); t.advance_by(frontier); (t, cdiffs[k].clone()) })
                 .collect();
             pairs.sort_by(|a, b| a.0.cmp(&b.0));
@@ -293,7 +292,7 @@ where
                     }
                 }
             }
-            i = j;
+            i = g_end;
         }
         if !otimes.is_empty() { Self::emit(&srcs, &tags, &offs, &otimes, &odiffs, out); }
     }

From a12e43e19edc40a8184cd234cec17e6451a6d812 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 08:18:58 -0400
Subject: [PATCH 45/68] collect_present: keep the scan (find_ranges seek
 regresses SCC)

Tried a delta-proportional find_ranges seek of the changed keys (value-as-id
makes them seekable in structural order). It REGRESSED SCC 1.62x->2.16x: SCC's
changed set is broad (label propagation touches most keys each retire), so the
scan already touches ~every row while the per-chunk gallop only adds overhead.
Reverted to the scan; simplified the signature to `changed: &[u64]` and recorded
the negative result in the doc so it isn't re-tried. Gate 6/6.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 8e3d4b371..39eaa5fc2 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -176,12 +176,18 @@ fn ids(col: &CValue) -> Vec<u64> {
     }
 }
 
-/// Concatenate selected records across a run of chunks into parallel `(keys_col, vals_col)` corgi
-/// columns plus per-record `(key_hash, time, diff)`. `keep(kh)` decides inclusion by key hash.
-fn collect_present<T, F>(chunks: &[&CorgiChunk<T, Diff>], mut keep: F) -> (CValue, CValue, Vec<u64>, Vec<T>, Vec<Diff>)
+/// Concatenate the records of the `changed` keys across a run of chunks into parallel
+/// `(keys_col, vals_col)` corgi columns plus per-record `(key_hash, time, diff)`. `changed` is the
+/// ASCENDING set of changed key hashes; a row is kept iff its key hash is in it.
+///
+/// NB this is a full scan of the presented chunks (incl. `source_batches`, the accumulated trace).
+/// A `find_ranges` seek of the changed keys was tried (delta-proportional in principle) but REGRESSED
+/// SCC (1.62x→2.16x): SCC's changed set is broad (label propagation touches most keys each retire), so
+/// the scan already touches ~every row while the per-chunk gallop only adds overhead. The O(history)
+/// re-presentation is inherent to SCC here, not a seekable-few-keys case.
+fn collect_present<T>(chunks: &[&CorgiChunk<T, Diff>], changed: &[u64]) -> (CValue, CValue, Vec<u64>, Vec<T>, Vec<Diff>)
 where
     T: ColTime,
-    F: FnMut(u64) -> bool,
 {
     let key_srcs: Vec<Option<&CValue>> = chunks.iter().map(|c| Some(c.keys())).collect();
     let val_srcs: Vec<Option<&CValue>> = chunks.iter().map(|c| Some(c.vals())).collect();
@@ -190,7 +196,7 @@ where
     for (ci, ch) in chunks.iter().enumerate() {
         let kh = ids(ch.keys());
         for i in 0..kh.len() {
-            if keep(kh[i]) {
+            if changed.binary_search(&kh[i]).is_ok() {
                 tags.push(ci);
                 offs.push(i);
                 khs.push(kh[i]);
@@ -392,7 +398,7 @@ where
         }
         let keys: Vec<u64> = changed[*cursor..].to_vec();
         *cursor = changed.len();
-        let present = |chunks: &[&CorgiChunk<T, Diff>]| collect_present(chunks, |h| keys.binary_search(&h).is_ok());
+        let present = |chunks: &[&CorgiChunk<T, Diff>]| collect_present(chunks, &keys);
 
         // Input presentation: accumulated history ∪ novel delta, restricted to the window's keys.
         // value_id = content hash of the value (equal values share an id → the tactic nets them);

From 96c7782ef94f7a0fd232a1179d7deaf63db16775 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 08:24:53 -0400
Subject: [PATCH 46/68] Hash unification: compound ids via native corgi::hash,
 not arrange::hash_rows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The `ids()` compound fallback now hashes via the canonical native `corgi::hash`
(the designed boundary-id fold — width-blind, consistent-with-equality) instead
of the branch-local `arrange::hash_rows` (width-seeded). Safe for DDIR: every leaf
transcodes to u64 so width-blindness is a no-op, and there is no cross-path hash
comparison (value-as-id for primitives and native hash for compounds are never
used for the same value — shape is uniform per column). DDIR no longer references
hash_rows, so the corgi side can retire it freely. Gate 6/6 (incl. compound-keyed
adt/binders/unnest), 29 lib tests.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_reduce_backend.rs | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi_reduce_backend.rs
index 39eaa5fc2..f1df55db6 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi_reduce_backend.rs
@@ -3,9 +3,9 @@
 //! The tactic (differential's `operators::int_proxy::reduce`) owns ALL time/lattice logic over
 //! integer proxies `(key_hash, value_id, time, diff)`; this backend supplies only:
 //!
-//!   * hashing — `key_hash`/`value_id` are corgi `hash_rows` over the corgi key/val COLUMNS
-//!     (columnar, content-addressed, so ids coincide across the output→input boundary); DD never
-//!     hashes.
+//!   * ids — `key_hash`/`value_id` are value-as-id for primitive columns (the value IS the id) and
+//!     the canonical native `corgi::hash` for compound columns (columnar, content-addressed, so ids
+//!     coincide across the output→input boundary); DD never hashes.
 //!   * the value callback — `reduce_many` runs ONE crossing per retire over every `(key, time)`
 //!     bracket, building the output value COLUMNS directly (Count → a `u64` prim, Distinct → a
 //!     `Unit`, Min → the chosen input rows, Collect → a `List`), never through DDIR rows.
@@ -37,7 +37,7 @@ use differential_dataflow::trace::chunk::ChunkBatch;
 use differential_dataflow::operators::int_proxy::ProxyBridge;
 use differential_dataflow::operators::int_proxy::reduce::{ProxyReduceBackend, ReduceInstance, ReduceWindow};
 
-use corgi::arrange::{gather, gather_lanes, hash_rows, sort_blocks};
+use corgi::arrange::{gather, gather_lanes, sort_blocks};
 use corgi::{Bounds, Shape, Value as CValue};
 
 use crate::col_times::ColTime;
@@ -159,12 +159,15 @@ fn concat_columns(blocks: &[CValue]) -> CValue {
 
 /// Id column for a key/value column. For a PRIMITIVE column — a bare 64-bit `Prim`, or a 1-field
 /// `Prod([Prim(64)])` — the value itself is already a collision-free id (`i64 as u64` is a bijection),
-/// so pass it straight through and skip the `hash_rows` content hash. Compound shapes (Unit / List /
-/// Sum / multi-field `Prod`) still hash. The id is used ONLY as an identity for netting/dedup — its
-/// numeric order is never relied upon — so the raw two's-complement `u64` is correct even for negative
-/// ints (no order-preserving swizzle needed). Must be applied CONSISTENTLY at every id site (both
-/// value presentations AND the freshly-produced `reduce_brackets` outputs), else `desired − current`
-/// nets across mismatched ids for the same value.
+/// so pass it straight through and skip the content hash. Compound shapes (Unit / List / Sum /
+/// multi-field `Prod`) hash via the CANONICAL native `corgi::hash` (the designed boundary-id fold,
+/// width-blind and consistent-with-equality) — not the branch-local `arrange::hash_rows`; DDIR
+/// transcodes every leaf to `u64`, so width-blindness is a no-op for us and there is no cross-path
+/// hash comparison (value-as-id and native hash are never used for the same value: shape is uniform
+/// per column). The id is used ONLY as an identity for netting/dedup — its numeric order is never
+/// relied upon — so the raw two's-complement `u64` is correct even for negative ints (no swizzle).
+/// Applied CONSISTENTLY at every id site (both value presentations AND the freshly-produced
+/// `reduce_brackets` outputs), else `desired − current` nets across mismatched ids for the same value.
 fn ids(col: &CValue) -> Vec<u64> {
     match corgi::shape_of_value(col) {
         Shape::Prim(64) => col.clone().into_u64("ids"),
@@ -172,7 +175,7 @@ fn ids(col: &CValue) -> Vec<u64> {
             CValue::Prod(fields) => fields[0].clone().into_u64("ids"),
             _ => unreachable!("shape Prod but value not Prod"),
         },
-        _ => hash_rows(col),
+        _ => corgi::hash(col).into_u64("ids"),
     }
 }
 

From 7b2a6ff844401689029e95724716e91c919df4db Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 09:31:03 -0400
Subject: [PATCH 47/68] =?UTF-8?q?Revert=20the=20survey=20merge=20=E2=80=94?=
 =?UTF-8?q?=20it=20bloats=20the=20arrangement=20at=20multi-chunk=20scale?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The survey merge (17ff06d0) was a single-chunk MIRAGE. survey aligns only
(key,val) (corgi owns no time), so its positional Both under-consolidates
cross-side times; combined with consuming both chunks and no suffix push-back, it
leaves canceling rows in the arrangement. Single-chunk (n<=100k) it looked like a
win (SCC 1.94->1.62x, compare_idx 21.9->8.9%), but past the chunk boundary
(edges e=2n cross TARGET=262144 at n~131k) the un-consolidated arrangement BLOATS
every iteration and the reduce re-presents ever-growing input -> super-linear
(n=150k: 104.9s / 19.5x vec vs 9.9s / 2.08x with two-pointer). Profile smoking
gun: retire 96%, consolidate_updates 24.8% + quicksort 22.7% + collect_present
17% — the REDUCE drowning in bloated input, not the merge itself.

Restored the two-pointer merge (full (key,val,time) consolidation + survivor
push-back). Kept group_bounds in advance (perf-neutral but a clean one-pass scan;
doesn't touch consolidation). Back to ~1.96x vec, LINEAR to n=250k. A survey merge
needs a group-RANGE Both to compose with out-of-band times — flagged to corgi.

Gate 6/6. corgi pin stays f556868 (group_bounds + native corgi::hash).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 interactive/src/corgi_chunk.rs | 70 +++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 34 deletions(-)

diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi_chunk.rs
index c50ca9f96..35473d4dd 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi_chunk.rs
@@ -29,7 +29,7 @@ use differential_dataflow::difference::Semigroup;
 use differential_dataflow::trace::chunk::{merge_chains, pack, Chunk, ChunkBatch};
 use differential_dataflow::trace::Description;
 
-use corgi::arrange::{compare_idx, find_ranges, gather, gather_lanes, group_bounds, sort_perm, survey, Run};
+use corgi::arrange::{compare_at, compare_idx, find_ranges, gather, gather_lanes, group_bounds, sort_perm};
 use corgi::Value as CValue;
 
 use columnar::Columnar;
@@ -152,54 +152,56 @@ where
 
     fn len(&self) -> usize { self.0.times.len() }
 
-    /// Merge the two front chunks via corgi `survey`: one bidirectional gallop over the `(key, val)`
-    /// columns yields `Run`s — maximal exclusive ranges (`A`/`B`, bulk-copied, no per-row compare) and
-    /// single matched pairs (`Both`, ordered/consolidated by `time` here, since corgi owns no time).
-    /// Both chunks are consumed fully into one output run (no suffix push-back).
-    ///
-    /// NOTE on times: `Both(ia, ib)` is a *positional* `(key, val)` match. For a `(key, val)` that
-    /// recurs at multiple times with unequal per-side counts, positional pairing can mis-order the
-    /// out-of-band times — this is the survey/time composition edge the gate is checking.
+    /// Two-pointer merge of the two front chunks through their shared horizon, FULLY consolidating
+    /// equal `(key, val, time)` triples and pushing back the survivor's suffix (the fueled-merger
+    /// contract). Reverted from a `survey`-based merge: survey aligns only `(key, val)` (corgi owns no
+    /// time), so its positional `Both` under-consolidates cross-side times, and — consuming both chunks
+    /// with no push-back — bloats the multi-chunk arrangement, which the reduce then re-presents each
+    /// retire → super-linear past the chunk boundary (n≳131k). A survey merge needs a group-RANGE
+    /// `Both` (both sides' full equal-`(key,val)` group) to time-merge correctly; the corgi agent has
+    /// that flagged. `group_bounds` in `advance` is kept (it doesn't touch consolidation).
     fn merge(in1: &mut VecDeque<Self>, in2: &mut VecDeque<Self>, out: &mut VecDeque<Self>) {
         let c1 = in1.pop_front().unwrap();
         let c2 = in2.pop_front().unwrap();
         let (kv1, kv2) = (c1.kv(), c2.kv());
+        let (n1, n2) = (c1.len_(), c2.len_());
         let (t1, d1) = (c1.times(), c1.diffs());
         let (t2, d2) = (c2.times(), c2.diffs());
 
         let (mut tags, mut offs) = (Vec::new(), Vec::new());
         let (mut times, mut diffs) = (ColTimes::new(), Vec::new());
-        for run in survey(&kv1, &kv2) {
-            match run {
-                Run::A(lo, hi) => {
-                    for p in lo..hi { tags.push(0); offs.push(p); times.push_ref(t1, p); diffs.push(d1[p].clone()); }
-                }
-                Run::B(lo, hi) => {
-                    for p in lo..hi { tags.push(1); offs.push(p); times.push_ref(t2, p); diffs.push(d2[p].clone()); }
-                }
-                Run::Both(ia, ib) => {
-                    // Equal `(key, val)`; order/consolidate by time.
-                    match t1.cmp_cross(ia, t2, ib) {
-                        Ordering::Less => {
-                            tags.push(0); offs.push(ia); times.push_ref(t1, ia); diffs.push(d1[ia].clone());
-                            tags.push(1); offs.push(ib); times.push_ref(t2, ib); diffs.push(d2[ib].clone());
-                        }
-                        Ordering::Greater => {
-                            tags.push(1); offs.push(ib); times.push_ref(t2, ib); diffs.push(d2[ib].clone());
-                            tags.push(0); offs.push(ia); times.push_ref(t1, ia); diffs.push(d1[ia].clone());
-                        }
-                        Ordering::Equal => {
-                            let mut d = d1[ia].clone();
-                            d.plus_equals(&d2[ib]);
-                            if !d.is_zero() { tags.push(0); offs.push(ia); times.push_ref(t1, ia); diffs.push(d); }
-                        }
-                    }
+        let (mut p1, mut p2) = (0usize, 0usize);
+        while p1 < n1 && p2 < n2 {
+            // `(key, val)` structurally, then `time` in place via the columnar `Ref: Ord`.
+            let ord = compare_at(&kv1, p1, &kv2, p2).then_with(|| t1.cmp_cross(p1, t2, p2));
+            match ord {
+                Ordering::Less => { tags.push(0); offs.push(p1); times.push_ref(t1, p1); diffs.push(d1[p1].clone()); p1 += 1; }
+                Ordering::Greater => { tags.push(1); offs.push(p2); times.push_ref(t2, p2); diffs.push(d2[p2].clone()); p2 += 1; }
+                Ordering::Equal => {
+                    let mut d = d1[p1].clone();
+                    d.plus_equals(&d2[p2]);
+                    if !d.is_zero() { tags.push(0); offs.push(p1); times.push_ref(t1, p1); diffs.push(d); }
+                    p1 += 1; p2 += 1;
                 }
             }
         }
 
         let srcs = [Some(&kv1), Some(&kv2)];
         Self::emit(&srcs, &tags, &offs, &times, &diffs, out);
+
+        // Push back the survivor's unconsumed suffix (all `>` the horizon), ahead of its deque.
+        if p1 < n1 {
+            let idx: Vec<usize> = (p1..n1).collect();
+            let mut t = ColTimes::new();
+            t.push_range(t1, p1, n1);
+            in1.push_front(Self::from_kv(gather(&kv1, &idx), t, d1[p1..].to_vec()));
+        }
+        if p2 < n2 {
+            let idx: Vec<usize> = (p2..n2).collect();
+            let mut t = ColTimes::new();
+            t.push_range(t2, p2, n2);
+            in2.push_front(Self::from_kv(gather(&kv2, &idx), t, d2[p2..].to_vec()));
+        }
     }
 
     fn extract(

From 57682f09cb00c89442e7963a89fecace989db4a3 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 10:19:32 -0400
Subject: [PATCH 48/68] Fair compiled SCC baseline: strongly_connected_at +
 four-way corgi_scc_big
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds scc::strongly_connected_at(graph, logic) — the prioritized variant the
code comment always suggested — routing trim_edges through propagate_at so
label introduction is log-bucketed 256*(64-lz(logic(label))), byte-identical
to DDIR's enter_at($1[0]) delay in vec.rs/corgi.rs. strongly_connected is
unchanged (= strongly_connected_at(_, |_| 0)).

Oracle-tested: tests/scc.rs gains scc_at_{10_20_1000,100_200_10,100_2000_1}
running the prioritized variant against the sequential SCC oracle (incl. 1000
incremental rounds); all 6 pass.

corgi_scc_big gains the fair(enter_at) column. Measured (arm64, e=2n):
  n=100k: native 4.16s, fair 0.62s (0.15x nat), vec 3.06s (4.95x fair), corgi 5.94s (9.61x fair, 1.94x vec)
  n=150k: native 7.42s, fair 0.95s (0.13x nat), vec 4.83s (5.08x fair), corgi 9.90s (10.41x fair, 2.05x vec)
The compiled target was ~6.7x closer than the plain-native column suggested.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/algorithms/graphs/scc.rs              | 30 ++++++++++++++-----
 differential-dataflow/tests/scc.rs            | 24 +++++++++++----
 interactive/examples/corgi_scc_big.rs         | 30 +++++++++++++++----
 3 files changed, 66 insertions(+), 18 deletions(-)

diff --git a/differential-dataflow/src/algorithms/graphs/scc.rs b/differential-dataflow/src/algorithms/graphs/scc.rs
index c66f93ba3..32477c52a 100644
--- a/differential-dataflow/src/algorithms/graphs/scc.rs
+++ b/differential-dataflow/src/algorithms/graphs/scc.rs
@@ -9,7 +9,7 @@ use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
 use crate::difference::{Abelian, Multiply};
 
-use super::propagate::propagate;
+use super::propagate::propagate_at;
 
 /// Returns the subset of edges in the same strongly connected component.
 pub fn strongly_connected<'scope, T, N, R>(graph: VecCollection<'scope, T, (N,N), R>) -> VecCollection<'scope, T, (N,N), R>
@@ -19,6 +19,23 @@ where
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>
+{
+    strongly_connected_at(graph, |_| 0)
+}
+
+/// Returns the subset of edges in the same strongly connected component.
+///
+/// This variant introduces node labels in rounds indicated by `logic`, as in `propagate_at`:
+/// small labels can complete their propagation before larger labels are introduced, which can
+/// substantially reduce the total work performed.
+pub fn strongly_connected_at<'scope, T, N, R, F>(graph: VecCollection<'scope, T, (N,N), R>, logic: F) -> VecCollection<'scope, T, (N,N), R>
+where
+    T: Timestamp + Lattice + Hash,
+    N: ExchangeData + Hash,
+    R: ExchangeData + Abelian,
+    R: Multiply<R, Output=R>,
+    R: From<i8>,
+    F: Fn(&N)->u64+Clone+'static,
 {
     use timely::order::Product;
     let outer = graph.scope();
@@ -30,20 +47,21 @@ where
         use crate::operators::iterate::Variable;
         let (variable, inner) = Variable::new_from(edges.clone(), Product::new(Default::default(), 1));
 
-        let result = trim_edges(trim_edges(inner, edges), trans);
+        let result = trim_edges(trim_edges(inner, edges, logic.clone()), trans, logic);
         variable.set(result.clone());
         result.leave(outer)
     })
 }
 
-fn trim_edges<'scope, T, N, R>(cycle: VecCollection<'scope, T, (N,N), R>, edges: VecCollection<'scope, T, (N,N), R>)
+fn trim_edges<'scope, T, N, R, F>(cycle: VecCollection<'scope, T, (N,N), R>, edges: VecCollection<'scope, T, (N,N), R>, logic: F)
     -> VecCollection<'scope, T, (N,N), R>
 where
     T: Timestamp + Lattice + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
-    R: From<i8>
+    R: From<i8>,
+    F: Fn(&N)->u64+Clone+'static,
 {
     let outer = edges.inner.scope();
     outer.region_named("TrimEdges", |region| {
@@ -54,9 +72,7 @@ where
                          .map_in_place(|x| x.0 = x.1.clone())
                          .consolidate();
 
-        // NOTE: With a node -> int function, can be improved by:
-        // let labels = propagate_at(&cycle, &nodes, |x| *x as u64);
-        let labels = propagate(cycle, nodes).arrange_by_key();
+        let labels = propagate_at(cycle, nodes, logic).arrange_by_key();
 
         edges.arrange_by_key()
              .join_core(labels.clone(), |e1,e2,l1| [(e2.clone(),(e1.clone(),l1.clone()))])
diff --git a/differential-dataflow/tests/scc.rs b/differential-dataflow/tests/scc.rs
index c1e702ff7..306299ed1 100644
--- a/differential-dataflow/tests/scc.rs
+++ b/differential-dataflow/tests/scc.rs
@@ -19,11 +19,17 @@ use differential_dataflow::lattice::Lattice;
 type Node = usize;
 type Edge = (Node, Node);
 
-#[test] fn scc_10_20_1000() { test_sizes(10, 20, 1000, Config::process(3)); }
-#[test] fn scc_100_200_10() { test_sizes(100, 200, 10, Config::process(3)); }
-#[test] fn scc_100_2000_1() { test_sizes(100, 2000, 1, Config::process(3)); }
+#[test] fn scc_10_20_1000() { test_sizes(10, 20, 1000, Config::process(3), false); }
+#[test] fn scc_100_200_10() { test_sizes(100, 200, 10, Config::process(3), false); }
+#[test] fn scc_100_2000_1() { test_sizes(100, 2000, 1, Config::process(3), false); }
 
-fn test_sizes(nodes: usize, edges: usize, rounds: usize, config: Config) {
+// The library's prioritized variant (`strongly_connected_at`, labels log-bucketed by node id)
+// against the same sequential oracle.
+#[test] fn scc_at_10_20_1000() { test_sizes(10, 20, 1000, Config::process(3), true); }
+#[test] fn scc_at_100_200_10() { test_sizes(100, 200, 10, Config::process(3), true); }
+#[test] fn scc_at_100_2000_1() { test_sizes(100, 2000, 1, Config::process(3), true); }
+
+fn test_sizes(nodes: usize, edges: usize, rounds: usize, config: Config, prioritized: bool) {
 
     let mut edge_list = Vec::new();
 
@@ -45,7 +51,7 @@ fn test_sizes(nodes: usize, edges: usize, rounds: usize, config: Config) {
     // }
 
     let mut results1 = scc_sequential(edge_list.clone());
-    let mut results2 = scc_differential(edge_list.clone(), config);
+    let mut results2 = scc_differential(edge_list.clone(), config, prioritized);
 
     results1.sort();
     results1.sort_by(|x,y| x.1.cmp(&y.1));
@@ -163,6 +169,7 @@ fn assign(node: usize, root: usize, reverse: &HashMap<usize, Vec<usize>>, compon
 fn scc_differential(
     edges_list: Vec<((usize, usize), usize, isize)>,
     config: Config,
+    prioritized: bool,
 )
 -> Vec<((usize, usize), usize, isize)>
 {
@@ -181,7 +188,12 @@ fn scc_differential(
 
             let (edge_input, edges) = scope.new_collection();
 
-            _strongly_connected(edges)
+            let result = if prioritized {
+                differential_dataflow::algorithms::graphs::scc::strongly_connected_at(edges, |x| *x as u64)
+            } else {
+                _strongly_connected(edges)
+            };
+            result
                 .consolidate()
                 .inner
                 .capture_into(send);
diff --git a/interactive/examples/corgi_scc_big.rs b/interactive/examples/corgi_scc_big.rs
index ec94ad048..51fbd5c78 100644
--- a/interactive/examples/corgi_scc_big.rs
+++ b/interactive/examples/corgi_scc_big.rs
@@ -13,7 +13,7 @@ use interactive::backend::{corgi, vec};
 use interactive::ir::Value;
 use interactive::{lower, parse};
 
-use differential_dataflow::algorithms::graphs::scc::strongly_connected;
+use differential_dataflow::algorithms::graphs::scc::{strongly_connected, strongly_connected_at};
 use differential_dataflow::input::Input;
 use timely::dataflow::operators::probe::Handle;
 
@@ -59,6 +59,25 @@ fn native_scc_once(edges: &[(usize, usize)]) {
     });
 }
 
+/// The FAIR compiled baseline: label introduction log-bucketed exactly as DDIR's
+/// `enter_at($1[0])` (propagate_core applies `256 * (64 - leading_zeros(logic(label)))`,
+/// the same delay vec.rs/corgi.rs compute), so native and DDIR run the same algorithm.
+fn native_scc_at_once(edges: &[(usize, usize)]) {
+    let edges = edges.to_vec();
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
+            strongly_connected_at(graph, |x| *x as u64).probe_with(&mut probe);
+            input
+        });
+        for &(s, d) in &edges { input.insert((s, d)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+}
+
 fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
 
 fn main() {
@@ -68,7 +87,7 @@ fn main() {
         .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
         .unwrap_or_else(|| vec![100_000, 250_000, 500_000, 1_000_000]);
 
-    println!("SCC large-N — native DD vs DDIR-vec vs DDIR-corgi (e = 2n):");
+    println!("SCC large-N — native DD / fair native (enter_at) / DDIR-vec / DDIR-corgi (e = 2n):");
     for (i, &nodes) in sizes.iter().enumerate() {
         let n_edges = nodes * 2;
         let mut seed = 0xc0ff_ee42u64;
@@ -88,12 +107,13 @@ fn main() {
         }
 
         let nt = once(|| native_scc_once(&native_edges));
+        let ft = once(|| native_scc_at_once(&native_edges));
         let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
         let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        let (nf, ff, vf, cf) = (nt.as_secs_f64(), ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
         println!(
-            "  n={nodes:<8} e={n_edges:<9}  native {nt:>9.2?}   vec-DDIR {vt:>9.2?} ({:.1}x nat)   corgi-DDIR {ct:>9.2?} ({:.1}x nat, {:.2}x vec){}",
-            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
+            "  n={nodes:<8} e={n_edges:<9}  native {nt:>8.2?}   fair(enter_at) {ft:>8.2?} ({:.2}x nat)   vec-DDIR {vt:>8.2?} ({:.2}x fair)   corgi-DDIR {ct:>8.2?} ({:.2}x fair, {:.2}x vec){}",
+            ff / nf, vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
         );
     }
 }

From ec65adcc31ccae612c9cec43ba02616981e5747f Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 10:32:24 -0400
Subject: [PATCH 49/68] B3 ident-join benchmark: pointer-doubling reps +
 term-resolution joins
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

E-graph-flavored identifier-lookup workload: parent forest (chains of CHAIN,
roots self-looped) resolved to roots by an iterative min-join fixpoint
(pointer doubling), then a term table (id,a,b) resolved by two integer joins
against reps. Closed-form oracle (root = x - x%CHAIN) checked against vec,
corgi asserted == vec, hand-written native twin oracle-checked too.

Measured (arm64, chains=64, terms=2n):
  n=100k: native 0.59s, vec 2.34s (4.00x nat), corgi 3.49s (5.95x nat, 1.49x vec)
  n=1m:   native 6.55s, vec 26.99s (4.12x nat), corgi 46.28s (7.07x nat, 1.71x vec)
corgi-vs-vec gap GROWS with n (1.31x @1k -> 1.71x @1m) — profile candidate.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_ident_big.rs | 199 ++++++++++++++++++++++++
 1 file changed, 199 insertions(+)
 create mode 100644 interactive/examples/corgi_ident_big.rs

diff --git a/interactive/examples/corgi_ident_big.rs b/interactive/examples/corgi_ident_big.rs
new file mode 100644
index 000000000..ae3d18358
--- /dev/null
+++ b/interactive/examples/corgi_ident_big.rs
@@ -0,0 +1,199 @@
+//! B3 "ident-join": identifier resolution via integer joins — the e-graph-flavored workload.
+//!
+//! Structure: a parent forest (chains of length CHAIN; roots hold self-loops) resolved to
+//! roots by pointer-doubling (iterative min-join fixpoint), then a term table (id, a, b)
+//! resolved by two joins mapping child identifiers to their representatives. Everything is
+//! integer-keyed joins + a min reduce — "identifier lookup" as the common action, with the
+//! joins in DD operators (corgi does per-row logic only).
+//!
+//!   N=100000,1000000 CHAIN=64 ~/.cargo/bin/cargo run --release --example corgi_ident_big
+//!
+//! Correctness: closed-form oracle (root(x) = x - x%CHAIN) checked against the vec backend,
+//! corgi asserted == vec, and the hand-written native twin captured + checked against the
+//! same oracle. CHECK=1 forces checks at every size (default: smallest size only).
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+use differential_dataflow::input::Input;
+use differential_dataflow::operators::iterate::Variable;
+use timely::dataflow::operators::probe::Handle;
+use timely::order::Product;
+
+const IDENT_SRC: &str = r#"
+    let parent = input 0 | key($0[0] ; $0[1]);
+    let terms  = input 1 | key($0[0] ; $0[1], $0[2]);
+    find: {
+        let reps = doubled + parent | min;
+        var doubled = reps | key($1 ; $0) | join(reps, ($1 ; $2));
+    }
+    let by_a    = terms | key($1[0] ; $0, $1[1]);
+    let with_a  = by_a  | join(find::reps, ($1[0] ; $1[1], $2));
+    let by_b    = with_a | key($1[0] ; $0, $1[1]);
+    let resolved = by_b | join(find::reps, ($1[0] ; $1[1], $2));
+    export "reps" = find::reps | arrange;
+    export "resolved" = resolved | arrange;
+"#;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
+
+/// The hand-written compiled twin, mirroring the DDIR plan: pointer-doubling fixpoint
+/// (Variable `doubled`; reps = min(doubled + parent); doubled' = reps∘reps), then the two
+/// term-resolution joins against the arranged reps. `capture` returns (reps, resolved).
+#[allow(clippy::type_complexity)]
+fn native_ident_once(
+    parents: &[(i64, i64)],
+    terms: &[(i64, i64, i64)],
+    capture: bool,
+) -> Option<(Vec<((i64, i64), isize)>, Vec<((i64, (i64, i64)), isize)>)> {
+    use timely::dataflow::operators::capture::{Capture, Event, Extract};
+
+    let parents = parents.to_vec();
+    let terms = terms.to_vec();
+    let (reps_tx, reps_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
+    let (res_tx, res_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, (i64, i64)), u64, isize)>>>();
+
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let (mut p_in, mut t_in) = worker.dataflow::<u64, _, _>(|scope| {
+            let (p_in, parent) = scope.new_collection::<(i64, i64), isize>();
+            let (t_in, term_rows) = scope.new_collection::<(i64, (i64, i64)), isize>();
+
+            let outer = parent.scope();
+            let reps = outer.scoped::<Product<u64, usize>, _, _>("Find", |inner| {
+                let parent = parent.enter(inner);
+                let (doubled_var, doubled) = Variable::new(inner, Product::new(Default::default(), 1));
+                let reps = doubled.concat(parent).reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
+                let reps_arr = reps.clone().arrange_by_key();
+                let next = reps
+                    .clone()
+                    .map(|(x, r)| (r, x))
+                    .arrange_by_key()
+                    .join_core(reps_arr, |_r, &x, &r2| Some((x, r2)));
+                doubled_var.set(next);
+                reps.leave(outer)
+            });
+
+            let reps_arr = reps.clone().arrange_by_key();
+            let by_a = term_rows.map(|(id, (a, b))| (a, (id, b))).arrange_by_key();
+            let with_a = by_a.join_core(reps_arr.clone(), |_a, &(id, b), &ra| Some((b, (id, ra))));
+            let resolved = with_a
+                .arrange_by_key()
+                .join_core(reps_arr, |_b, &(id, ra), &rb| Some((id, (ra, rb))));
+
+            resolved.clone().probe_with(&mut probe);
+            if capture {
+                reps.inner.capture_into(reps_tx);
+                resolved.inner.capture_into(res_tx);
+            }
+            (p_in, t_in)
+        });
+
+        for &(x, p) in &parents { p_in.insert((x, p)); }
+        for &(id, a, b) in &terms { t_in.insert((id, (a, b))); }
+        p_in.advance_to(1); p_in.flush();
+        t_in.advance_to(1); t_in.flush();
+        while probe.less_than(p_in.time()) { worker.step(); }
+    });
+
+    if capture {
+        let mut reps: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
+        for (_, batch) in reps_rx.extract() {
+            for (d, _, r) in batch { *reps.entry(d).or_insert(0) += r; }
+        }
+        let mut res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
+        for (_, batch) in res_rx.extract() {
+            for (d, _, r) in batch { *res.entry(d).or_insert(0) += r; }
+        }
+        Some((
+            reps.into_iter().filter(|(_, r)| *r != 0).collect(),
+            res.into_iter().filter(|(_, r)| *r != 0).collect(),
+        ))
+    } else {
+        None
+    }
+}
+
+fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
+
+/// Consolidate a backend export into a sorted (data, diff) list for oracle comparison.
+fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
+    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
+    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
+    map.into_iter().filter(|(_, d)| *d != 0).collect()
+}
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(IDENT_SRC));
+    p.optimize();
+    let sizes: Vec<u64> = std::env::var("N").ok()
+        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
+        .unwrap_or_else(|| vec![100_000, 1_000_000]);
+    let chain: u64 = std::env::var("CHAIN").ok().and_then(|s| s.parse().ok()).unwrap_or(64);
+
+    println!("ident-join (B3) — pointer-doubling reps + 2 term-resolution joins (chains of {chain}, terms = 2n):");
+    for (i, &nodes) in sizes.iter().enumerate() {
+        let n_terms = nodes * 2;
+        let root = |x: u64| (x - x % chain) as i64;
+
+        // Native inputs.
+        let parents: Vec<(i64, i64)> = (0..nodes)
+            .map(|x| (x as i64, if x % chain == 0 { x as i64 } else { (x - 1) as i64 }))
+            .collect();
+        let mut seed = 0xdead_beef_u64;
+        let terms: Vec<(i64, i64, i64)> = (0..n_terms)
+            .map(|j| ((nodes + j) as i64, (xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64))
+            .collect();
+
+        // DDIR inputs: input 0 = (x, parent ;), input 1 = (id, a, b ;).
+        let parent_rows: Vec<(Value, Value)> = parents.iter().map(|&(x, p)| (tup(&[x, p]), Value::unit())).collect();
+        let term_rows: Vec<(Value, Value)> = terms.iter().map(|&(id, a, b)| (tup(&[id, a, b]), Value::unit())).collect();
+        let inputs = vec![parent_rows, term_rows];
+
+        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
+        if check {
+            // Closed-form oracle.
+            let expect_reps: Vec<((Value, Value), i64)> = (0..nodes)
+                .map(|x| ((tup(&[x as i64]), tup(&[root(x)])), 1))
+                .collect();
+            let mut expect_res: Vec<((Value, Value), i64)> = Default::default();
+            {
+                let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
+                for &(id, a, b) in &terms {
+                    *map.entry((tup(&[id]), tup(&[root(a as u64), root(b as u64)]))).or_insert(0) += 1;
+                }
+                expect_res.extend(map.into_iter());
+            }
+
+            let vec_out = vec::evaluate(&p, &inputs);
+            assert_eq!(consolidated(&vec_out["reps"]), expect_reps, "vec reps != oracle at n={nodes}");
+            assert_eq!(consolidated(&vec_out["resolved"]), expect_res, "vec resolved != oracle at n={nodes}");
+            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={nodes}");
+
+            let (nat_reps, nat_res) = native_ident_once(&parents, &terms, true).unwrap();
+            let expect_nat_reps: Vec<((i64, i64), isize)> =
+                (0..nodes).map(|x| ((x as i64, root(x)), 1)).collect();
+            assert_eq!(nat_reps, expect_nat_reps, "native reps != oracle at n={nodes}");
+            let mut expect_nat_res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
+            for &(id, a, b) in &terms {
+                *expect_nat_res.entry((id, (root(a as u64), root(b as u64)))).or_insert(0) += 1;
+            }
+            let expect_nat_res: Vec<_> = expect_nat_res.into_iter().collect();
+            assert_eq!(nat_res, expect_nat_res, "native resolved != oracle at n={nodes}");
+        }
+
+        let nt = once(|| { native_ident_once(&parents, &terms, false); });
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={nodes:<8} terms={n_terms:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
+            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}

From 6c341cb1f8645e6071447e04196184691b07f086 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 10:41:57 -0400
Subject: [PATCH 50/68] B2 scc-compound benchmark: SCC over (group,index) tuple
 nodes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Same control structure as B1 but every node is a nested compound value
(x -> (x>>10, x&1023), order-preserving): no value-as-id fast path — compound
hashing, nested compares, and nested-column gathers carry the load.
enter_at($1[0][0]) buckets by group; the fair native twin is
strongly_connected_at over (i64,i64) with logic |n| n.0 (identical delay).

Correctness: corgi == vec on the full SCC edge set; compound output mapped
back through the encoding == the plain-encoding program on the same graph.

Measured (arm64, e=2n): compound keys hurt everyone, corgi worst:
  n=100k: fair 2.76s, vec 21.56s (7.80x), corgi 61.42s (22.22x fair, 2.85x vec)
  n=150k: fair 5.22s, vec 41.48s (7.95x), corgi 132.77s (25.43x fair, 3.20x vec)
(B1 plain-int corgi is 1.94-2.05x vec — the compound-key path is corgi's
weakest spot so far, and the ratio grows with n.)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_scc_compound.rs | 172 +++++++++++++++++++++
 1 file changed, 172 insertions(+)
 create mode 100644 interactive/examples/corgi_scc_compound.rs

diff --git a/interactive/examples/corgi_scc_compound.rs b/interactive/examples/corgi_scc_compound.rs
new file mode 100644
index 000000000..84c53f108
--- /dev/null
+++ b/interactive/examples/corgi_scc_compound.rs
@@ -0,0 +1,172 @@
+//! B2 "scc-compound": SCC where node identity is a compound value — each node is the
+//! nested tuple (group, index) = (x >> 10, x & 1023) — same control structure as B1
+//! (corgi_scc_big) but compound keys/labels everywhere: no value-as-id fast path, so
+//! hashing, compound compares, and gather of nested columns carry the load.
+//!
+//!   N=100000,150000 ~/.cargo/bin/cargo run --release --example corgi_scc_compound
+//!
+//! Fairness: the native twin is `strongly_connected_at` over (i64,i64) nodes with
+//! `logic = |n| n.0` — the same delay DDIR's `enter_at($1[0][0])` computes (bucket by
+//! group). The encoding x -> (x>>10, x&1023) is order-preserving, so min-label agrees
+//! with B1 on the same graph.
+//!
+//! Correctness (CHECK=1 forces; default smallest size): corgi == vec on the full SCC
+//! edge set, and the compound program's output mapped back through the encoding equals
+//! the plain-encoding program's output (vec backend) on the same graph.
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+use differential_dataflow::algorithms::graphs::scc::strongly_connected_at;
+use differential_dataflow::input::Input;
+use timely::dataflow::operators::probe::Handle;
+
+/// Compound-node SCC: identical to B1's program except nodes are single fields holding
+/// (group, index) tuples, and enter_at buckets by the group (first field of the node).
+const SCC_COMPOUND_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0][0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0][0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | arrange;
+"#;
+
+/// Plain-encoding SCC (B1's program with the full edge-set export) — the reference for
+/// the encoding cross-check.
+const SCC_PLAIN_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | arrange;
+"#;
+
+const GROUP_BITS: u64 = 10;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn node_val(x: u64) -> Value {
+    Value::Tuple(vec![Value::Int((x >> GROUP_BITS) as i64), Value::Int((x & ((1 << GROUP_BITS) - 1)) as i64)])
+}
+
+fn decode(v: &Value) -> i64 {
+    match v {
+        Value::Tuple(fs) => match (&fs[0], &fs[1]) {
+            (Value::Int(g), Value::Int(i)) => (g << GROUP_BITS) | i,
+            other => panic!("decode: unexpected node fields {other:?}"),
+        },
+        other => panic!("decode: unexpected node {other:?}"),
+    }
+}
+
+fn native_scc_compound_once(edges: &[(u64, u64)]) {
+    let enc = |x: u64| ((x >> GROUP_BITS) as i64, (x & ((1 << GROUP_BITS) - 1)) as i64);
+    let edges: Vec<((i64, i64), (i64, i64))> = edges.iter().map(|&(s, d)| (enc(s), enc(d))).collect();
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, graph) = scope.new_collection::<((i64, i64), (i64, i64)), isize>();
+            strongly_connected_at(graph, |n| n.0 as u64).probe_with(&mut probe);
+            input
+        });
+        for &(s, d) in &edges { input.insert((s, d)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+}
+
+fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
+
+fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
+    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
+    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
+    map.into_iter().filter(|(_, d)| *d != 0).collect()
+}
+
+fn main() {
+    let mut p_compound = lower::lower_tree(parse::pipe::parse(SCC_COMPOUND_SRC));
+    p_compound.optimize();
+    let mut p_plain = lower::lower_tree(parse::pipe::parse(SCC_PLAIN_SRC));
+    p_plain.optimize();
+
+    let sizes: Vec<u64> = std::env::var("N").ok()
+        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
+        .unwrap_or_else(|| vec![100_000, 150_000]);
+
+    println!("scc-compound (B2) — nodes are (group,index) tuples; fair native / DDIR-vec / DDIR-corgi (e = 2n):");
+    for (i, &nodes) in sizes.iter().enumerate() {
+        let n_edges = nodes * 2;
+        let mut seed = 0xc0ff_ee42u64;
+        let raw_edges: Vec<(u64, u64)> = (0..n_edges)
+            .map(|_| (xorshift(&mut seed) % nodes, xorshift(&mut seed) % nodes))
+            .collect();
+
+        let compound_rows: Vec<(Value, Value)> = raw_edges.iter()
+            .map(|&(s, d)| (Value::Tuple(vec![node_val(s), node_val(d)]), Value::unit()))
+            .collect();
+        let inputs = vec![compound_rows];
+
+        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
+        if check {
+            let vec_out = vec::evaluate(&p_compound, &inputs);
+            assert_eq!(corgi::evaluate(&p_compound, &inputs), vec_out, "corgi != vec at n={nodes}");
+
+            // Encoding cross-check: compound output mapped back == plain-program output.
+            let plain_rows: Vec<(Value, Value)> = raw_edges.iter()
+                .map(|&(s, d)| (Value::Tuple(vec![Value::Int(s as i64), Value::Int(d as i64)]), Value::unit()))
+                .collect();
+            let plain_out = vec::evaluate(&p_plain, &vec![plain_rows]);
+            // Export shape: key = (src_node), val = (dst_node), each node one compound field.
+            let remap = |t: &Value| match t {
+                Value::Tuple(fs) => Value::Tuple(fs.iter().map(|f| Value::Int(decode(f))).collect()),
+                other => panic!("unexpected row {other:?}"),
+            };
+            let mut mapped: Vec<((Value, Value), i64)> = consolidated(&vec_out["result"]).into_iter()
+                .map(|((k, v), d)| ((remap(&k), remap(&v)), d))
+                .collect();
+            mapped.sort();
+            assert_eq!(mapped, consolidated(&plain_out["result"]), "compound != plain (mapped) at n={nodes}");
+        }
+
+        let ft = once(|| native_scc_compound_once(&raw_edges));
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p_compound, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p_compound, &inputs)); });
+        let (ff, vf, cf) = (ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={nodes:<8} e={n_edges:<9}  native(fair) {ft:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
+            vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}

From 11e16ebf6072a903d5317d0ee6b32ca024eb38a7 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 10:46:29 -0400
Subject: [PATCH 51/68] B4 ast-compute benchmark: list/flatmap/variant/fold
 compute bookend
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Per row (a,b < 2^15): 8-element arithmetic list, flatmap explosion, Fwd/Bwd
variant + case + 4-element fold per element, min per 16 buckets (min so the
compute can't be dead-coded; reduce stays tiny). Closed-form Rust oracle
checked against vec, corgi == vec, native twin oracle-checked.

Values constrained non-negative + non-overflowing: the first draft (values to
1e6, a-b negative, e*e overflowing) exposed corgi min DIVERGING from vec on
negative ints — corgi's structural order is unsigned at the integer leaf.
Real abstraction gap, logged in the read-out; out of contract for B4.

Measured (arm64): corgi is NOT columnar on this path — flatmap/case/fold run
the row-wise fallback (ir::eval + transcode), so the expected compute win is
absent:
  n=1m: native 1.09s, vec 8.35s (7.69x nat), corgi 8.89s (8.19x nat, 1.07x vec)
  n=4m: native 4.55s, vec 34.61s (7.60x nat), corgi 37.19s (8.17x nat, 1.07x vec)
Columnarizing flatmap/case/fold is a top lever candidate.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_ast_compute.rs | 151 ++++++++++++++++++++++
 1 file changed, 151 insertions(+)
 create mode 100644 interactive/examples/corgi_ast_compute.rs

diff --git a/interactive/examples/corgi_ast_compute.rs b/interactive/examples/corgi_ast_compute.rs
new file mode 100644
index 000000000..cdbf120ed
--- /dev/null
+++ b/interactive/examples/corgi_ast_compute.rs
@@ -0,0 +1,151 @@
+//! B4 "ast-compute": the compute-heavy AST-style bookend — list build with arithmetic,
+//! flatmap explosion, variant tag + case + fold per element, then a tiny min reduce.
+//! This is corgi's home turf (wide per-row compute, no joins/recursion); it is labeled
+//! as such in the charter — a bookend, not the headline.
+//!
+//!   N=1000000,4000000 ~/.cargo/bin/cargo run --release --example corgi_ast_compute
+//!
+//! Per row (a, b < 2^15 — keeps every intermediate non-negative and inside i64; corgi's
+//! structural order is unsigned at the integer leaf, so signed values are out of contract
+//! for min — see the read-out finding): build list [a, b, a+b, a*b, a-b+2^15, b*b, a*a,
+//! a+b*b], explode to
+//! (pos, elem), bucket = pos + 8*(elem < H ? 0 : 1), payload = fold over
+//! [a, elem, a*elem, elem*elem] wrapped in a Fwd/Bwd variant and matched back out,
+//! then min(payload) per bucket (min so the compute cannot be dead-code eliminated,
+//! while the reduce itself stays tiny — 16 keys).
+//!
+//! Correctness: closed-form Rust oracle checked against vec, corgi == vec, and the
+//! hand-written native twin checked against the same oracle. CHECK=1 forces.
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+use differential_dataflow::input::Input;
+use timely::dataflow::operators::probe::Handle;
+
+const H: i64 = 500_000;
+
+const AST_SRC: &str = r#"
+    con Fwd(1) = 0;
+    con Bwd(1) = 1;
+
+    let rows = input 0 | key($0[0] ; $0[1]);
+    let lists = rows | map($0 ; list($0[0], $1[0], $0[0] + $1[0], $0[0] * $1[0], $0[0] - $1[0] + 32768, $1[0] * $1[0], $0[0] * $0[0], $0[0] + $1[0] * $1[0]));
+    let exploded = lists | flatmap($1[0]);
+    let tagged = exploded
+        | map( $1[0] + 8 * if($1[1] < 500000, 0, 1)
+             ; case if($1[1] < 250000,
+                       Fwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)),
+                       Bwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)))
+               {
+                 Fwd(s) => s,
+                 Bwd(s) => s,
+               } );
+    let buckets = tagged | min;
+    export "result" = buckets | arrange;
+"#;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
+
+/// The per-row logic, shared by the oracle and the native twin.
+fn explode(a: i64, b: i64) -> impl Iterator<Item = (i64, i64)> {
+    let elems = [a, b, a + b, a * b, a - b + 32768, b * b, a * a, a + b * b];
+    elems.into_iter().enumerate().map(move |(pos, e)| {
+        let bucket = pos as i64 + 8 * if e < H { 0 } else { 1 };
+        let payload = a + e + a * e + e * e;
+        (bucket, payload)
+    })
+}
+
+fn native_ast_once(rows: &[(i64, i64)], capture: bool) -> Option<Vec<((i64, i64), isize)>> {
+    use timely::dataflow::operators::capture::{Capture, Event, Extract};
+    let rows = rows.to_vec();
+    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
+
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, data) = scope.new_collection::<(i64, i64), isize>();
+            let buckets = data
+                .flat_map(|(a, b)| explode(a, b))
+                .reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
+            buckets.clone().probe_with(&mut probe);
+            if capture { buckets.inner.capture_into(tx); }
+            input
+        });
+        for &(a, b) in &rows { input.insert((a, b)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+
+    if capture {
+        let mut out: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
+        for (_, batch) in rx.extract() {
+            for (d, _, r) in batch { *out.entry(d).or_insert(0) += r; }
+        }
+        Some(out.into_iter().filter(|(_, r)| *r != 0).collect())
+    } else {
+        None
+    }
+}
+
+fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
+
+fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
+    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
+    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
+    map.into_iter().filter(|(_, d)| *d != 0).collect()
+}
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(AST_SRC));
+    p.optimize();
+    let sizes: Vec<u64> = std::env::var("N").ok()
+        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
+        .unwrap_or_else(|| vec![1_000_000, 4_000_000]);
+
+    println!("ast-compute (B4) — list build + flatmap + variant/case/fold + min (8 elems/row):");
+    for (i, &n_rows) in sizes.iter().enumerate() {
+        let mut seed = 0xfeed_f00d_u64;
+        let rows: Vec<(i64, i64)> = (0..n_rows)
+            .map(|_| ((xorshift(&mut seed) % 32_768) as i64, (xorshift(&mut seed) % 32_768) as i64))
+            .collect();
+        let ddir_rows: Vec<(Value, Value)> = rows.iter().map(|&(a, b)| (tup(&[a, b]), Value::unit())).collect();
+        let inputs = vec![ddir_rows];
+
+        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
+        if check {
+            // Closed-form oracle: min payload per bucket.
+            let mut mins: std::collections::BTreeMap<i64, i64> = Default::default();
+            for &(a, b) in &rows {
+                for (bucket, payload) in explode(a, b) {
+                    mins.entry(bucket).and_modify(|m| *m = (*m).min(payload)).or_insert(payload);
+                }
+            }
+            let expect: Vec<((Value, Value), i64)> =
+                mins.iter().map(|(&k, &v)| ((tup(&[k]), tup(&[v])), 1)).collect();
+            let expect_nat: Vec<((i64, i64), isize)> =
+                mins.iter().map(|(&k, &v)| ((k, v), 1)).collect();
+
+            let vec_out = vec::evaluate(&p, &inputs);
+            assert_eq!(consolidated(&vec_out["result"]), expect, "vec != oracle at n={n_rows}");
+            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={n_rows}");
+            assert_eq!(native_ast_once(&rows, true).unwrap(), expect_nat, "native != oracle at n={n_rows}");
+        }
+
+        let nt = once(|| { native_ast_once(&rows, false); });
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={n_rows:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
+            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}

From dbe00936ba0ec31d0e54015210dd6b8ef74052f4 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 11:22:08 -0400
Subject: [PATCH 52/68] B2 profiling harness: corgi_compound_prof
 (BACKEND=corgi|vec)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Loops one backend of scc-compound at a fixed size for samply, built identically
for apples-to-apples profiles.

Iteration-1 profile findings (n=50k, corgi 28.0s vs vec 11.4s):
- retire subtree = 77% of corgi; vec's Value::cmp/partial_cmp/eq = 26% self.
- consolidate_updates_slice_slow 17.6% total. Two tactic-side fixes (permutation
  sort; interned-time integer consolidation + stable run-merge) were both
  measured FLAT and reverted: the hot consolidation is NOT the tactic's delta
  emit — it is next_window's presentation build in corgi_reduce_backend
  (collect_present clones an owned PointStamp per presented row, then
  consolidate_updates comparison-sorts the AoS records; the caller frame was
  inlined away). That backend site is the next lever.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_compound_prof.rs | 61 +++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 interactive/examples/corgi_compound_prof.rs

diff --git a/interactive/examples/corgi_compound_prof.rs b/interactive/examples/corgi_compound_prof.rs
new file mode 100644
index 000000000..06eb5137d
--- /dev/null
+++ b/interactive/examples/corgi_compound_prof.rs
@@ -0,0 +1,61 @@
+//! Profiling target for B2 scc-compound: loop one backend at a fixed size for samply.
+//!
+//!   N=50000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
+//!       target/release/examples/corgi_compound_prof
+//!
+//! BACKEND=corgi (default) or vec — built identically for apples-to-apples profiles.
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+const SCC_COMPOUND_SRC: &str = r#"
+    let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0][0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0][0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | arrange;
+"#;
+
+const GROUP_BITS: u64 = 10;
+
+fn node_val(x: u64) -> Value {
+    Value::Tuple(vec![Value::Int((x >> GROUP_BITS) as i64), Value::Int((x & ((1 << GROUP_BITS) - 1)) as i64)])
+}
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(SCC_COMPOUND_SRC));
+    p.optimize();
+    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(50_000);
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
+    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
+    let mut seed = 0xc0ff_ee42u64;
+    let edges: Vec<(Value, Value)> = (0..nodes * 2)
+        .map(|_| (Value::Tuple(vec![node_val(xorshift(&mut seed) % nodes), node_val(xorshift(&mut seed) % nodes)]), Value::unit()))
+        .collect();
+    let inputs = vec![edges];
+    let mut acc = 0usize;
+    for _ in 0..iters {
+        acc += match backend.as_str() {
+            "vec" => std::hint::black_box(vec::evaluate(&p, &inputs)).len(),
+            _ => std::hint::black_box(corgi::evaluate(&p, &inputs)).len(),
+        };
+    }
+    eprintln!("done scc-compound backend={backend} n={nodes} iters={iters} (acc={acc})");
+}

From a8de8c3db61d91975bcbec623f8310b5d6e2461c Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 12:08:51 -0400
Subject: [PATCH 53/68] B4 profiling harness: corgi_ast_prof
 (BACKEND=corgi|vec)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

B4 corgi profile (n=1m): ir::eval 19% (row-wise List/Case fallback), Value
churn ~15%, arrangement merge of the 8m exploded rows ~29%, reduce 14%.
Both backends run B4 row-wise — the columnar win is unrealized here.
Iteration-4 lever scoped in the read-out: columnarize List/FlatMap/Case in
the backend via existing corgi kernels (Iota/Gather/Flatten/Fold/Inject/
MapSum + gather_lanes interleave).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_ast_prof.rs | 55 ++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 interactive/examples/corgi_ast_prof.rs

diff --git a/interactive/examples/corgi_ast_prof.rs b/interactive/examples/corgi_ast_prof.rs
new file mode 100644
index 000000000..83d16e8b8
--- /dev/null
+++ b/interactive/examples/corgi_ast_prof.rs
@@ -0,0 +1,55 @@
+//! Profiling target for B4 ast-compute: loop one backend at a fixed size for samply.
+//!
+//!   N=1000000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
+//!       target/release/examples/corgi_ast_prof
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+const AST_SRC: &str = r#"
+    con Fwd(1) = 0;
+    con Bwd(1) = 1;
+
+    let rows = input 0 | key($0[0] ; $0[1]);
+    let lists = rows | map($0 ; list($0[0], $1[0], $0[0] + $1[0], $0[0] * $1[0], $0[0] - $1[0] + 32768, $1[0] * $1[0], $0[0] * $0[0], $0[0] + $1[0] * $1[0]));
+    let exploded = lists | flatmap($1[0]);
+    let tagged = exploded
+        | map( $1[0] + 8 * if($1[1] < 500000, 0, 1)
+             ; case if($1[1] < 250000,
+                       Fwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)),
+                       Bwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)))
+               {
+                 Fwd(s) => s,
+                 Bwd(s) => s,
+               } );
+    let buckets = tagged | min;
+    export "result" = buckets | arrange;
+"#;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(AST_SRC));
+    p.optimize();
+    let n_rows: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(1_000_000);
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
+    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
+    let mut seed = 0xfeed_f00d_u64;
+    let rows: Vec<(Value, Value)> = (0..n_rows)
+        .map(|_| {
+            let a = (xorshift(&mut seed) % 32_768) as i64;
+            let b = (xorshift(&mut seed) % 32_768) as i64;
+            (Value::Tuple(vec![Value::Int(a), Value::Int(b)]), Value::unit())
+        })
+        .collect();
+    let inputs = vec![rows];
+    let mut acc = 0usize;
+    for _ in 0..iters {
+        acc += match backend.as_str() {
+            "vec" => std::hint::black_box(vec::evaluate(&p, &inputs)).len(),
+            _ => std::hint::black_box(corgi::evaluate(&p, &inputs)).len(),
+        };
+    }
+    eprintln!("done ast backend={backend} n={n_rows} iters={iters} (acc={acc})");
+}

From 83d3a35843c78fb207a236461fbe2c80174a8a07 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 14:17:36 -0400
Subject: [PATCH 54/68] B3 profiling harness: corgi_ident_prof
 (BACKEND=corgi|vec)

B3 corgi profile at n=1m surfaces two concentrated corgi-kernel buckets the
SCC profiles never showed: sort_leaf_blocks 17% self (discrimination-sort
leaf pass, under ingress sort_consolidate + materialize from_columns) and
the join's find_ranges probe 17.8% total (interpreted CmpOp::eval compare
per binary-search step). Both kernel-general levers; details in the read-out.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_ident_prof.rs | 53 ++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 interactive/examples/corgi_ident_prof.rs

diff --git a/interactive/examples/corgi_ident_prof.rs b/interactive/examples/corgi_ident_prof.rs
new file mode 100644
index 000000000..7a1b06c52
--- /dev/null
+++ b/interactive/examples/corgi_ident_prof.rs
@@ -0,0 +1,53 @@
+//! Profiling target for B3 ident-join: loop one backend at a fixed size for samply.
+//!
+//!   N=1000000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
+//!       target/release/examples/corgi_ident_prof
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+const IDENT_SRC: &str = r#"
+    let parent = input 0 | key($0[0] ; $0[1]);
+    let terms  = input 1 | key($0[0] ; $0[1], $0[2]);
+    find: {
+        let reps = doubled + parent | min;
+        var doubled = reps | key($1 ; $0) | join(reps, ($1 ; $2));
+    }
+    let by_a    = terms | key($1[0] ; $0, $1[1]);
+    let with_a  = by_a  | join(find::reps, ($1[0] ; $1[1], $2));
+    let by_b    = with_a | key($1[0] ; $0, $1[1]);
+    let resolved = by_b | join(find::reps, ($1[0] ; $1[1], $2));
+    export "reps" = find::reps | arrange;
+    export "resolved" = resolved | arrange;
+"#;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
+
+fn main() {
+    let mut p = lower::lower_tree(parse::pipe::parse(IDENT_SRC));
+    p.optimize();
+    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(1_000_000);
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
+    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
+    let chain: u64 = std::env::var("CHAIN").ok().and_then(|s| s.parse().ok()).unwrap_or(64);
+    let n_terms = nodes * 2;
+    let parents: Vec<(Value, Value)> = (0..nodes)
+        .map(|x| (tup(&[x as i64, if x % chain == 0 { x as i64 } else { (x - 1) as i64 }]), Value::unit()))
+        .collect();
+    let mut seed = 0xdead_beef_u64;
+    let terms: Vec<(Value, Value)> = (0..n_terms)
+        .map(|j| (tup(&[(nodes + j) as i64, (xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
+        .collect();
+    let inputs = vec![parents, terms];
+    let mut acc = 0usize;
+    for _ in 0..iters {
+        acc += match backend.as_str() {
+            "vec" => std::hint::black_box(vec::evaluate(&p, &inputs)).len(),
+            _ => std::hint::black_box(corgi::evaluate(&p, &inputs)).len(),
+        };
+    }
+    eprintln!("done ident backend={backend} n={nodes} iters={iters} (acc={acc})");
+}

From 9b8167958a2ed480f0c69057bd3d62732dd39a4d Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sat, 11 Jul 2026 15:33:39 -0400
Subject: [PATCH 55/68] corgi_scc_big: SEED env for instance-variance
 measurement

5 timing runs at n=100k (fixed graph): corgi 3.76-3.89s, vec 2.97-3.03s,
ratio 1.26-1.30x; n=250k: ratio 1.28-1.29x. 3 graph instances (SEED=1,
12345, 999983): ratio 1.24-1.29x, vec/fair 4.78-4.94x. Both axes ~ +/-2%;
the reported ratios are solid to about two figures.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_scc_big.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/interactive/examples/corgi_scc_big.rs b/interactive/examples/corgi_scc_big.rs
index 51fbd5c78..2789e83f8 100644
--- a/interactive/examples/corgi_scc_big.rs
+++ b/interactive/examples/corgi_scc_big.rs
@@ -88,13 +88,14 @@ fn main() {
         .unwrap_or_else(|| vec![100_000, 250_000, 500_000, 1_000_000]);
 
     println!("SCC large-N — native DD / fair native (enter_at) / DDIR-vec / DDIR-corgi (e = 2n):");
+    let seed0: u64 = std::env::var("SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(0xc0ff_ee42);
     for (i, &nodes) in sizes.iter().enumerate() {
         let n_edges = nodes * 2;
-        let mut seed = 0xc0ff_ee42u64;
+        let mut seed = seed0;
         let edges: Vec<(Value, Value)> = (0..n_edges)
             .map(|_| (tup(&[(xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
             .collect();
-        let mut seed2 = 0xc0ff_ee42u64;
+        let mut seed2 = seed0;
         let native_edges: Vec<(usize, usize)> = (0..n_edges)
             .map(|_| ((xorshift(&mut seed2) % nodes) as usize, (xorshift(&mut seed2) % nodes) as usize))
             .collect();

From 32e795e3743740254a9059f30532ade470a0528c Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sun, 12 Jul 2026 08:20:28 -0400
Subject: [PATCH 56/68] phase 3: framework-tax decomposition profile + mimalloc
 for the suite

New native_scc_prof (fair enter_at compiled twin). Triptych at n=100k, self-time
by module: allocator native 2.2% / vec 28.4% / corgi 27.2%; memmove native 0.7%
/ vec 2.8% / corgi 11.9%; timely progress tracking ~0.5% in BOTH backends. The
4.8x shared tax is BUFFER LIFECYCLE (allocation + copy churn), not progress
tracking (kills lever 1b as a priority), not operator count (rung B), not edge
time repr (rung A). vec's churn is per-row ir::Value boxes (cmp+clone+eq ~20%
self); corgi's is column rebuilds (fresh Arc<Vec> per gather/merge/present).

The suite ran on the SYSTEM allocator (only ddir_server/ddir_vec linked
mimalloc). Adding mimalloc to all suite + prof binaries (one binary per
benchmark: every column shares it; native columns move <5%, DDIR 12-36%):
  B1 250k: corgi 8.67 -> 7.07s (0.96x vec, 4.29x fair; was 5.2x fair)
  B2 150k: corgi 53.45 -> 42.94s (1.22x vec)   100k: 1.08x vec
  B3 1m:   corgi 27.24 -> 19.79s (0.82x vec, 3.17x fair)
  B4 4m:   corgi 20.09 -> 13.00s (0.45x vec, 2.96x fair)
Gate 6/6 incl. fusion oracle; [checked] rows green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_ast_compute.rs   |  6 +++
 interactive/examples/corgi_ast_prof.rs      |  6 +++
 interactive/examples/corgi_compound_prof.rs |  6 +++
 interactive/examples/corgi_ident_big.rs     |  6 +++
 interactive/examples/corgi_ident_prof.rs    |  6 +++
 interactive/examples/corgi_progs.rs         |  6 +++
 interactive/examples/corgi_scc_big.rs       |  6 +++
 interactive/examples/corgi_scc_compound.rs  |  6 +++
 interactive/examples/corgi_scc_prof.rs      |  6 +++
 interactive/examples/corgi_scorecard.rs     |  6 +++
 interactive/examples/native_scc_prof.rs     | 44 +++++++++++++++++++++
 interactive/examples/vec_scc_prof.rs        |  6 +++
 12 files changed, 110 insertions(+)
 create mode 100644 interactive/examples/native_scc_prof.rs

diff --git a/interactive/examples/corgi_ast_compute.rs b/interactive/examples/corgi_ast_compute.rs
index cdbf120ed..5baac0c24 100644
--- a/interactive/examples/corgi_ast_compute.rs
+++ b/interactive/examples/corgi_ast_compute.rs
@@ -17,6 +17,12 @@
 //! Correctness: closed-form Rust oracle checked against vec, corgi == vec, and the
 //! hand-written native twin checked against the same oracle. CHECK=1 forces.
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use std::time::{Duration, Instant};
 
 use interactive::backend::{corgi, vec};
diff --git a/interactive/examples/corgi_ast_prof.rs b/interactive/examples/corgi_ast_prof.rs
index 83d16e8b8..cf63dde8b 100644
--- a/interactive/examples/corgi_ast_prof.rs
+++ b/interactive/examples/corgi_ast_prof.rs
@@ -3,6 +3,12 @@
 //!   N=1000000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
 //!       target/release/examples/corgi_ast_prof
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use interactive::backend::{corgi, vec};
 use interactive::ir::Value;
 use interactive::{lower, parse};
diff --git a/interactive/examples/corgi_compound_prof.rs b/interactive/examples/corgi_compound_prof.rs
index 06eb5137d..286a12cca 100644
--- a/interactive/examples/corgi_compound_prof.rs
+++ b/interactive/examples/corgi_compound_prof.rs
@@ -5,6 +5,12 @@
 //!
 //! BACKEND=corgi (default) or vec — built identically for apples-to-apples profiles.
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use interactive::backend::{corgi, vec};
 use interactive::ir::Value;
 use interactive::{lower, parse};
diff --git a/interactive/examples/corgi_ident_big.rs b/interactive/examples/corgi_ident_big.rs
index ae3d18358..0a9bc9463 100644
--- a/interactive/examples/corgi_ident_big.rs
+++ b/interactive/examples/corgi_ident_big.rs
@@ -12,6 +12,12 @@
 //! corgi asserted == vec, and the hand-written native twin captured + checked against the
 //! same oracle. CHECK=1 forces checks at every size (default: smallest size only).
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use std::time::{Duration, Instant};
 
 use interactive::backend::{corgi, vec};
diff --git a/interactive/examples/corgi_ident_prof.rs b/interactive/examples/corgi_ident_prof.rs
index 7a1b06c52..b59158333 100644
--- a/interactive/examples/corgi_ident_prof.rs
+++ b/interactive/examples/corgi_ident_prof.rs
@@ -3,6 +3,12 @@
 //!   N=1000000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
 //!       target/release/examples/corgi_ident_prof
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use interactive::backend::{corgi, vec};
 use interactive::ir::Value;
 use interactive::{lower, parse};
diff --git a/interactive/examples/corgi_progs.rs b/interactive/examples/corgi_progs.rs
index b200f4bff..6673933f9 100644
--- a/interactive/examples/corgi_progs.rs
+++ b/interactive/examples/corgi_progs.rs
@@ -3,6 +3,12 @@
 //! Picks inputs by program (small graphs). Reports OK / FAIL / panic per program; with no PROG,
 //! runs the whole set.
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use interactive::backend::{corgi, vec};
 use interactive::ir::Value;
 use interactive::{lower, parse};
diff --git a/interactive/examples/corgi_scc_big.rs b/interactive/examples/corgi_scc_big.rs
index 2789e83f8..9774510e3 100644
--- a/interactive/examples/corgi_scc_big.rs
+++ b/interactive/examples/corgi_scc_big.rs
@@ -7,6 +7,12 @@
 //! One run per backend per size (these are seconds-scale; no median). CHECK=1 asserts corgi==vec
 //! (doubles the corgi+vec work at that size) — on by default only for the smallest size.
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use std::time::{Duration, Instant};
 
 use interactive::backend::{corgi, vec};
diff --git a/interactive/examples/corgi_scc_compound.rs b/interactive/examples/corgi_scc_compound.rs
index 84c53f108..2c8bf91a2 100644
--- a/interactive/examples/corgi_scc_compound.rs
+++ b/interactive/examples/corgi_scc_compound.rs
@@ -14,6 +14,12 @@
 //! edge set, and the compound program's output mapped back through the encoding equals
 //! the plain-encoding program's output (vec backend) on the same graph.
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use std::time::{Duration, Instant};
 
 use interactive::backend::{corgi, vec};
diff --git a/interactive/examples/corgi_scc_prof.rs b/interactive/examples/corgi_scc_prof.rs
index 3a83cc9e3..8d41be763 100644
--- a/interactive/examples/corgi_scc_prof.rs
+++ b/interactive/examples/corgi_scc_prof.rs
@@ -3,6 +3,12 @@
 //!
 //!   ITERS=300 N=500 samply record -- .../corgi_scc_prof
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use interactive::backend::corgi;
 use interactive::ir::Value;
 use interactive::{lower, parse};
diff --git a/interactive/examples/corgi_scorecard.rs b/interactive/examples/corgi_scorecard.rs
index 65a5b5ccb..bde27e61d 100644
--- a/interactive/examples/corgi_scorecard.rs
+++ b/interactive/examples/corgi_scorecard.rs
@@ -13,6 +13,12 @@
 //! Targets encode the thesis: parity with vec is the FLOOR (never lose on an operator), beating vec
 //! is the GOAL (columnar corgi should avoid the row backend's interpretation + Value pointer-chasing).
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use std::time::{Duration, Instant};
 
 use interactive::backend::{corgi, vec};
diff --git a/interactive/examples/native_scc_prof.rs b/interactive/examples/native_scc_prof.rs
new file mode 100644
index 000000000..7f95d60ad
--- /dev/null
+++ b/interactive/examples/native_scc_prof.rs
@@ -0,0 +1,44 @@
+//! Profiling target: loop FAIR compiled SCC (`strongly_connected_at`, the same enter_at
+//! log-bucketing DDIR uses) at a fixed size for samply — the compiled twin of
+//! `vec_scc_prof`/`corgi_scc_prof`, for decomposing the DDIR-over-compiled framework tax.
+//!
+//!   ITERS=5 N=100000 samply record -- .../native_scc_prof
+
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+use differential_dataflow::algorithms::graphs::scc::strongly_connected_at;
+use differential_dataflow::input::Input;
+use timely::dataflow::operators::probe::Handle;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn main() {
+    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(100_000);
+    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
+    let n_edges = nodes * 2;
+    let mut seed = 0xc0ff_ee42u64;
+    let edges: Vec<(usize, usize)> = (0..n_edges)
+        .map(|_| ((xorshift(&mut seed) % nodes) as usize, (xorshift(&mut seed) % nodes) as usize))
+        .collect();
+
+    for i in 0..iters {
+        let edges = edges.clone();
+        timely::execute_directly(move |worker| {
+            let mut probe = Handle::new();
+            let mut input = worker.dataflow::<u64, _, _>(|scope| {
+                let (input, graph) = scope.new_collection::<(usize, usize), isize>();
+                strongly_connected_at(graph, |x| *x as u64).probe_with(&mut probe);
+                input
+            });
+            for &(s, d) in &edges { input.insert((s, d)); }
+            input.advance_to(1);
+            input.flush();
+            while probe.less_than(input.time()) { worker.step(); }
+        });
+        println!("done native-fair scc n={nodes} iter={i}");
+    }
+}
diff --git a/interactive/examples/vec_scc_prof.rs b/interactive/examples/vec_scc_prof.rs
index f624e1473..e3d68582b 100644
--- a/interactive/examples/vec_scc_prof.rs
+++ b/interactive/examples/vec_scc_prof.rs
@@ -3,6 +3,12 @@
 //!
 //!   ITERS=200 N=800 samply record -- .../vec_scc_prof
 
+// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
+// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
+// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 use interactive::backend::vec;
 use interactive::ir::Value;
 use interactive::{lower, parse};

From dabd27efb8f966cc8246949a77d943e56241438d Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sun, 12 Jul 2026 21:52:45 -0400
Subject: [PATCH 57/68] CI prep: bump corgi pin to dd-arrange-api 1301b28; drop
 unused import

The pin moves from f556868 to the dd-arrange-api tip, which carries the four
landed kernel additions (wip#7). Gate green; workspace passes -D warnings.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/Cargo.toml           | 2 +-
 interactive/src/backend/corgi.rs | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/interactive/Cargo.toml b/interactive/Cargo.toml
index 0cb3fd4ba..c8d083d65 100644
--- a/interactive/Cargo.toml
+++ b/interactive/Cargo.toml
@@ -15,7 +15,7 @@ workspace = true
 columnar = { workspace = true }
 # Local dev: `path = "../../wip/corgi"`. Pinned to a git rev so the branch builds standalone
 # (frankmcsherry/wip @ dd-arrange-api) — see int-proxy-columnar-findings.md.
-corgi = { git = "https://github.com/frankmcsherry/wip", rev = "f556868b7b13de19b969bb0eb810c7ffacbb515f" }
+corgi = { git = "https://github.com/frankmcsherry/wip", rev = "1301b281501d5e70ab63f9405412770a3250d985" }
 differential-dataflow = { workspace = true }
 mimalloc = "0.1.48"
 serde = { version = "1.0", features = ["derive"] }
diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index afb904bca..20987752a 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -6,7 +6,6 @@
 //! This iteration: the `Backend` impl SHAPE compiles (arrange + leave_dynamic real; linear/join/
 //! as_collection/reduce/inspect = `todo!()`), validating the trait wiring + `render_tree::<CorgiBackend>`.
 
-use timely::container::CapacityContainerBuilder;
 use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::Pipeline;
 use timely::dataflow::operators::generic::Operator;

From 49b4d55ff1564444d3519fb4005ee79bef830f5a Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sun, 12 Jul 2026 22:25:27 -0400
Subject: [PATCH 58/68] examples: one ddir_bench runner; benchmark programs to
 .ddp files
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ten purpose-built binaries (four benchmarks + six profiling twins) collapse
into one runner: interpreted programs live in examples/programs/*.ddp where
they belong; the irreducibly compiled parts — input generators and the native
twins, including the enter_at-fair SCC — register in the runner by bench name.
BACKEND=/ITERS= select profiling mode (loop one column, a samply target),
replacing the prof twins. Output formats, env protocols (N/SEED/CHECK/CHAIN),
and all correctness assertions are unchanged; all four benches verified
[checked] plus a prof-mode smoke; gate green; workspace passes -D warnings.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_ast_compute.rs     | 157 -----
 interactive/examples/corgi_ast_prof.rs        |  61 --
 interactive/examples/corgi_compound_prof.rs   |  67 ---
 interactive/examples/corgi_ident_big.rs       | 205 -------
 interactive/examples/corgi_ident_prof.rs      |  59 --
 interactive/examples/corgi_scc_big.rs         | 126 ----
 interactive/examples/corgi_scc_compound.rs    | 178 ------
 interactive/examples/corgi_scc_prof.rs        |  55 --
 interactive/examples/ddir_bench.rs            | 545 ++++++++++++++++++
 interactive/examples/native_scc_prof.rs       |  44 --
 interactive/examples/programs/ast.ddp         |  17 +
 interactive/examples/programs/ident.ddp       |  12 +
 interactive/examples/programs/scc.ddp         |  52 +-
 .../examples/programs/scc_compound.ddp        |  19 +
 interactive/examples/programs/scc_plain.ddp   |  19 +
 interactive/examples/vec_scc_prof.rs          |  55 --
 16 files changed, 629 insertions(+), 1042 deletions(-)
 delete mode 100644 interactive/examples/corgi_ast_compute.rs
 delete mode 100644 interactive/examples/corgi_ast_prof.rs
 delete mode 100644 interactive/examples/corgi_compound_prof.rs
 delete mode 100644 interactive/examples/corgi_ident_big.rs
 delete mode 100644 interactive/examples/corgi_ident_prof.rs
 delete mode 100644 interactive/examples/corgi_scc_big.rs
 delete mode 100644 interactive/examples/corgi_scc_compound.rs
 delete mode 100644 interactive/examples/corgi_scc_prof.rs
 create mode 100644 interactive/examples/ddir_bench.rs
 delete mode 100644 interactive/examples/native_scc_prof.rs
 create mode 100644 interactive/examples/programs/ast.ddp
 create mode 100644 interactive/examples/programs/ident.ddp
 create mode 100644 interactive/examples/programs/scc_compound.ddp
 create mode 100644 interactive/examples/programs/scc_plain.ddp
 delete mode 100644 interactive/examples/vec_scc_prof.rs

diff --git a/interactive/examples/corgi_ast_compute.rs b/interactive/examples/corgi_ast_compute.rs
deleted file mode 100644
index 5baac0c24..000000000
--- a/interactive/examples/corgi_ast_compute.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-//! B4 "ast-compute": the compute-heavy AST-style bookend — list build with arithmetic,
-//! flatmap explosion, variant tag + case + fold per element, then a tiny min reduce.
-//! This is corgi's home turf (wide per-row compute, no joins/recursion); it is labeled
-//! as such in the charter — a bookend, not the headline.
-//!
-//!   N=1000000,4000000 ~/.cargo/bin/cargo run --release --example corgi_ast_compute
-//!
-//! Per row (a, b < 2^15 — keeps every intermediate non-negative and inside i64; corgi's
-//! structural order is unsigned at the integer leaf, so signed values are out of contract
-//! for min — see the read-out finding): build list [a, b, a+b, a*b, a-b+2^15, b*b, a*a,
-//! a+b*b], explode to
-//! (pos, elem), bucket = pos + 8*(elem < H ? 0 : 1), payload = fold over
-//! [a, elem, a*elem, elem*elem] wrapped in a Fwd/Bwd variant and matched back out,
-//! then min(payload) per bucket (min so the compute cannot be dead-code eliminated,
-//! while the reduce itself stays tiny — 16 keys).
-//!
-//! Correctness: closed-form Rust oracle checked against vec, corgi == vec, and the
-//! hand-written native twin checked against the same oracle. CHECK=1 forces.
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-use differential_dataflow::input::Input;
-use timely::dataflow::operators::probe::Handle;
-
-const H: i64 = 500_000;
-
-const AST_SRC: &str = r#"
-    con Fwd(1) = 0;
-    con Bwd(1) = 1;
-
-    let rows = input 0 | key($0[0] ; $0[1]);
-    let lists = rows | map($0 ; list($0[0], $1[0], $0[0] + $1[0], $0[0] * $1[0], $0[0] - $1[0] + 32768, $1[0] * $1[0], $0[0] * $0[0], $0[0] + $1[0] * $1[0]));
-    let exploded = lists | flatmap($1[0]);
-    let tagged = exploded
-        | map( $1[0] + 8 * if($1[1] < 500000, 0, 1)
-             ; case if($1[1] < 250000,
-                       Fwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)),
-                       Bwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)))
-               {
-                 Fwd(s) => s,
-                 Bwd(s) => s,
-               } );
-    let buckets = tagged | min;
-    export "result" = buckets | arrange;
-"#;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
-
-/// The per-row logic, shared by the oracle and the native twin.
-fn explode(a: i64, b: i64) -> impl Iterator<Item = (i64, i64)> {
-    let elems = [a, b, a + b, a * b, a - b + 32768, b * b, a * a, a + b * b];
-    elems.into_iter().enumerate().map(move |(pos, e)| {
-        let bucket = pos as i64 + 8 * if e < H { 0 } else { 1 };
-        let payload = a + e + a * e + e * e;
-        (bucket, payload)
-    })
-}
-
-fn native_ast_once(rows: &[(i64, i64)], capture: bool) -> Option<Vec<((i64, i64), isize)>> {
-    use timely::dataflow::operators::capture::{Capture, Event, Extract};
-    let rows = rows.to_vec();
-    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
-
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, data) = scope.new_collection::<(i64, i64), isize>();
-            let buckets = data
-                .flat_map(|(a, b)| explode(a, b))
-                .reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
-            buckets.clone().probe_with(&mut probe);
-            if capture { buckets.inner.capture_into(tx); }
-            input
-        });
-        for &(a, b) in &rows { input.insert((a, b)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-
-    if capture {
-        let mut out: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
-        for (_, batch) in rx.extract() {
-            for (d, _, r) in batch { *out.entry(d).or_insert(0) += r; }
-        }
-        Some(out.into_iter().filter(|(_, r)| *r != 0).collect())
-    } else {
-        None
-    }
-}
-
-fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
-
-fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
-    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
-    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
-    map.into_iter().filter(|(_, d)| *d != 0).collect()
-}
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(AST_SRC));
-    p.optimize();
-    let sizes: Vec<u64> = std::env::var("N").ok()
-        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
-        .unwrap_or_else(|| vec![1_000_000, 4_000_000]);
-
-    println!("ast-compute (B4) — list build + flatmap + variant/case/fold + min (8 elems/row):");
-    for (i, &n_rows) in sizes.iter().enumerate() {
-        let mut seed = 0xfeed_f00d_u64;
-        let rows: Vec<(i64, i64)> = (0..n_rows)
-            .map(|_| ((xorshift(&mut seed) % 32_768) as i64, (xorshift(&mut seed) % 32_768) as i64))
-            .collect();
-        let ddir_rows: Vec<(Value, Value)> = rows.iter().map(|&(a, b)| (tup(&[a, b]), Value::unit())).collect();
-        let inputs = vec![ddir_rows];
-
-        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
-        if check {
-            // Closed-form oracle: min payload per bucket.
-            let mut mins: std::collections::BTreeMap<i64, i64> = Default::default();
-            for &(a, b) in &rows {
-                for (bucket, payload) in explode(a, b) {
-                    mins.entry(bucket).and_modify(|m| *m = (*m).min(payload)).or_insert(payload);
-                }
-            }
-            let expect: Vec<((Value, Value), i64)> =
-                mins.iter().map(|(&k, &v)| ((tup(&[k]), tup(&[v])), 1)).collect();
-            let expect_nat: Vec<((i64, i64), isize)> =
-                mins.iter().map(|(&k, &v)| ((k, v), 1)).collect();
-
-            let vec_out = vec::evaluate(&p, &inputs);
-            assert_eq!(consolidated(&vec_out["result"]), expect, "vec != oracle at n={n_rows}");
-            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={n_rows}");
-            assert_eq!(native_ast_once(&rows, true).unwrap(), expect_nat, "native != oracle at n={n_rows}");
-        }
-
-        let nt = once(|| { native_ast_once(&rows, false); });
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={n_rows:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
-            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
diff --git a/interactive/examples/corgi_ast_prof.rs b/interactive/examples/corgi_ast_prof.rs
deleted file mode 100644
index cf63dde8b..000000000
--- a/interactive/examples/corgi_ast_prof.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//! Profiling target for B4 ast-compute: loop one backend at a fixed size for samply.
-//!
-//!   N=1000000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
-//!       target/release/examples/corgi_ast_prof
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-const AST_SRC: &str = r#"
-    con Fwd(1) = 0;
-    con Bwd(1) = 1;
-
-    let rows = input 0 | key($0[0] ; $0[1]);
-    let lists = rows | map($0 ; list($0[0], $1[0], $0[0] + $1[0], $0[0] * $1[0], $0[0] - $1[0] + 32768, $1[0] * $1[0], $0[0] * $0[0], $0[0] + $1[0] * $1[0]));
-    let exploded = lists | flatmap($1[0]);
-    let tagged = exploded
-        | map( $1[0] + 8 * if($1[1] < 500000, 0, 1)
-             ; case if($1[1] < 250000,
-                       Fwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)),
-                       Bwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)))
-               {
-                 Fwd(s) => s,
-                 Bwd(s) => s,
-               } );
-    let buckets = tagged | min;
-    export "result" = buckets | arrange;
-"#;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(AST_SRC));
-    p.optimize();
-    let n_rows: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(1_000_000);
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
-    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
-    let mut seed = 0xfeed_f00d_u64;
-    let rows: Vec<(Value, Value)> = (0..n_rows)
-        .map(|_| {
-            let a = (xorshift(&mut seed) % 32_768) as i64;
-            let b = (xorshift(&mut seed) % 32_768) as i64;
-            (Value::Tuple(vec![Value::Int(a), Value::Int(b)]), Value::unit())
-        })
-        .collect();
-    let inputs = vec![rows];
-    let mut acc = 0usize;
-    for _ in 0..iters {
-        acc += match backend.as_str() {
-            "vec" => std::hint::black_box(vec::evaluate(&p, &inputs)).len(),
-            _ => std::hint::black_box(corgi::evaluate(&p, &inputs)).len(),
-        };
-    }
-    eprintln!("done ast backend={backend} n={n_rows} iters={iters} (acc={acc})");
-}
diff --git a/interactive/examples/corgi_compound_prof.rs b/interactive/examples/corgi_compound_prof.rs
deleted file mode 100644
index 286a12cca..000000000
--- a/interactive/examples/corgi_compound_prof.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-//! Profiling target for B2 scc-compound: loop one backend at a fixed size for samply.
-//!
-//!   N=50000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
-//!       target/release/examples/corgi_compound_prof
-//!
-//! BACKEND=corgi (default) or vec — built identically for apples-to-apples profiles.
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-const SCC_COMPOUND_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0][0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0][0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | arrange;
-"#;
-
-const GROUP_BITS: u64 = 10;
-
-fn node_val(x: u64) -> Value {
-    Value::Tuple(vec![Value::Int((x >> GROUP_BITS) as i64), Value::Int((x & ((1 << GROUP_BITS) - 1)) as i64)])
-}
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(SCC_COMPOUND_SRC));
-    p.optimize();
-    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(50_000);
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
-    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
-    let mut seed = 0xc0ff_ee42u64;
-    let edges: Vec<(Value, Value)> = (0..nodes * 2)
-        .map(|_| (Value::Tuple(vec![node_val(xorshift(&mut seed) % nodes), node_val(xorshift(&mut seed) % nodes)]), Value::unit()))
-        .collect();
-    let inputs = vec![edges];
-    let mut acc = 0usize;
-    for _ in 0..iters {
-        acc += match backend.as_str() {
-            "vec" => std::hint::black_box(vec::evaluate(&p, &inputs)).len(),
-            _ => std::hint::black_box(corgi::evaluate(&p, &inputs)).len(),
-        };
-    }
-    eprintln!("done scc-compound backend={backend} n={nodes} iters={iters} (acc={acc})");
-}
diff --git a/interactive/examples/corgi_ident_big.rs b/interactive/examples/corgi_ident_big.rs
deleted file mode 100644
index 0a9bc9463..000000000
--- a/interactive/examples/corgi_ident_big.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-//! B3 "ident-join": identifier resolution via integer joins — the e-graph-flavored workload.
-//!
-//! Structure: a parent forest (chains of length CHAIN; roots hold self-loops) resolved to
-//! roots by pointer-doubling (iterative min-join fixpoint), then a term table (id, a, b)
-//! resolved by two joins mapping child identifiers to their representatives. Everything is
-//! integer-keyed joins + a min reduce — "identifier lookup" as the common action, with the
-//! joins in DD operators (corgi does per-row logic only).
-//!
-//!   N=100000,1000000 CHAIN=64 ~/.cargo/bin/cargo run --release --example corgi_ident_big
-//!
-//! Correctness: closed-form oracle (root(x) = x - x%CHAIN) checked against the vec backend,
-//! corgi asserted == vec, and the hand-written native twin captured + checked against the
-//! same oracle. CHECK=1 forces checks at every size (default: smallest size only).
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-use differential_dataflow::input::Input;
-use differential_dataflow::operators::iterate::Variable;
-use timely::dataflow::operators::probe::Handle;
-use timely::order::Product;
-
-const IDENT_SRC: &str = r#"
-    let parent = input 0 | key($0[0] ; $0[1]);
-    let terms  = input 1 | key($0[0] ; $0[1], $0[2]);
-    find: {
-        let reps = doubled + parent | min;
-        var doubled = reps | key($1 ; $0) | join(reps, ($1 ; $2));
-    }
-    let by_a    = terms | key($1[0] ; $0, $1[1]);
-    let with_a  = by_a  | join(find::reps, ($1[0] ; $1[1], $2));
-    let by_b    = with_a | key($1[0] ; $0, $1[1]);
-    let resolved = by_b | join(find::reps, ($1[0] ; $1[1], $2));
-    export "reps" = find::reps | arrange;
-    export "resolved" = resolved | arrange;
-"#;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
-
-/// The hand-written compiled twin, mirroring the DDIR plan: pointer-doubling fixpoint
-/// (Variable `doubled`; reps = min(doubled + parent); doubled' = reps∘reps), then the two
-/// term-resolution joins against the arranged reps. `capture` returns (reps, resolved).
-#[allow(clippy::type_complexity)]
-fn native_ident_once(
-    parents: &[(i64, i64)],
-    terms: &[(i64, i64, i64)],
-    capture: bool,
-) -> Option<(Vec<((i64, i64), isize)>, Vec<((i64, (i64, i64)), isize)>)> {
-    use timely::dataflow::operators::capture::{Capture, Event, Extract};
-
-    let parents = parents.to_vec();
-    let terms = terms.to_vec();
-    let (reps_tx, reps_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
-    let (res_tx, res_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, (i64, i64)), u64, isize)>>>();
-
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let (mut p_in, mut t_in) = worker.dataflow::<u64, _, _>(|scope| {
-            let (p_in, parent) = scope.new_collection::<(i64, i64), isize>();
-            let (t_in, term_rows) = scope.new_collection::<(i64, (i64, i64)), isize>();
-
-            let outer = parent.scope();
-            let reps = outer.scoped::<Product<u64, usize>, _, _>("Find", |inner| {
-                let parent = parent.enter(inner);
-                let (doubled_var, doubled) = Variable::new(inner, Product::new(Default::default(), 1));
-                let reps = doubled.concat(parent).reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
-                let reps_arr = reps.clone().arrange_by_key();
-                let next = reps
-                    .clone()
-                    .map(|(x, r)| (r, x))
-                    .arrange_by_key()
-                    .join_core(reps_arr, |_r, &x, &r2| Some((x, r2)));
-                doubled_var.set(next);
-                reps.leave(outer)
-            });
-
-            let reps_arr = reps.clone().arrange_by_key();
-            let by_a = term_rows.map(|(id, (a, b))| (a, (id, b))).arrange_by_key();
-            let with_a = by_a.join_core(reps_arr.clone(), |_a, &(id, b), &ra| Some((b, (id, ra))));
-            let resolved = with_a
-                .arrange_by_key()
-                .join_core(reps_arr, |_b, &(id, ra), &rb| Some((id, (ra, rb))));
-
-            resolved.clone().probe_with(&mut probe);
-            if capture {
-                reps.inner.capture_into(reps_tx);
-                resolved.inner.capture_into(res_tx);
-            }
-            (p_in, t_in)
-        });
-
-        for &(x, p) in &parents { p_in.insert((x, p)); }
-        for &(id, a, b) in &terms { t_in.insert((id, (a, b))); }
-        p_in.advance_to(1); p_in.flush();
-        t_in.advance_to(1); t_in.flush();
-        while probe.less_than(p_in.time()) { worker.step(); }
-    });
-
-    if capture {
-        let mut reps: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
-        for (_, batch) in reps_rx.extract() {
-            for (d, _, r) in batch { *reps.entry(d).or_insert(0) += r; }
-        }
-        let mut res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
-        for (_, batch) in res_rx.extract() {
-            for (d, _, r) in batch { *res.entry(d).or_insert(0) += r; }
-        }
-        Some((
-            reps.into_iter().filter(|(_, r)| *r != 0).collect(),
-            res.into_iter().filter(|(_, r)| *r != 0).collect(),
-        ))
-    } else {
-        None
-    }
-}
-
-fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
-
-/// Consolidate a backend export into a sorted (data, diff) list for oracle comparison.
-fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
-    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
-    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
-    map.into_iter().filter(|(_, d)| *d != 0).collect()
-}
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(IDENT_SRC));
-    p.optimize();
-    let sizes: Vec<u64> = std::env::var("N").ok()
-        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
-        .unwrap_or_else(|| vec![100_000, 1_000_000]);
-    let chain: u64 = std::env::var("CHAIN").ok().and_then(|s| s.parse().ok()).unwrap_or(64);
-
-    println!("ident-join (B3) — pointer-doubling reps + 2 term-resolution joins (chains of {chain}, terms = 2n):");
-    for (i, &nodes) in sizes.iter().enumerate() {
-        let n_terms = nodes * 2;
-        let root = |x: u64| (x - x % chain) as i64;
-
-        // Native inputs.
-        let parents: Vec<(i64, i64)> = (0..nodes)
-            .map(|x| (x as i64, if x % chain == 0 { x as i64 } else { (x - 1) as i64 }))
-            .collect();
-        let mut seed = 0xdead_beef_u64;
-        let terms: Vec<(i64, i64, i64)> = (0..n_terms)
-            .map(|j| ((nodes + j) as i64, (xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64))
-            .collect();
-
-        // DDIR inputs: input 0 = (x, parent ;), input 1 = (id, a, b ;).
-        let parent_rows: Vec<(Value, Value)> = parents.iter().map(|&(x, p)| (tup(&[x, p]), Value::unit())).collect();
-        let term_rows: Vec<(Value, Value)> = terms.iter().map(|&(id, a, b)| (tup(&[id, a, b]), Value::unit())).collect();
-        let inputs = vec![parent_rows, term_rows];
-
-        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
-        if check {
-            // Closed-form oracle.
-            let expect_reps: Vec<((Value, Value), i64)> = (0..nodes)
-                .map(|x| ((tup(&[x as i64]), tup(&[root(x)])), 1))
-                .collect();
-            let mut expect_res: Vec<((Value, Value), i64)> = Default::default();
-            {
-                let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
-                for &(id, a, b) in &terms {
-                    *map.entry((tup(&[id]), tup(&[root(a as u64), root(b as u64)]))).or_insert(0) += 1;
-                }
-                expect_res.extend(map.into_iter());
-            }
-
-            let vec_out = vec::evaluate(&p, &inputs);
-            assert_eq!(consolidated(&vec_out["reps"]), expect_reps, "vec reps != oracle at n={nodes}");
-            assert_eq!(consolidated(&vec_out["resolved"]), expect_res, "vec resolved != oracle at n={nodes}");
-            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={nodes}");
-
-            let (nat_reps, nat_res) = native_ident_once(&parents, &terms, true).unwrap();
-            let expect_nat_reps: Vec<((i64, i64), isize)> =
-                (0..nodes).map(|x| ((x as i64, root(x)), 1)).collect();
-            assert_eq!(nat_reps, expect_nat_reps, "native reps != oracle at n={nodes}");
-            let mut expect_nat_res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
-            for &(id, a, b) in &terms {
-                *expect_nat_res.entry((id, (root(a as u64), root(b as u64)))).or_insert(0) += 1;
-            }
-            let expect_nat_res: Vec<_> = expect_nat_res.into_iter().collect();
-            assert_eq!(nat_res, expect_nat_res, "native resolved != oracle at n={nodes}");
-        }
-
-        let nt = once(|| { native_ident_once(&parents, &terms, false); });
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={nodes:<8} terms={n_terms:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
-            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
diff --git a/interactive/examples/corgi_ident_prof.rs b/interactive/examples/corgi_ident_prof.rs
deleted file mode 100644
index b59158333..000000000
--- a/interactive/examples/corgi_ident_prof.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-//! Profiling target for B3 ident-join: loop one backend at a fixed size for samply.
-//!
-//!   N=1000000 ITERS=1 BACKEND=corgi samply record --save-only -o /tmp/p.json.gz -- \
-//!       target/release/examples/corgi_ident_prof
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-const IDENT_SRC: &str = r#"
-    let parent = input 0 | key($0[0] ; $0[1]);
-    let terms  = input 1 | key($0[0] ; $0[1], $0[2]);
-    find: {
-        let reps = doubled + parent | min;
-        var doubled = reps | key($1 ; $0) | join(reps, ($1 ; $2));
-    }
-    let by_a    = terms | key($1[0] ; $0, $1[1]);
-    let with_a  = by_a  | join(find::reps, ($1[0] ; $1[1], $2));
-    let by_b    = with_a | key($1[0] ; $0, $1[1]);
-    let resolved = by_b | join(find::reps, ($1[0] ; $1[1], $2));
-    export "reps" = find::reps | arrange;
-    export "resolved" = resolved | arrange;
-"#;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(IDENT_SRC));
-    p.optimize();
-    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(1_000_000);
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
-    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
-    let chain: u64 = std::env::var("CHAIN").ok().and_then(|s| s.parse().ok()).unwrap_or(64);
-    let n_terms = nodes * 2;
-    let parents: Vec<(Value, Value)> = (0..nodes)
-        .map(|x| (tup(&[x as i64, if x % chain == 0 { x as i64 } else { (x - 1) as i64 }]), Value::unit()))
-        .collect();
-    let mut seed = 0xdead_beef_u64;
-    let terms: Vec<(Value, Value)> = (0..n_terms)
-        .map(|j| (tup(&[(nodes + j) as i64, (xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
-        .collect();
-    let inputs = vec![parents, terms];
-    let mut acc = 0usize;
-    for _ in 0..iters {
-        acc += match backend.as_str() {
-            "vec" => std::hint::black_box(vec::evaluate(&p, &inputs)).len(),
-            _ => std::hint::black_box(corgi::evaluate(&p, &inputs)).len(),
-        };
-    }
-    eprintln!("done ident backend={backend} n={nodes} iters={iters} (acc={acc})");
-}
diff --git a/interactive/examples/corgi_scc_big.rs b/interactive/examples/corgi_scc_big.rs
deleted file mode 100644
index 9774510e3..000000000
--- a/interactive/examples/corgi_scc_big.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-//! Large-N SCC: native DD vs DDIR-vec vs DDIR-corgi at the sizes Frank actually runs
-//! (n = 100k–1m, e = 2n). The small corgi_perf sizes (n<=1000) barely touch the spine
-//! compaction machinery; this is where the arrangement/merge cost shows its true scaling.
-//!
-//!   N=100000,250000,500000,1000000 ~/.cargo/bin/cargo run --release -p interactive --example corgi_scc_big
-//!
-//! One run per backend per size (these are seconds-scale; no median). CHECK=1 asserts corgi==vec
-//! (doubles the corgi+vec work at that size) — on by default only for the smallest size.
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-use differential_dataflow::algorithms::graphs::scc::{strongly_connected, strongly_connected_at};
-use differential_dataflow::input::Input;
-use timely::dataflow::operators::probe::Handle;
-
-const SCC_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | map(;) | arrange;
-"#;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
-
-fn native_scc_once(edges: &[(usize, usize)]) {
-    let edges = edges.to_vec();
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
-            strongly_connected(graph).probe_with(&mut probe);
-            input
-        });
-        for &(s, d) in &edges { input.insert((s, d)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-}
-
-/// The FAIR compiled baseline: label introduction log-bucketed exactly as DDIR's
-/// `enter_at($1[0])` (propagate_core applies `256 * (64 - leading_zeros(logic(label)))`,
-/// the same delay vec.rs/corgi.rs compute), so native and DDIR run the same algorithm.
-fn native_scc_at_once(edges: &[(usize, usize)]) {
-    let edges = edges.to_vec();
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
-            strongly_connected_at(graph, |x| *x as u64).probe_with(&mut probe);
-            input
-        });
-        for &(s, d) in &edges { input.insert((s, d)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-}
-
-fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
-    p.optimize();
-    let sizes: Vec<u64> = std::env::var("N").ok()
-        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
-        .unwrap_or_else(|| vec![100_000, 250_000, 500_000, 1_000_000]);
-
-    println!("SCC large-N — native DD / fair native (enter_at) / DDIR-vec / DDIR-corgi (e = 2n):");
-    let seed0: u64 = std::env::var("SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(0xc0ff_ee42);
-    for (i, &nodes) in sizes.iter().enumerate() {
-        let n_edges = nodes * 2;
-        let mut seed = seed0;
-        let edges: Vec<(Value, Value)> = (0..n_edges)
-            .map(|_| (tup(&[(xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
-            .collect();
-        let mut seed2 = seed0;
-        let native_edges: Vec<(usize, usize)> = (0..n_edges)
-            .map(|_| ((xorshift(&mut seed2) % nodes) as usize, (xorshift(&mut seed2) % nodes) as usize))
-            .collect();
-        let inputs = vec![edges];
-
-        // Correctness check (doubles work): default on for the first/smallest size only.
-        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
-        if check {
-            assert_eq!(corgi::evaluate(&p, &inputs), vec::evaluate(&p, &inputs), "corgi != vec at n={nodes}");
-        }
-
-        let nt = once(|| native_scc_once(&native_edges));
-        let ft = once(|| native_scc_at_once(&native_edges));
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, ff, vf, cf) = (nt.as_secs_f64(), ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={nodes:<8} e={n_edges:<9}  native {nt:>8.2?}   fair(enter_at) {ft:>8.2?} ({:.2}x nat)   vec-DDIR {vt:>8.2?} ({:.2}x fair)   corgi-DDIR {ct:>8.2?} ({:.2}x fair, {:.2}x vec){}",
-            ff / nf, vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
diff --git a/interactive/examples/corgi_scc_compound.rs b/interactive/examples/corgi_scc_compound.rs
deleted file mode 100644
index 2c8bf91a2..000000000
--- a/interactive/examples/corgi_scc_compound.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-//! B2 "scc-compound": SCC where node identity is a compound value — each node is the
-//! nested tuple (group, index) = (x >> 10, x & 1023) — same control structure as B1
-//! (corgi_scc_big) but compound keys/labels everywhere: no value-as-id fast path, so
-//! hashing, compound compares, and gather of nested columns carry the load.
-//!
-//!   N=100000,150000 ~/.cargo/bin/cargo run --release --example corgi_scc_compound
-//!
-//! Fairness: the native twin is `strongly_connected_at` over (i64,i64) nodes with
-//! `logic = |n| n.0` — the same delay DDIR's `enter_at($1[0][0])` computes (bucket by
-//! group). The encoding x -> (x>>10, x&1023) is order-preserving, so min-label agrees
-//! with B1 on the same graph.
-//!
-//! Correctness (CHECK=1 forces; default smallest size): corgi == vec on the full SCC
-//! edge set, and the compound program's output mapped back through the encoding equals
-//! the plain-encoding program's output (vec backend) on the same graph.
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-use differential_dataflow::algorithms::graphs::scc::strongly_connected_at;
-use differential_dataflow::input::Input;
-use timely::dataflow::operators::probe::Handle;
-
-/// Compound-node SCC: identical to B1's program except nodes are single fields holding
-/// (group, index) tuples, and enter_at buckets by the group (first field of the node).
-const SCC_COMPOUND_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0][0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0][0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | arrange;
-"#;
-
-/// Plain-encoding SCC (B1's program with the full edge-set export) — the reference for
-/// the encoding cross-check.
-const SCC_PLAIN_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | arrange;
-"#;
-
-const GROUP_BITS: u64 = 10;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn node_val(x: u64) -> Value {
-    Value::Tuple(vec![Value::Int((x >> GROUP_BITS) as i64), Value::Int((x & ((1 << GROUP_BITS) - 1)) as i64)])
-}
-
-fn decode(v: &Value) -> i64 {
-    match v {
-        Value::Tuple(fs) => match (&fs[0], &fs[1]) {
-            (Value::Int(g), Value::Int(i)) => (g << GROUP_BITS) | i,
-            other => panic!("decode: unexpected node fields {other:?}"),
-        },
-        other => panic!("decode: unexpected node {other:?}"),
-    }
-}
-
-fn native_scc_compound_once(edges: &[(u64, u64)]) {
-    let enc = |x: u64| ((x >> GROUP_BITS) as i64, (x & ((1 << GROUP_BITS) - 1)) as i64);
-    let edges: Vec<((i64, i64), (i64, i64))> = edges.iter().map(|&(s, d)| (enc(s), enc(d))).collect();
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, graph) = scope.new_collection::<((i64, i64), (i64, i64)), isize>();
-            strongly_connected_at(graph, |n| n.0 as u64).probe_with(&mut probe);
-            input
-        });
-        for &(s, d) in &edges { input.insert((s, d)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-}
-
-fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
-
-fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
-    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
-    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
-    map.into_iter().filter(|(_, d)| *d != 0).collect()
-}
-
-fn main() {
-    let mut p_compound = lower::lower_tree(parse::pipe::parse(SCC_COMPOUND_SRC));
-    p_compound.optimize();
-    let mut p_plain = lower::lower_tree(parse::pipe::parse(SCC_PLAIN_SRC));
-    p_plain.optimize();
-
-    let sizes: Vec<u64> = std::env::var("N").ok()
-        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
-        .unwrap_or_else(|| vec![100_000, 150_000]);
-
-    println!("scc-compound (B2) — nodes are (group,index) tuples; fair native / DDIR-vec / DDIR-corgi (e = 2n):");
-    for (i, &nodes) in sizes.iter().enumerate() {
-        let n_edges = nodes * 2;
-        let mut seed = 0xc0ff_ee42u64;
-        let raw_edges: Vec<(u64, u64)> = (0..n_edges)
-            .map(|_| (xorshift(&mut seed) % nodes, xorshift(&mut seed) % nodes))
-            .collect();
-
-        let compound_rows: Vec<(Value, Value)> = raw_edges.iter()
-            .map(|&(s, d)| (Value::Tuple(vec![node_val(s), node_val(d)]), Value::unit()))
-            .collect();
-        let inputs = vec![compound_rows];
-
-        let check = std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0);
-        if check {
-            let vec_out = vec::evaluate(&p_compound, &inputs);
-            assert_eq!(corgi::evaluate(&p_compound, &inputs), vec_out, "corgi != vec at n={nodes}");
-
-            // Encoding cross-check: compound output mapped back == plain-program output.
-            let plain_rows: Vec<(Value, Value)> = raw_edges.iter()
-                .map(|&(s, d)| (Value::Tuple(vec![Value::Int(s as i64), Value::Int(d as i64)]), Value::unit()))
-                .collect();
-            let plain_out = vec::evaluate(&p_plain, &vec![plain_rows]);
-            // Export shape: key = (src_node), val = (dst_node), each node one compound field.
-            let remap = |t: &Value| match t {
-                Value::Tuple(fs) => Value::Tuple(fs.iter().map(|f| Value::Int(decode(f))).collect()),
-                other => panic!("unexpected row {other:?}"),
-            };
-            let mut mapped: Vec<((Value, Value), i64)> = consolidated(&vec_out["result"]).into_iter()
-                .map(|((k, v), d)| ((remap(&k), remap(&v)), d))
-                .collect();
-            mapped.sort();
-            assert_eq!(mapped, consolidated(&plain_out["result"]), "compound != plain (mapped) at n={nodes}");
-        }
-
-        let ft = once(|| native_scc_compound_once(&raw_edges));
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p_compound, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p_compound, &inputs)); });
-        let (ff, vf, cf) = (ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={nodes:<8} e={n_edges:<9}  native(fair) {ft:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
-            vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
diff --git a/interactive/examples/corgi_scc_prof.rs b/interactive/examples/corgi_scc_prof.rs
deleted file mode 100644
index 8d41be763..000000000
--- a/interactive/examples/corgi_scc_prof.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//! Profiling target: loop corgi's SCC at a fixed size for samply. Attribute the slowness to
-//! framework (int_proxy tactic / timely) vs corgi backend (present/materialize/arrange/join/eval).
-//!
-//!   ITERS=300 N=500 samply record -- .../corgi_scc_prof
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use interactive::backend::corgi;
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-const SCC_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | map(;) | arrange;
-"#;
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
-    p.optimize();
-    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(500);
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(300);
-    let mut seed = 0xc0ff_ee42u64;
-    let edges: Vec<(Value, Value)> = (0..nodes * 2)
-        .map(|_| (Value::Tuple(vec![Value::Int((xorshift(&mut seed) % nodes) as i64), Value::Int((xorshift(&mut seed) % nodes) as i64)]), Value::unit()))
-        .collect();
-    let inputs = vec![edges];
-    let mut acc = 0usize;
-    for _ in 0..iters {
-        acc += std::hint::black_box(corgi::evaluate(&p, &inputs)).len();
-    }
-    eprintln!("done scc n={nodes} iters={iters} (acc={acc})");
-}
diff --git a/interactive/examples/ddir_bench.rs b/interactive/examples/ddir_bench.rs
new file mode 100644
index 000000000..0cebec9d2
--- /dev/null
+++ b/interactive/examples/ddir_bench.rs
@@ -0,0 +1,545 @@
+//! The DDIR benchmark runner: interpreted programs from `examples/programs/*.ddp`,
+//! compiled twins and input generators registered here by bench name.
+//!
+//!   ddir_bench <bench>        bench ∈ { scc, scc-compound, ident, ast }
+//!
+//! Environment:
+//!   N=a,b,..   sizes (per-bench defaults below)
+//!   CHECK=0/1  correctness assertions (default: first size only)
+//!   SEED=      graph seed (scc)          CHAIN=  chain length (ident)
+//!   BACKEND=corgi|vec|native|native-fair with ITERS=k — profiling mode: loop ONE
+//!   column at the first size, no table (a samply target; replaces the prof twins).
+//!
+//! Fairness: the scc twins include `strongly_connected_at` with the same enter_at
+//! log-bucketing the DDIR programs apply, so compiled and interpreted run the same
+//! algorithm. Correctness: corgi == vec asserted per checked row; ident and ast also
+//! check both backends and the compiled twin against closed-form oracles;
+//! scc-compound additionally maps its compound encoding back and compares against
+//! the plain-encoding program.
+
+// The suite runs on mimalloc (as a real deployment would): one binary, so every
+// column shares the allocator.
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+use std::time::{Duration, Instant};
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::scope_ir::Program;
+use interactive::{lower, parse};
+
+use differential_dataflow::algorithms::graphs::scc::{strongly_connected, strongly_connected_at};
+use differential_dataflow::input::Input;
+use differential_dataflow::operators::iterate::Variable;
+use timely::dataflow::operators::probe::Handle;
+use timely::order::Product;
+
+fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
+
+fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
+
+fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
+
+fn program(name: &str) -> Program {
+    let path = format!("{}/examples/programs/{name}.ddp", env!("CARGO_MANIFEST_DIR"));
+    let mut p = lower::lower_tree(parse::pipe::parse(&interactive::load_program(&path)));
+    p.optimize();
+    p
+}
+
+fn sizes(default: &[u64]) -> Vec<u64> {
+    std::env::var("N").ok()
+        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
+        .unwrap_or_else(|| default.to_vec())
+}
+
+fn checked(i: usize) -> bool {
+    std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0)
+}
+
+/// Profiling mode: `BACKEND=` set — loop that one column `ITERS` times at the first size.
+fn prof_mode() -> Option<(String, usize)> {
+    std::env::var("BACKEND").ok().map(|b| {
+        let iters = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
+        (b, iters)
+    })
+}
+
+fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
+    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
+    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
+    map.into_iter().filter(|(_, d)| *d != 0).collect()
+}
+
+// ---------------------------------------------------------------------------------------
+// scc — B1: SCC four ways at n = 100k..1m, e = 2n.
+// ---------------------------------------------------------------------------------------
+
+fn native_scc_once(edges: &[(usize, usize)], fair: bool) {
+    let edges = edges.to_vec();
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
+            if fair {
+                strongly_connected_at(graph, |x| *x as u64).probe_with(&mut probe);
+            } else {
+                strongly_connected(graph).probe_with(&mut probe);
+            }
+            input
+        });
+        for &(s, d) in &edges { input.insert((s, d)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+}
+
+fn scc_edges(nodes: u64, seed0: u64) -> (Vec<(Value, Value)>, Vec<(usize, usize)>) {
+    let n_edges = nodes * 2;
+    let mut seed = seed0;
+    let rows: Vec<(Value, Value)> = (0..n_edges)
+        .map(|_| (tup(&[(xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
+        .collect();
+    let mut seed = seed0;
+    let native: Vec<(usize, usize)> = (0..n_edges)
+        .map(|_| ((xorshift(&mut seed) % nodes) as usize, (xorshift(&mut seed) % nodes) as usize))
+        .collect();
+    (rows, native)
+}
+
+fn bench_scc() {
+    let p = program("scc");
+    let seed0: u64 = std::env::var("SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(0xc0ff_ee42);
+    let sizes = sizes(&[100_000, 250_000, 500_000, 1_000_000]);
+
+    if let Some((backend, iters)) = prof_mode() {
+        let nodes = sizes[0];
+        let (rows, native) = scc_edges(nodes, seed0);
+        let inputs = vec![rows];
+        for i in 0..iters {
+            match backend.as_str() {
+                "corgi" => { std::hint::black_box(corgi::evaluate(&p, &inputs)); }
+                "vec" => { std::hint::black_box(vec::evaluate(&p, &inputs)); }
+                "native" => native_scc_once(&native, false),
+                "native-fair" => native_scc_once(&native, true),
+                other => panic!("scc: unknown BACKEND {other}"),
+            }
+            println!("done scc backend={backend} n={nodes} iter={i}");
+        }
+        return;
+    }
+
+    println!("SCC large-N — native DD / fair native (enter_at) / DDIR-vec / DDIR-corgi (e = 2n):");
+    for (i, &nodes) in sizes.iter().enumerate() {
+        let (rows, native) = scc_edges(nodes, seed0);
+        let n_edges = nodes * 2;
+        let inputs = vec![rows];
+        let check = checked(i);
+        if check {
+            assert_eq!(corgi::evaluate(&p, &inputs), vec::evaluate(&p, &inputs), "corgi != vec at n={nodes}");
+        }
+        let nt = once(|| native_scc_once(&native, false));
+        let ft = once(|| native_scc_once(&native, true));
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+        let (nf, ff, vf, cf) = (nt.as_secs_f64(), ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={nodes:<8} e={n_edges:<9}  native {nt:>8.2?}   fair(enter_at) {ft:>8.2?} ({:.2}x nat)   vec-DDIR {vt:>8.2?} ({:.2}x fair)   corgi-DDIR {ct:>8.2?} ({:.2}x fair, {:.2}x vec){}",
+            ff / nf, vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// scc-compound — B2: nodes are (group, index) tuples; compound keys and labels throughout.
+// ---------------------------------------------------------------------------------------
+
+const GROUP_BITS: u64 = 10;
+
+fn node_val(x: u64) -> Value {
+    Value::Tuple(vec![Value::Int((x >> GROUP_BITS) as i64), Value::Int((x & ((1 << GROUP_BITS) - 1)) as i64)])
+}
+
+fn decode(v: &Value) -> i64 {
+    match v {
+        Value::Tuple(fs) => match (&fs[0], &fs[1]) {
+            (Value::Int(g), Value::Int(i)) => (g << GROUP_BITS) | i,
+            other => panic!("decode: unexpected node fields {other:?}"),
+        },
+        other => panic!("decode: unexpected node {other:?}"),
+    }
+}
+
+fn native_scc_compound_once(edges: &[(u64, u64)]) {
+    let enc = |x: u64| ((x >> GROUP_BITS) as i64, (x & ((1 << GROUP_BITS) - 1)) as i64);
+    let edges: Vec<((i64, i64), (i64, i64))> = edges.iter().map(|&(s, d)| (enc(s), enc(d))).collect();
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, graph) = scope.new_collection::<((i64, i64), (i64, i64)), isize>();
+            strongly_connected_at(graph, |n| n.0 as u64).probe_with(&mut probe);
+            input
+        });
+        for &(s, d) in &edges { input.insert((s, d)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+}
+
+fn bench_scc_compound() {
+    let p_compound = program("scc_compound");
+    let p_plain = program("scc_plain");
+    let sizes = sizes(&[100_000, 150_000]);
+
+    let gen = |nodes: u64| -> (Vec<(u64, u64)>, Vec<(Value, Value)>) {
+        let n_edges = nodes * 2;
+        let mut seed = 0xc0ff_ee42u64;
+        let raw: Vec<(u64, u64)> = (0..n_edges)
+            .map(|_| (xorshift(&mut seed) % nodes, xorshift(&mut seed) % nodes))
+            .collect();
+        let rows = raw.iter()
+            .map(|&(s, d)| (Value::Tuple(vec![node_val(s), node_val(d)]), Value::unit()))
+            .collect();
+        (raw, rows)
+    };
+
+    if let Some((backend, iters)) = prof_mode() {
+        let nodes = sizes[0];
+        let (raw, rows) = gen(nodes);
+        let inputs = vec![rows];
+        for i in 0..iters {
+            match backend.as_str() {
+                "corgi" => { std::hint::black_box(corgi::evaluate(&p_compound, &inputs)); }
+                "vec" => { std::hint::black_box(vec::evaluate(&p_compound, &inputs)); }
+                "native" | "native-fair" => native_scc_compound_once(&raw),
+                other => panic!("scc-compound: unknown BACKEND {other}"),
+            }
+            println!("done scc-compound backend={backend} n={nodes} iter={i}");
+        }
+        return;
+    }
+
+    println!("scc-compound (B2) — nodes are (group,index) tuples; fair native / DDIR-vec / DDIR-corgi (e = 2n):");
+    for (i, &nodes) in sizes.iter().enumerate() {
+        let n_edges = nodes * 2;
+        let (raw_edges, compound_rows) = gen(nodes);
+        let inputs = vec![compound_rows];
+
+        let check = checked(i);
+        if check {
+            let vec_out = vec::evaluate(&p_compound, &inputs);
+            assert_eq!(corgi::evaluate(&p_compound, &inputs), vec_out, "corgi != vec at n={nodes}");
+
+            // Encoding cross-check: compound output mapped back == plain-program output.
+            let plain_rows: Vec<(Value, Value)> = raw_edges.iter()
+                .map(|&(s, d)| (Value::Tuple(vec![Value::Int(s as i64), Value::Int(d as i64)]), Value::unit()))
+                .collect();
+            let plain_out = vec::evaluate(&p_plain, &vec![plain_rows]);
+            let remap = |t: &Value| match t {
+                Value::Tuple(fs) => Value::Tuple(fs.iter().map(|f| Value::Int(decode(f))).collect()),
+                other => panic!("unexpected row {other:?}"),
+            };
+            let mut mapped: Vec<((Value, Value), i64)> = consolidated(&vec_out["result"]).into_iter()
+                .map(|((k, v), d)| ((remap(&k), remap(&v)), d))
+                .collect();
+            mapped.sort();
+            assert_eq!(mapped, consolidated(&plain_out["result"]), "compound != plain (mapped) at n={nodes}");
+        }
+
+        let ft = once(|| native_scc_compound_once(&raw_edges));
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p_compound, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p_compound, &inputs)); });
+        let (ff, vf, cf) = (ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={nodes:<8} e={n_edges:<9}  native(fair) {ft:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
+            vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// ident — B3: pointer-doubling representatives + two term-resolution joins.
+// ---------------------------------------------------------------------------------------
+
+#[allow(clippy::type_complexity)]
+fn native_ident_once(
+    parents: &[(i64, i64)],
+    terms: &[(i64, i64, i64)],
+    capture: bool,
+) -> Option<(Vec<((i64, i64), isize)>, Vec<((i64, (i64, i64)), isize)>)> {
+    use timely::dataflow::operators::capture::{Capture, Event, Extract};
+
+    let parents = parents.to_vec();
+    let terms = terms.to_vec();
+    let (reps_tx, reps_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
+    let (res_tx, res_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, (i64, i64)), u64, isize)>>>();
+
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let (mut p_in, mut t_in) = worker.dataflow::<u64, _, _>(|scope| {
+            let (p_in, parent) = scope.new_collection::<(i64, i64), isize>();
+            let (t_in, term_rows) = scope.new_collection::<(i64, (i64, i64)), isize>();
+
+            let outer = parent.scope();
+            let reps = outer.scoped::<Product<u64, usize>, _, _>("Find", |inner| {
+                let parent = parent.enter(inner);
+                let (doubled_var, doubled) = Variable::new(inner, Product::new(Default::default(), 1));
+                let reps = doubled.concat(parent).reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
+                let reps_arr = reps.clone().arrange_by_key();
+                let next = reps
+                    .clone()
+                    .map(|(x, r)| (r, x))
+                    .arrange_by_key()
+                    .join_core(reps_arr, |_r, &x, &r2| Some((x, r2)));
+                doubled_var.set(next);
+                reps.leave(outer)
+            });
+
+            let reps_arr = reps.clone().arrange_by_key();
+            let by_a = term_rows.map(|(id, (a, b))| (a, (id, b))).arrange_by_key();
+            let with_a = by_a.join_core(reps_arr.clone(), |_a, &(id, b), &ra| Some((b, (id, ra))));
+            let resolved = with_a
+                .arrange_by_key()
+                .join_core(reps_arr, |_b, &(id, ra), &rb| Some((id, (ra, rb))));
+
+            resolved.clone().probe_with(&mut probe);
+            if capture {
+                reps.inner.capture_into(reps_tx);
+                resolved.inner.capture_into(res_tx);
+            }
+            (p_in, t_in)
+        });
+
+        for &(x, p) in &parents { p_in.insert((x, p)); }
+        for &(id, a, b) in &terms { t_in.insert((id, (a, b))); }
+        p_in.advance_to(1); p_in.flush();
+        t_in.advance_to(1); t_in.flush();
+        while probe.less_than(p_in.time()) { worker.step(); }
+    });
+
+    if capture {
+        let mut reps: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
+        for (_, batch) in reps_rx.extract() {
+            for (d, _, r) in batch { *reps.entry(d).or_insert(0) += r; }
+        }
+        let mut res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
+        for (_, batch) in res_rx.extract() {
+            for (d, _, r) in batch { *res.entry(d).or_insert(0) += r; }
+        }
+        Some((
+            reps.into_iter().filter(|(_, r)| *r != 0).collect(),
+            res.into_iter().filter(|(_, r)| *r != 0).collect(),
+        ))
+    } else {
+        None
+    }
+}
+
+fn bench_ident() {
+    let p = program("ident");
+    let sizes = sizes(&[100_000, 1_000_000]);
+    let chain: u64 = std::env::var("CHAIN").ok().and_then(|s| s.parse().ok()).unwrap_or(64);
+
+    let gen = |nodes: u64| {
+        let n_terms = nodes * 2;
+        let parents: Vec<(i64, i64)> = (0..nodes)
+            .map(|x| (x as i64, if x % chain == 0 { x as i64 } else { (x - 1) as i64 }))
+            .collect();
+        let mut seed = 0xdead_beef_u64;
+        let terms: Vec<(i64, i64, i64)> = (0..n_terms)
+            .map(|j| ((nodes + j) as i64, (xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64))
+            .collect();
+        let parent_rows: Vec<(Value, Value)> = parents.iter().map(|&(x, p)| (tup(&[x, p]), Value::unit())).collect();
+        let term_rows: Vec<(Value, Value)> = terms.iter().map(|&(id, a, b)| (tup(&[id, a, b]), Value::unit())).collect();
+        (parents, terms, vec![parent_rows, term_rows])
+    };
+
+    if let Some((backend, iters)) = prof_mode() {
+        let nodes = sizes[0];
+        let (parents, terms, inputs) = gen(nodes);
+        for i in 0..iters {
+            match backend.as_str() {
+                "corgi" => { std::hint::black_box(corgi::evaluate(&p, &inputs)); }
+                "vec" => { std::hint::black_box(vec::evaluate(&p, &inputs)); }
+                "native" => { native_ident_once(&parents, &terms, false); }
+                other => panic!("ident: unknown BACKEND {other}"),
+            }
+            println!("done ident backend={backend} n={nodes} iter={i}");
+        }
+        return;
+    }
+
+    println!("ident-join (B3) — pointer-doubling reps + 2 term-resolution joins (chains of {chain}, terms = 2n):");
+    for (i, &nodes) in sizes.iter().enumerate() {
+        let n_terms = nodes * 2;
+        let root = |x: u64| (x - x % chain) as i64;
+        let (parents, terms, inputs) = gen(nodes);
+
+        let check = checked(i);
+        if check {
+            let expect_reps: Vec<((Value, Value), i64)> = (0..nodes)
+                .map(|x| ((tup(&[x as i64]), tup(&[root(x)])), 1))
+                .collect();
+            let mut expect_res: Vec<((Value, Value), i64)> = Default::default();
+            {
+                let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
+                for &(id, a, b) in &terms {
+                    *map.entry((tup(&[id]), tup(&[root(a as u64), root(b as u64)]))).or_insert(0) += 1;
+                }
+                expect_res.extend(map.into_iter());
+            }
+
+            let vec_out = vec::evaluate(&p, &inputs);
+            assert_eq!(consolidated(&vec_out["reps"]), expect_reps, "vec reps != oracle at n={nodes}");
+            assert_eq!(consolidated(&vec_out["resolved"]), expect_res, "vec resolved != oracle at n={nodes}");
+            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={nodes}");
+
+            let (nat_reps, nat_res) = native_ident_once(&parents, &terms, true).unwrap();
+            let expect_nat_reps: Vec<((i64, i64), isize)> =
+                (0..nodes).map(|x| ((x as i64, root(x)), 1)).collect();
+            assert_eq!(nat_reps, expect_nat_reps, "native reps != oracle at n={nodes}");
+            let mut expect_nat_res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
+            for &(id, a, b) in &terms {
+                *expect_nat_res.entry((id, (root(a as u64), root(b as u64)))).or_insert(0) += 1;
+            }
+            let expect_nat_res: Vec<_> = expect_nat_res.into_iter().collect();
+            assert_eq!(nat_res, expect_nat_res, "native resolved != oracle at n={nodes}");
+        }
+
+        let nt = once(|| { native_ident_once(&parents, &terms, false); });
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={nodes:<8} terms={n_terms:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
+            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}
+
+// ---------------------------------------------------------------------------------------
+// ast — B4: list build + flatmap + variant/case/fold + min (8 elements per row).
+// ---------------------------------------------------------------------------------------
+
+const H: i64 = 500_000;
+
+/// The per-row logic, shared by the oracle and the native twin.
+fn explode(a: i64, b: i64) -> impl Iterator<Item = (i64, i64)> {
+    let elems = [a, b, a + b, a * b, a - b + 32768, b * b, a * a, a + b * b];
+    elems.into_iter().enumerate().map(move |(pos, e)| {
+        let bucket = pos as i64 + 8 * if e < H { 0 } else { 1 };
+        let payload = a + e + a * e + e * e;
+        (bucket, payload)
+    })
+}
+
+fn native_ast_once(rows: &[(i64, i64)], capture: bool) -> Option<Vec<((i64, i64), isize)>> {
+    use timely::dataflow::operators::capture::{Capture, Event, Extract};
+    let rows = rows.to_vec();
+    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
+
+    timely::execute_directly(move |worker| {
+        let mut probe = Handle::new();
+        let mut input = worker.dataflow::<u64, _, _>(|scope| {
+            let (input, data) = scope.new_collection::<(i64, i64), isize>();
+            let buckets = data
+                .flat_map(|(a, b)| explode(a, b))
+                .reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
+            buckets.clone().probe_with(&mut probe);
+            if capture { buckets.inner.capture_into(tx); }
+            input
+        });
+        for &(a, b) in &rows { input.insert((a, b)); }
+        input.advance_to(1);
+        input.flush();
+        while probe.less_than(input.time()) { worker.step(); }
+    });
+
+    if capture {
+        let mut out: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
+        for (_, batch) in rx.extract() {
+            for (d, _, r) in batch { *out.entry(d).or_insert(0) += r; }
+        }
+        Some(out.into_iter().filter(|(_, r)| *r != 0).collect())
+    } else {
+        None
+    }
+}
+
+fn bench_ast() {
+    let p = program("ast");
+    let sizes = sizes(&[1_000_000, 4_000_000]);
+
+    let gen = |n_rows: u64| {
+        let mut seed = 0xfeed_f00d_u64;
+        let rows: Vec<(i64, i64)> = (0..n_rows)
+            .map(|_| ((xorshift(&mut seed) % 32_768) as i64, (xorshift(&mut seed) % 32_768) as i64))
+            .collect();
+        let ddir: Vec<(Value, Value)> = rows.iter().map(|&(a, b)| (tup(&[a, b]), Value::unit())).collect();
+        (rows, vec![ddir])
+    };
+
+    if let Some((backend, iters)) = prof_mode() {
+        let n_rows = sizes[0];
+        let (rows, inputs) = gen(n_rows);
+        for i in 0..iters {
+            match backend.as_str() {
+                "corgi" => { std::hint::black_box(corgi::evaluate(&p, &inputs)); }
+                "vec" => { std::hint::black_box(vec::evaluate(&p, &inputs)); }
+                "native" => { native_ast_once(&rows, false); }
+                other => panic!("ast: unknown BACKEND {other}"),
+            }
+            println!("done ast backend={backend} n={n_rows} iter={i}");
+        }
+        return;
+    }
+
+    println!("ast-compute (B4) — list build + flatmap + variant/case/fold + min (8 elems/row):");
+    for (i, &n_rows) in sizes.iter().enumerate() {
+        let (rows, inputs) = gen(n_rows);
+
+        let check = checked(i);
+        if check {
+            let mut mins: std::collections::BTreeMap<i64, i64> = Default::default();
+            for &(a, b) in &rows {
+                for (bucket, payload) in explode(a, b) {
+                    mins.entry(bucket).and_modify(|m| *m = (*m).min(payload)).or_insert(payload);
+                }
+            }
+            let expect: Vec<((Value, Value), i64)> =
+                mins.iter().map(|(&k, &v)| ((tup(&[k]), tup(&[v])), 1)).collect();
+            let expect_nat: Vec<((i64, i64), isize)> =
+                mins.iter().map(|(&k, &v)| ((k, v), 1)).collect();
+
+            let vec_out = vec::evaluate(&p, &inputs);
+            assert_eq!(consolidated(&vec_out["result"]), expect, "vec != oracle at n={n_rows}");
+            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={n_rows}");
+            assert_eq!(native_ast_once(&rows, true).unwrap(), expect_nat, "native != oracle at n={n_rows}");
+        }
+
+        let nt = once(|| { native_ast_once(&rows, false); });
+        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
+        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
+        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
+        println!(
+            "  n={n_rows:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
+            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
+        );
+    }
+}
+
+fn main() {
+    match std::env::args().nth(1).as_deref() {
+        Some("scc") => bench_scc(),
+        Some("scc-compound") => bench_scc_compound(),
+        Some("ident") => bench_ident(),
+        Some("ast") => bench_ast(),
+        other => {
+            eprintln!("usage: ddir_bench <scc|scc-compound|ident|ast>  (got {other:?})");
+            std::process::exit(1);
+        }
+    }
+}
diff --git a/interactive/examples/native_scc_prof.rs b/interactive/examples/native_scc_prof.rs
deleted file mode 100644
index 7f95d60ad..000000000
--- a/interactive/examples/native_scc_prof.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! Profiling target: loop FAIR compiled SCC (`strongly_connected_at`, the same enter_at
-//! log-bucketing DDIR uses) at a fixed size for samply — the compiled twin of
-//! `vec_scc_prof`/`corgi_scc_prof`, for decomposing the DDIR-over-compiled framework tax.
-//!
-//!   ITERS=5 N=100000 samply record -- .../native_scc_prof
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use differential_dataflow::algorithms::graphs::scc::strongly_connected_at;
-use differential_dataflow::input::Input;
-use timely::dataflow::operators::probe::Handle;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn main() {
-    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(100_000);
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
-    let n_edges = nodes * 2;
-    let mut seed = 0xc0ff_ee42u64;
-    let edges: Vec<(usize, usize)> = (0..n_edges)
-        .map(|_| ((xorshift(&mut seed) % nodes) as usize, (xorshift(&mut seed) % nodes) as usize))
-        .collect();
-
-    for i in 0..iters {
-        let edges = edges.clone();
-        timely::execute_directly(move |worker| {
-            let mut probe = Handle::new();
-            let mut input = worker.dataflow::<u64, _, _>(|scope| {
-                let (input, graph) = scope.new_collection::<(usize, usize), isize>();
-                strongly_connected_at(graph, |x| *x as u64).probe_with(&mut probe);
-                input
-            });
-            for &(s, d) in &edges { input.insert((s, d)); }
-            input.advance_to(1);
-            input.flush();
-            while probe.less_than(input.time()) { worker.step(); }
-        });
-        println!("done native-fair scc n={nodes} iter={i}");
-    }
-}
diff --git a/interactive/examples/programs/ast.ddp b/interactive/examples/programs/ast.ddp
new file mode 100644
index 000000000..d4d21c473
--- /dev/null
+++ b/interactive/examples/programs/ast.ddp
@@ -0,0 +1,17 @@
+con Fwd(1) = 0;
+    con Bwd(1) = 1;
+
+    let rows = input 0 | key($0[0] ; $0[1]);
+    let lists = rows | map($0 ; list($0[0], $1[0], $0[0] + $1[0], $0[0] * $1[0], $0[0] - $1[0] + 32768, $1[0] * $1[0], $0[0] * $0[0], $0[0] + $1[0] * $1[0]));
+    let exploded = lists | flatmap($1[0]);
+    let tagged = exploded
+        | map( $1[0] + 8 * if($1[1] < 500000, 0, 1)
+             ; case if($1[1] < 250000,
+                       Fwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)),
+                       Bwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)))
+               {
+                 Fwd(s) => s,
+                 Bwd(s) => s,
+               } );
+    let buckets = tagged | min;
+    export "result" = buckets | arrange;
diff --git a/interactive/examples/programs/ident.ddp b/interactive/examples/programs/ident.ddp
new file mode 100644
index 000000000..51335de30
--- /dev/null
+++ b/interactive/examples/programs/ident.ddp
@@ -0,0 +1,12 @@
+let parent = input 0 | key($0[0] ; $0[1]);
+    let terms  = input 1 | key($0[0] ; $0[1], $0[2]);
+    find: {
+        let reps = doubled + parent | min;
+        var doubled = reps | key($1 ; $0) | join(reps, ($1 ; $2));
+    }
+    let by_a    = terms | key($1[0] ; $0, $1[1]);
+    let with_a  = by_a  | join(find::reps, ($1[0] ; $1[1], $2));
+    let by_b    = with_a | key($1[0] ; $0, $1[1]);
+    let resolved = by_b | join(find::reps, ($1[0] ; $1[1], $2));
+    export "reps" = find::reps | arrange;
+    export "resolved" = resolved | arrange;
diff --git a/interactive/examples/programs/scc.ddp b/interactive/examples/programs/scc.ddp
index 91c673ddf..d660f7c3b 100644
--- a/interactive/examples/programs/scc.ddp
+++ b/interactive/examples/programs/scc.ddp
@@ -1,37 +1,19 @@
--- Strongly Connected Components — pipe syntax
--- input 0: edges (src, dst ;)
-
 let edges = input 0 | key($0[0] ; $0[1]);
-let trans = edges | key($1 ; $0);
-
-outer: {
-    let scc = edges + trim;
-
-    fwd: {
-        let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-        let labels = proposals + nodes | min;
-        var proposals = labels | join(scc, ($2 ; $1));
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
     }
-
-    let trim_fwd = edges
-        | join(fwd::labels, ($1 ; $0, $2))
-        | join(fwd::labels, ($0 ; $1, $2))
-        | filter($1[1] == $1[2])
-        | key($0 ; $1[0]);
-
-    bwd: {
-        let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-        let labels = proposals + nodes | min;
-        var proposals = labels | join(trim_fwd, ($2 ; $1));
-    }
-
-    let trim_bwd = trans
-        | join(bwd::labels, ($1 ; $0, $2))
-        | join(bwd::labels, ($0 ; $1, $2))
-        | filter($1[1] == $1[2])
-        | key($0 ; $1[0]);
-
-    var trim = trim_bwd - edges;
-}
-
-export "result" = outer::scc | map(;) | arrange | inspect(total);
+    export "result" = outer::scc | map(;) | arrange;
diff --git a/interactive/examples/programs/scc_compound.ddp b/interactive/examples/programs/scc_compound.ddp
new file mode 100644
index 000000000..a935a1c53
--- /dev/null
+++ b/interactive/examples/programs/scc_compound.ddp
@@ -0,0 +1,19 @@
+let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0][0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0][0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | arrange;
diff --git a/interactive/examples/programs/scc_plain.ddp b/interactive/examples/programs/scc_plain.ddp
new file mode 100644
index 000000000..1a2d61ae2
--- /dev/null
+++ b/interactive/examples/programs/scc_plain.ddp
@@ -0,0 +1,19 @@
+let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | arrange;
diff --git a/interactive/examples/vec_scc_prof.rs b/interactive/examples/vec_scc_prof.rs
deleted file mode 100644
index e3d68582b..000000000
--- a/interactive/examples/vec_scc_prof.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//! Profiling target: loop DDIR-VEC's SCC at a fixed size for samply — the vec-backend twin of
-//! `corgi_scc_prof`, so the self-time attribution can be compared apples-to-apples.
-//!
-//!   ITERS=200 N=800 samply record -- .../vec_scc_prof
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use interactive::backend::vec;
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-const SCC_SRC: &str = r#"
-    let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | map(;) | arrange;
-"#;
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(SCC_SRC));
-    p.optimize();
-    let nodes: u64 = std::env::var("N").ok().and_then(|s| s.parse().ok()).unwrap_or(800);
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(200);
-    let mut seed = 0xc0ff_ee42u64;
-    let edges: Vec<(Value, Value)> = (0..nodes * 2)
-        .map(|_| (Value::Tuple(vec![Value::Int((xorshift(&mut seed) % nodes) as i64), Value::Int((xorshift(&mut seed) % nodes) as i64)]), Value::unit()))
-        .collect();
-    let inputs = vec![edges];
-    let mut acc = 0usize;
-    for _ in 0..iters {
-        acc += std::hint::black_box(vec::evaluate(&p, &inputs)).len();
-    }
-    eprintln!("done vec scc n={nodes} iters={iters} (acc={acc})");
-}

From d2f321ce3f3ef5f92a40be3177650fbb17bd8a80 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sun, 12 Jul 2026 22:32:38 -0400
Subject: [PATCH 59/68] examples: prune the build-up scaffolding

Eleven milestone/experiment binaries (rungs 0-4, M1-M4, Q3 of the backend
build-up) whose questions are answered and whose coverage the survivors carry:
the gate (corgi_progs) runs reach/scc and richer programs continuously, the
scorecard owns per-operator triage, and ddir_bench owns end-to-end measurement
and profiling. SPIKE.md narrates the arc they documented.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/corgi_backend_linear.rs  | 142 -----------
 interactive/examples/corgi_bench.rs           | 227 -----------------
 interactive/examples/corgi_chain.rs           | 113 ---------
 interactive/examples/corgi_fold.rs            |  73 ------
 interactive/examples/corgi_linear_dataflow.rs | 151 ------------
 interactive/examples/corgi_perf.rs            | 233 ------------------
 interactive/examples/corgi_prof.rs            |  54 ----
 interactive/examples/corgi_program.rs         |  53 ----
 interactive/examples/corgi_reach.rs           |  69 ------
 interactive/examples/corgi_reduce.rs          |  79 ------
 interactive/examples/corgi_smoke.rs           |  23 --
 11 files changed, 1217 deletions(-)
 delete mode 100644 interactive/examples/corgi_backend_linear.rs
 delete mode 100644 interactive/examples/corgi_bench.rs
 delete mode 100644 interactive/examples/corgi_chain.rs
 delete mode 100644 interactive/examples/corgi_fold.rs
 delete mode 100644 interactive/examples/corgi_linear_dataflow.rs
 delete mode 100644 interactive/examples/corgi_perf.rs
 delete mode 100644 interactive/examples/corgi_prof.rs
 delete mode 100644 interactive/examples/corgi_program.rs
 delete mode 100644 interactive/examples/corgi_reach.rs
 delete mode 100644 interactive/examples/corgi_reduce.rs
 delete mode 100644 interactive/examples/corgi_smoke.rs

diff --git a/interactive/examples/corgi_backend_linear.rs b/interactive/examples/corgi_backend_linear.rs
deleted file mode 100644
index b9eefa0f2..000000000
--- a/interactive/examples/corgi_backend_linear.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-//! M1: corgi as DDIR's NATIVE representation inside a real dataflow. Rows enter, are transcoded
-//! to a `CorgiContainer` ONCE (ingest boundary), flow through K corgi-native Linear (Project)
-//! operators — each `eval_graph` over the corgi columns, ZERO inter-operator transcode — and are
-//! read back ONCE (egress boundary). Verified vs the per-row `ir::eval` interpreter; timed.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_backend_linear
-
-use std::collections::BTreeMap;
-use std::time::Instant;
-
-use timely::dataflow::operators::*;
-use timely::dataflow::channels::pact::Pipeline;
-use timely::dataflow::operators::capture::{Capture, Event};
-
-use interactive::corgi_backend::CorgiContainer;
-use interactive::corgi_logic::{compile_projection, infer_shape};
-use interactive::ir::{self, Diff, Value as DValue};
-use interactive::parse::{BinOp, Term};
-
-use corgi::Value as CValue;
-
-type Row = DValue;
-type CC = CorgiContainer<u64, Diff>;
-
-fn main() {
-    // Project: key'=key (Var0 passthrough), val'=(a+b, a*3) over val=(a,b) (Var1). Shape-stable
-    // (val stays a 2-tuple of ints), so it chains K times.
-    let a = || Box::new(Term::Proj(Box::new(Term::Var(1)), 0));
-    let b = || Box::new(Term::Proj(Box::new(Term::Var(1)), 1));
-    let key_term = Term::Var(0);
-    let val_term = Term::Tuple(vec![
-        Term::Binary(BinOp::Add, a(), b()),
-        Term::Binary(BinOp::Mul, a(), Box::new(Term::Int(3))),
-    ]);
-
-    let k = 8usize;
-    let n = 100_000usize;
-    let data: Vec<(Row, Row)> = (0..n)
-        .map(|i| {
-            (
-                DValue::Int((i % 10) as i64),
-                DValue::Tuple(vec![DValue::Int((i % 100) as i64), DValue::Int(((i * 7) % 97) as i64)]),
-            )
-        })
-        .collect();
-
-    // ---- run the corgi-native dataflow ----
-    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
-    let data_in = data.clone();
-    let (kt, vt) = (key_term.clone(), val_term.clone());
-    let t0 = Instant::now();
-    timely::execute_directly(move |worker| {
-        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
-            use differential_dataflow::input::Input;
-            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
-
-            // ingest boundary: rows -> CorgiContainer (transcode once)
-            let mut corgi_stream = coll.inner.unary(Pipeline, "ToCorgi", |_, _| {
-                |input, output| {
-                    input.for_each(|cap, data| {
-                        let mut c = CorgiContainer::from_updates(std::mem::take(data));
-                        output.session(&cap).give_container(&mut c);
-                    });
-                }
-            });
-            // K corgi-native Linear ops — eval_graph over corgi columns, no transcode between them
-            // Shapes are stable across the K iterations (key=Prim, val=Prod[Prim,Prim]).
-            let (kshape, vshape) = (infer_shape(&data_in[0].0), infer_shape(&data_in[0].1));
-            for _ in 0..k {
-                let graph = compile_projection(&kt, &vt, &kshape, &vshape);
-                corgi_stream = corgi_stream.unary(Pipeline, "CorgiProject", move |_, _| {
-                    move |input, output| {
-                        input.for_each(|cap, data| {
-                            let c: CC = std::mem::take(data);
-                            let mut out = if c.times.is_empty() {
-                                c
-                            } else {
-                                let inp = CValue::Prod(vec![c.keys, c.vals]);
-                                let mut cols = corgi::eval_graph(&graph, inp).into_prod("project");
-                                let nv = cols.pop().unwrap();
-                                let nk = cols.pop().unwrap();
-                                CorgiContainer { keys: nk, vals: nv, times: c.times, diffs: c.diffs }
-                            };
-                            output.session(&cap).give_container(&mut out);
-                        });
-                    }
-                });
-            }
-            // egress boundary: CorgiContainer -> rows (transcode once)
-            corgi_stream
-                .unary(Pipeline, "FromCorgi", |_, _| {
-                    |input, output| {
-                        input.for_each(|cap, data| {
-                            let mut updates = std::mem::take(data).into_updates();
-                            output.session(&cap).give_container(&mut updates);
-                        });
-                    }
-                })
-                .capture_into(tx);
-            handle
-        });
-        for r in data_in {
-            handle.update(r, 1);
-        }
-    });
-    let elapsed = t0.elapsed();
-
-    let mut got: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for event in rx {
-        if let Event::Messages(_, d) = event {
-            for ((k, v), _, df) in d {
-                *got.entry((k, v)).or_insert(0) += df;
-            }
-        }
-    }
-    got.retain(|_, d| *d != 0);
-
-    // ---- reference: interpreter, K-chain per row ----
-    let mut want: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for (k0, v0) in &data {
-        let (mut ck, mut cv) = (k0.clone(), v0.clone());
-        for _ in 0..k {
-            let mut env = vec![ck.clone(), cv.clone()];
-            let nk = ir::eval(&key_term, &mut env);
-            let nv = ir::eval(&val_term, &mut env);
-            ck = nk;
-            cv = nv;
-        }
-        *want.entry((ck, cv)).or_insert(0) += 1;
-    }
-    want.retain(|_, d| *d != 0);
-
-    assert_eq!(got, want, "corgi-native dataflow output != interpreter reference");
-
-    println!("M1: corgi-native Linear chain inside a real DD dataflow");
-    println!("  K (chained Project ops): {k}");
-    println!("  input rows:              {n}");
-    println!("  output rows:             {}", got.len());
-    println!("  matches interpreter:     YES");
-    println!("  transcodes:              2 (ingest + egress) — ZERO between the {k} operators");
-    println!("  wall-clock:              {elapsed:?}");
-}
diff --git a/interactive/examples/corgi_bench.rs b/interactive/examples/corgi_bench.rs
deleted file mode 100644
index 86b8e7adf..000000000
--- a/interactive/examples/corgi_bench.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-//! Rung 1: compile a DDIR scalar `Term` to a corgi `Graph<NumOp>`, run it columnar, and
-//! measure it against DDIR's per-row `ir::eval` interpreter — sweeping column width to find
-//! the crossover. Also measures the AoS->SoA transcode tax (open question: does it dominate?).
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_bench
-//!
-//! Subset supported in this rung: the map/filter core over non-negative ints —
-//! Var/Proj/Int/Tuple/Binary(arith,cmp,logical)/If. Variant/List/Fold/Hash are later rungs.
-
-use std::time::Instant;
-
-use interactive::ir::{self, Value as DValue};
-use interactive::parse::{BinOp, Term};
-
-use corgi::{ArithOp, BinOp as CBinOp, Builder, CmpOp, Kind, NumOp, Op, Pred, Shape, Value as CValue};
-
-// ---------- shape inference (the dynamic-typing primitive: observe data -> Shape) ----------
-
-fn infer_shape(sample: &DValue) -> Shape {
-    match sample {
-        DValue::Int(_) => Shape::Prim(64),
-        DValue::Tuple(xs) => Shape::Prod(xs.iter().map(infer_shape).collect()),
-        DValue::List(xs) => Shape::List(Box::new(infer_shape(xs.first().expect("nonempty list")))),
-        DValue::Variant(..) => panic!("variant shape inference is a later rung"),
-    }
-}
-
-// ---------- AoS rows -> SoA corgi columns, directed by the inferred shape ----------
-
-fn transcode(rows: &[DValue], shape: &Shape) -> CValue {
-    match shape {
-        Shape::Prim(_) => CValue::u64(rows.iter().map(|r| r.as_int() as u64).collect()),
-        Shape::Prod(field_shapes) => {
-            let cols = field_shapes
-                .iter()
-                .enumerate()
-                .map(|(i, fs)| {
-                    let sub: Vec<DValue> = rows
-                        .iter()
-                        .map(|r| match r {
-                            DValue::Tuple(xs) => xs[i].clone(),
-                            other => panic!("transcode: expected Tuple, got {other:?}"),
-                        })
-                        .collect();
-                    transcode(&sub, fs)
-                })
-                .collect();
-            CValue::Prod(cols)
-        }
-        other => panic!("transcode: shape not supported in this rung: {other:?}"),
-    }
-}
-
-// ---------- the compiler: Term -> corgi node (flat, columnar) ----------
-// `env[i]` is the node for `Var(i)`; binders (none yet in this subset) would push on top.
-// `anchor` is any node used to broadcast `Lit` to the column length.
-
-fn compile(term: &Term, b: &mut Builder<NumOp>, env: &[usize], anchor: usize) -> usize {
-    match term {
-        Term::Var(i) => env[*i],
-        Term::Bound(k) => env[env.len() - 1 - *k],
-        Term::Int(n) => b.add(Op::Lit(CValue::u64(vec![*n as u64])), vec![anchor]),
-        Term::Tuple(fields) => {
-            let ids: Vec<usize> = fields.iter().map(|f| compile(f, b, env, anchor)).collect();
-            b.tuple(ids)
-        }
-        Term::Proj(t, i) => {
-            let id = compile(t, b, env, anchor);
-            b.add(Op::Field(*i), vec![id])
-        }
-        Term::Binary(op, l, r) => {
-            let lid = compile(l, b, env, anchor);
-            let rid = compile(r, b, env, anchor);
-            let pair = |b: &mut Builder<NumOp>, x, y| b.tuple(vec![x, y]);
-            match op {
-                BinOp::Add => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Add, Kind::U, 64), vec![p]) }
-                BinOp::Sub => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Sub, Kind::U, 64), vec![p]) }
-                BinOp::Mul => { let p = pair(b, lid, rid); b.add(ArithOp::Bin(CBinOp::Mul, Kind::U, 64), vec![p]) }
-                BinOp::Eq => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Eq), vec![p]) }
-                BinOp::Ne => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Ne), vec![p]) }
-                BinOp::Lt => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Lt), vec![p]) }
-                BinOp::Le => { let p = pair(b, lid, rid); b.add(CmpOp::Rel(Pred::Le), vec![p]) }
-                BinOp::Gt => { let p = pair(b, rid, lid); b.add(CmpOp::Rel(Pred::Lt), vec![p]) } // a>b == b<a
-                BinOp::Ge => { let p = pair(b, rid, lid); b.add(CmpOp::Rel(Pred::Le), vec![p]) } // a>=b == b<=a
-                BinOp::And => { let p = pair(b, lid, rid); b.add(CmpOp::Min, vec![p]) } // 0/1 masks
-                BinOp::Or => { let p = pair(b, lid, rid); b.add(CmpOp::Max, vec![p]) }
-            }
-        }
-        Term::If { cond, then, els } => {
-            let c = compile(cond, b, env, anchor);
-            let t = compile(then, b, env, anchor);
-            let e = compile(els, b, env, anchor);
-            let sel = b.tuple(vec![c, t, e]);
-            b.add(Op::Select, vec![sel])
-        }
-        other => panic!("compile: unsupported Term in this rung: {other:?}"),
-    }
-}
-
-/// Build the full graph for `term`. `Var(0)` = the whole input row. The graph is
-/// shape-independent in this subset (corgi resolves layout at eval); shape drives transcode.
-fn build_graph(term: &Term) -> corgi::Graph<NumOp> {
-    let mut b = Builder::<NumOp>::default();
-    let input = b.input();
-    let env = vec![input]; // Var(0) is the input column
-    let out = compile(term, &mut b, &env, input);
-    b.finish(out)
-}
-
-// ---------- timing ----------
-
-fn bench<F: FnMut()>(n: usize, mut f: F) -> f64 {
-    let reps = (4_000_000 / n.max(1)).max(5);
-    f(); // warmup
-    let t = Instant::now();
-    for _ in 0..reps {
-        f();
-    }
-    t.elapsed().as_secs_f64() / reps as f64 // seconds per call
-}
-
-fn per_row_ns(secs_per_call: f64, n: usize) -> f64 {
-    secs_per_call * 1e9 / n as f64
-}
-
-fn main() {
-    // Two representative scalar programs over rows of shape Tuple([a, b]) (Var(0) = the row):
-    let a = || Box::new(Term::Proj(Box::new(Term::Var(0)), 0));
-    let bb = || Box::new(Term::Proj(Box::new(Term::Var(0)), 1));
-
-    // MAP:    (a + b, a * 3)
-    let term_map = Term::Tuple(vec![
-        Term::Binary(BinOp::Add, a(), bb()),
-        Term::Binary(BinOp::Mul, a(), Box::new(Term::Int(3))),
-    ]);
-    // FILTER: a < b   (produces the 0/1 keep-mask)
-    let term_filter = Term::Binary(BinOp::Lt, a(), bb());
-
-    for (name, term) in [("map (a+b, a*3)", &term_map), ("filter a<b", &term_filter)] {
-        println!("\n=== {name} ===");
-        println!(
-            "{:>10} {:>12} {:>12} {:>12} {:>10} {:>10}",
-            "rows", "interp ns/r", "corgi ns/r", "+xcode ns/r", "speedup", "w/xcode"
-        );
-        let g = build_graph(term);
-
-        for &n in &[1usize, 10, 100, 1_000, 10_000, 100_000, 1_000_000] {
-            let rows: Vec<DValue> = (0..n)
-                .map(|i| DValue::Tuple(vec![DValue::Int((i % 1000) as i64), DValue::Int(((i * 7) % 997) as i64)]))
-                .collect();
-            let shape = infer_shape(&rows[0]); // dynamic typing: form the corgi Shape from the data
-
-            // baseline: per-row interpreter
-            let interp = bench(n, || {
-                let mut out = Vec::with_capacity(n);
-                for r in &rows {
-                    let mut env = vec![r.clone()];
-                    out.push(ir::eval(term, &mut env));
-                }
-                std::hint::black_box(&out);
-            });
-
-            // corgi eval only (input pre-transcoded; clone = cheap Arc bumps)
-            let input = transcode(&rows, &shape);
-            let corgi_eval = bench(n, || {
-                let out = corgi::eval_graph(&g, input.clone());
-                std::hint::black_box(&out);
-            });
-
-            // corgi total: transcode each call + eval (the rung-1 tax)
-            let corgi_total = bench(n, || {
-                let inp = transcode(&rows, &shape);
-                let out = corgi::eval_graph(&g, inp);
-                std::hint::black_box(&out);
-            });
-
-            println!(
-                "{:>10} {:>12.1} {:>12.1} {:>12.1} {:>9.2}x {:>9.2}x",
-                n,
-                per_row_ns(interp, n),
-                per_row_ns(corgi_eval, n),
-                per_row_ns(corgi_total, n),
-                interp / corgi_eval,
-                interp / corgi_total,
-            );
-        }
-    }
-
-    // correctness: corgi == interpreter on a mid-size column
-    check_correctness(&term_map, true);
-    check_correctness(&term_filter, false);
-    println!("\ncorrectness: OK");
-}
-
-fn check_correctness(term: &Term, is_map: bool) {
-    let n = 1000;
-    let rows: Vec<DValue> = (0..n)
-        .map(|i| DValue::Tuple(vec![DValue::Int((i % 1000) as i64), DValue::Int(((i * 7) % 997) as i64)]))
-        .collect();
-    let shape = infer_shape(&rows[0]);
-    let g = build_graph(term);
-    let out = corgi::eval_graph(&g, transcode(&rows, &shape));
-
-    let base: Vec<DValue> = rows
-        .iter()
-        .map(|r| {
-            let mut env = vec![r.clone()];
-            ir::eval(term, &mut env)
-        })
-        .collect();
-
-    if is_map {
-        let cols = out.into_prod("map result");
-        let c0 = cols[0].clone().into_u64("col0");
-        let c1 = cols[1].clone().into_u64("col1");
-        for (i, bv) in base.iter().enumerate() {
-            let DValue::Tuple(xs) = bv else { panic!("expected tuple") };
-            assert_eq!(c0[i], xs[0].as_int() as u64, "map col0 row {i}");
-            assert_eq!(c1[i], xs[1].as_int() as u64, "map col1 row {i}");
-        }
-    } else {
-        let mask = out.into_u64("filter mask");
-        for (i, bv) in base.iter().enumerate() {
-            assert_eq!(mask[i], bv.as_int() as u64, "filter row {i}");
-        }
-    }
-}
diff --git a/interactive/examples/corgi_chain.rs b/interactive/examples/corgi_chain.rs
deleted file mode 100644
index 01ffb8862..000000000
--- a/interactive/examples/corgi_chain.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! Rung 4 (measurement): how corgi-columnar *storage* amortizes the dominant transcode.
-//! A chain of K Linear map ops, three ways:
-//!   - interp:   per-row `ir::eval`, K ops per row.
-//!   - per-op:   corgi, but transcode rows<->corgi at every op boundary (the rung-2 "floor":
-//!               what you pay if each operator hands off row-major data).
-//!   - columnar: corgi, transcode IN once, eval x K staying in corgi columns, transcode OUT once
-//!               (the rung-4 model: data lives corgi-columnar between ops).
-//! Shows per-op cost ~ K*(2*xcode + eval) vs columnar ~ 2*xcode + K*eval → columnar approaches
-//! the eval-only ceiling as K grows. Quantifies the payoff of a corgi-data CHUNK/container.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_chain
-
-use std::time::Instant;
-
-use interactive::corgi_logic::{compile_term_single, infer_shape, transcode, untranscode};
-use interactive::ir::{self, Value as DValue};
-use interactive::parse::{BinOp, Term};
-
-fn op_term(c: i64) -> Term {
-    Term::Binary(BinOp::Add, Box::new(Term::Var(0)), Box::new(Term::Int(c)))
-}
-
-fn bench<F: FnMut()>(n: usize, mut f: F) -> f64 {
-    let reps = (2_000_000 / n.max(1)).max(5);
-    f();
-    let t = Instant::now();
-    for _ in 0..reps {
-        f();
-    }
-    t.elapsed().as_secs_f64() / reps as f64
-}
-
-fn main() {
-    let n = 100_000usize;
-    let consts: Vec<i64> = (1..=16).map(|i| i * 3).collect();
-
-    println!("chain of K Linear ops (x -> x+c), n = {n} rows; ns/row totals over the whole chain");
-    println!("{:>4} {:>12} {:>12} {:>12} {:>12} {:>12}", "K", "interp", "per-op", "columnar", "col vs interp", "col vs perop");
-
-    for &k in &[1usize, 2, 4, 8, 16] {
-        let terms: Vec<Term> = consts[..k].iter().map(|&c| op_term(c)).collect();
-        let graphs: Vec<_> = terms.iter().map(compile_term_single).collect();
-
-        let rows: Vec<DValue> = (0..n).map(|i| DValue::Int((i % 1000) as i64)).collect();
-        let shape = infer_shape(&rows[0]);
-
-        // interp: per-row, K ops.
-        let interp = bench(n, || {
-            let mut out = Vec::with_capacity(n);
-            for r in &rows {
-                let mut v = r.clone();
-                for t in &terms {
-                    let mut env = vec![v];
-                    v = ir::eval(t, &mut env);
-                }
-                out.push(v);
-            }
-            std::hint::black_box(&out);
-        });
-
-        // per-op: transcode round-trip at every op boundary.
-        let per_op = bench(n, || {
-            let mut cur = rows.clone();
-            for g in &graphs {
-                let col = transcode(&cur, &shape);
-                let out = corgi::eval_graph(g, col);
-                cur = untranscode(out, &shape);
-            }
-            std::hint::black_box(&cur);
-        });
-
-        // columnar: transcode once, stay in corgi columns across all K ops, transcode out once.
-        let columnar = bench(n, || {
-            let mut col = transcode(&rows, &shape);
-            for g in &graphs {
-                col = corgi::eval_graph(g, col);
-            }
-            let out = untranscode(col, &shape);
-            std::hint::black_box(&out);
-        });
-
-        let nsr = |s: f64| s * 1e9 / n as f64;
-        println!(
-            "{:>4} {:>12.1} {:>12.1} {:>12.1} {:>11.1}x {:>11.1}x",
-            k,
-            nsr(interp),
-            nsr(per_op),
-            nsr(columnar),
-            interp / columnar,
-            per_op / columnar,
-        );
-    }
-
-    // correctness: all three agree at K=8.
-    {
-        let k = 8;
-        let terms: Vec<Term> = consts[..k].iter().map(|&c| op_term(c)).collect();
-        let graphs: Vec<_> = terms.iter().map(compile_term_single).collect();
-        let rows: Vec<DValue> = (0..1000).map(|i| DValue::Int(i)).collect();
-        let shape = infer_shape(&rows[0]);
-        let bump: i64 = consts[..k].iter().sum();
-
-        let mut col = transcode(&rows, &shape);
-        for g in &graphs {
-            col = corgi::eval_graph(g, col);
-        }
-        let got = untranscode(col, &shape);
-        for (i, v) in got.iter().enumerate() {
-            assert_eq!(v.as_int(), i as i64 + bump, "chain row {i}");
-        }
-        println!("\ncorrectness (K=8 chain): OK");
-    }
-}
diff --git a/interactive/examples/corgi_fold.rs b/interactive/examples/corgi_fold.rs
deleted file mode 100644
index 329245515..000000000
--- a/interactive/examples/corgi_fold.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Q3: corgi covers beyond map/filter — a List + Fold (per-row aggregation), the construct
-//! datalog/eqsat lean on (Collect/Count/nested data). Rows are List<Int>; the Term folds each
-//! row's list (acc+elem). Validates corgi vs `ir::eval` and measures the columnar speedup.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_fold
-
-use std::time::Instant;
-
-use interactive::corgi_logic::{compile_term_single, infer_shape, transcode, untranscode};
-use interactive::ir::{self, Value as DValue};
-use interactive::parse::{BinOp, Term};
-
-fn bench<F: FnMut()>(n: usize, mut f: F) -> f64 {
-    let reps = (2_000_000 / n.max(1)).max(5);
-    f();
-    let t = Instant::now();
-    for _ in 0..reps {
-        f();
-    }
-    t.elapsed().as_secs_f64() / reps as f64
-}
-
-fn main() {
-    // Fold over Var(0) (the row, a List<Int>): seed 0, step = acc + elem.
-    // DDIR Fold binders: elem=Bound(0), acc=Bound(1).
-    let step = Term::Binary(BinOp::Add, Box::new(Term::Bound(1)), Box::new(Term::Bound(0)));
-    let term = Term::Fold {
-        list: Box::new(Term::Var(0)),
-        init: Box::new(Term::Int(0)),
-        step: Box::new(step),
-    };
-    let g = compile_term_single(&term);
-
-    // Rows: lists of length 1..=20 of small ints.
-    let n = 100_000usize;
-    let rows: Vec<DValue> = (0..n)
-        .map(|i| {
-            let len = 1 + (i % 20);
-            DValue::List((0..len).map(|j| DValue::Int(((i + j) % 50) as i64)).collect())
-        })
-        .collect();
-    let shape = infer_shape(&rows[0]); // List(Prim(64))
-
-    // correctness vs interpreter
-    let input = transcode(&rows, &shape);
-    let out = untranscode(corgi::eval_graph(&g, input), &corgi::Shape::Prim(64));
-    for (i, r) in rows.iter().enumerate() {
-        let mut env = vec![r.clone()];
-        let want = ir::eval(&term, &mut env).as_int();
-        assert_eq!(out[i].as_int(), want, "fold row {i}");
-    }
-    println!("Q3: List + Fold (per-row aggregation)");
-    println!("  correctness vs ir::eval: OK ({n} rows, list len 1..=20)");
-
-    // throughput
-    let interp = bench(n, || {
-        let mut acc = Vec::with_capacity(n);
-        for r in &rows {
-            let mut env = vec![r.clone()];
-            acc.push(ir::eval(&term, &mut env));
-        }
-        std::hint::black_box(&acc);
-    });
-    let pre = transcode(&rows, &shape);
-    let corgi_eval = bench(n, || {
-        std::hint::black_box(corgi::eval_graph(&g, pre.clone()));
-    });
-    let total_elems: usize = rows.iter().map(|r| if let DValue::List(xs) = r { xs.len() } else { 0 }).sum();
-    println!("  total elements folded: {total_elems}");
-    println!("  interp:     {:>7.1} ns/row", interp * 1e9 / n as f64);
-    println!("  corgi eval: {:>7.1} ns/row   ({:.1}x)", corgi_eval * 1e9 / n as f64, interp / corgi_eval);
-    println!("\ncorgi covers List/Fold — the aggregation/nested-data path beyond map/filter.");
-}
diff --git a/interactive/examples/corgi_linear_dataflow.rs b/interactive/examples/corgi_linear_dataflow.rs
deleted file mode 100644
index e34629c9f..000000000
--- a/interactive/examples/corgi_linear_dataflow.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-//! Rung 2: corgi as the scalar logic of a DDIR **Linear** map, running inside a real
-//! differential-dataflow computation. A container-level unary operator transcodes each
-//! update batch to corgi columns, runs the compiled `Graph` over the whole batch at once,
-//! and transcodes back — preserving (time, diff) per row. Verified against the per-row
-//! `ir::eval` interpreter, including retractions (incremental soundness).
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_linear_dataflow
-
-use std::collections::BTreeMap;
-use std::time::Instant;
-
-use interactive::corgi_logic::{compile_projection, infer_shape, transcode, untranscode};
-use interactive::ir::{self, Diff, Value as DValue};
-use interactive::parse::{BinOp, Term};
-
-use corgi::{Graph, NumOp, Shape, Value as CValue};
-
-type Row = DValue;
-
-/// Apply the compiled projection `graph` to a whole update batch, columnar, via corgi.
-/// (time, diff) pass through untouched; only (key, val) are transformed.
-fn corgi_apply(graph: &Graph<NumOp>, batch: Vec<((Row, Row), u64, Diff)>) -> Vec<((Row, Row), u64, Diff)> {
-    if batch.is_empty() {
-        return batch;
-    }
-    let kshape = infer_shape(&batch[0].0 .0);
-    let vshape = infer_shape(&batch[0].0 .1);
-    let in_shape = Shape::Prod(vec![kshape.clone(), vshape.clone()]);
-
-    let keys: Vec<DValue> = batch.iter().map(|x| x.0 .0.clone()).collect();
-    let vals: Vec<DValue> = batch.iter().map(|x| x.0 .1.clone()).collect();
-    let input = CValue::Prod(vec![transcode(&keys, &kshape), transcode(&vals, &vshape)]);
-
-    let out = corgi::eval_graph(graph, input);
-    let out_shape = corgi::shape_of(graph, &in_shape).expect("shape_of");
-    let Shape::Prod(out_fs) = &out_shape else { panic!("expected Prod output shape") };
-    let mut cols = out.into_prod("out");
-    let newvals = untranscode(cols.pop().unwrap(), &out_fs[1]);
-    let newkeys = untranscode(cols.pop().unwrap(), &out_fs[0]);
-
-    batch
-        .into_iter()
-        .enumerate()
-        .map(|(i, ((_, _), t, d))| ((newkeys[i].clone(), newvals[i].clone()), t, d))
-        .collect()
-}
-
-/// Run the corgi-Linear dataflow on `data` (rows with diffs), return consolidated output.
-fn run_corgi_dataflow(graph: Graph<NumOp>, data: Vec<((Row, Row), Diff)>) -> BTreeMap<(Row, Row), Diff> {
-    use std::sync::mpsc::channel;
-    use timely::dataflow::operators::*;
-    use timely::dataflow::channels::pact::Pipeline;
-    use timely::dataflow::operators::capture::{Capture, Event};
-    use differential_dataflow::AsCollection;
-    use differential_dataflow::input::Input;
-
-    let (tx, rx) = channel::<Event<u64, Vec<((Row, Row), u64, Diff)>>>();
-    timely::execute_directly(move |worker| {
-        let mut handle = worker.dataflow::<u64, _, _>(|scope| {
-            let (handle, coll) = scope.new_collection::<(Row, Row), Diff>();
-            let graph = graph.clone();
-            coll.inner
-                .unary(Pipeline, "CorgiLinear", move |_, _| {
-                    move |input, output| {
-                        input.for_each(|time, data| {
-                            let mut result = corgi_apply(&graph, std::mem::take(data));
-                            output.session(&time).give_container(&mut result);
-                        });
-                    }
-                })
-                .as_collection()
-                .inner
-                .capture_into(tx);
-            handle
-        });
-        for (row, diff) in data {
-            handle.update(row, diff);
-        }
-    });
-
-    let mut acc: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for event in rx {
-        if let Event::Messages(_, data) = event {
-            for ((k, v), _, d) in data {
-                *acc.entry((k, v)).or_insert(0) += d;
-            }
-        }
-    }
-    acc.retain(|_, d| *d != 0);
-    acc
-}
-
-/// Reference: the same projection via the per-row `ir::eval` interpreter.
-fn reference(key: &Term, val: &Term, data: &[((Row, Row), Diff)]) -> BTreeMap<(Row, Row), Diff> {
-    let mut acc: BTreeMap<(Row, Row), Diff> = BTreeMap::new();
-    for ((k, v), d) in data {
-        let mut env = vec![k.clone(), v.clone()];
-        let nk = ir::eval(key, &mut env);
-        let nv = ir::eval(val, &mut env);
-        *acc.entry((nk, nv)).or_insert(0) += d;
-    }
-    acc.retain(|_, d| *d != 0);
-    acc
-}
-
-fn main() {
-    // Projection: keep the key; reval val=[a,b] -> (a+b, a*3).  Var(0)=key, Var(1)=val.
-    let a = || Box::new(Term::Proj(Box::new(Term::Var(1)), 0));
-    let b = || Box::new(Term::Proj(Box::new(Term::Var(1)), 1));
-    let key = Term::Var(0);
-    let val = Term::Tuple(vec![
-        Term::Binary(BinOp::Add, a(), b()),
-        Term::Binary(BinOp::Mul, a(), Box::new(Term::Int(3))),
-    ]);
-
-    // Input shapes: key=Int (Prim), val=(Int,Int) (Prod[Prim,Prim]).
-    let kshape = infer_shape(&DValue::Int(0));
-    let vshape = infer_shape(&DValue::Tuple(vec![DValue::Int(0), DValue::Int(0)]));
-    let graph = compile_projection(&key, &val, &kshape, &vshape);
-
-    // Data with mixed diffs INCLUDING retractions (net-zero rows must vanish from both).
-    let n = 20_000usize;
-    let data: Vec<((Row, Row), Diff)> = (0..n)
-        .flat_map(|i| {
-            let row = (
-                DValue::Int((i % 10) as i64),
-                DValue::Tuple(vec![DValue::Int((i % 100) as i64), DValue::Int(((i * 7) % 97) as i64)]),
-            );
-            match i % 3 {
-                0 => vec![(row.clone(), 1), (row, -1)], // net zero -> must disappear
-                1 => vec![(row, 2)],
-                _ => vec![(row, 1)],
-            }
-        })
-        .collect();
-
-    let t0 = Instant::now();
-    let got = run_corgi_dataflow(graph, data.clone());
-    let elapsed = t0.elapsed();
-    let want = reference(&key, &val, &data);
-
-    assert_eq!(got.len(), want.len(), "output cardinality mismatch");
-    assert_eq!(got, want, "corgi-Linear dataflow output != interpreter reference");
-
-    println!("rung 2: corgi-Linear inside a real DD dataflow");
-    println!("  input updates (with retractions): {}", data.len());
-    println!("  output rows (consolidated):       {}", got.len());
-    println!("  matches interpreter reference:    YES (incl. net-zero retractions vanished)");
-    println!("  dataflow wall-clock:              {:?}", elapsed);
-    println!("\nINTEGRATION SOUND: corgi runs as DDIR's columnar Linear logic; (time,diff) preserved.");
-}
diff --git a/interactive/examples/corgi_perf.rs b/interactive/examples/corgi_perf.rs
deleted file mode 100644
index 81c83d47c..000000000
--- a/interactive/examples/corgi_perf.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-//! End-to-end performance: the corgi backend vs the vec backend on whole DDIR programs (NOT the
-//! Phase-1 eval-only microbench). Measures the real thing this work produced — `corgi::evaluate`
-//! vs `vec::evaluate` — across two shapes of program:
-//!   1. LINEAR-HEAVY: a long chain of compilable Project/Filter ops over wide rows — corgi's
-//!      columnar strength (eval stays in columns; transcode only at the arrange boundary).
-//!   2. REACH: recursive reachability — join + distinct + concat + leave_dynamic; narrow rows,
-//!      per-key value slices where the columnar win doesn't apply and row-wise fallbacks + the
-//!      (eager, unoptimized) CorgiBatch merge dominate.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_perf
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-use differential_dataflow::algorithms::graphs::scc::strongly_connected;
-use differential_dataflow::input::Input;
-use timely::dataflow::operators::probe::Handle;
-
-/// One from-scratch run of the HAND-WRITTEN native DD `strongly_connected` on a static graph — the
-/// "SCC in Rust" reference to compare the DDIR-interpreted SCC against. Same shape as `evaluate`:
-/// a full single-worker `execute_directly` (setup + load at t0 + run to fixpoint).
-fn native_scc_once(edges: &[(usize, usize)]) {
-    let edges = edges.to_vec();
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
-            strongly_connected(graph).probe_with(&mut probe);
-            input
-        });
-        for &(s, d) in &edges {
-            input.insert((s, d));
-        }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) {
-            worker.step();
-        }
-    });
-}
-
-type Row = Value;
-
-fn tup(fields: &[i64]) -> Row {
-    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
-}
-
-/// Median wall-clock of `iters` runs of `f` (min 3), after one warmup.
-fn bench<F: FnMut()>(iters: usize, mut f: F) -> Duration {
-    f(); // warmup
-    let mut ts: Vec<Duration> = (0..iters.max(3))
-        .map(|_| {
-            let t = Instant::now();
-            f();
-            t.elapsed()
-        })
-        .collect();
-    ts.sort();
-    ts[ts.len() / 2]
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-fn compile(src: &str) -> interactive::scope_ir::Program {
-    let mut p = lower::lower_tree(parse::pipe::parse(src));
-    p.optimize();
-    p
-}
-
-fn report(name: &str, n: usize, vec_t: Duration, corgi_t: Duration) {
-    let ratio = corgi_t.as_secs_f64() / vec_t.as_secs_f64();
-    let faster = if ratio < 1.0 {
-        format!("corgi {:.2}x FASTER", 1.0 / ratio)
-    } else {
-        format!("corgi {ratio:.2}x slower")
-    };
-    println!("  {name:<22} n={n:<7}  vec {vec_t:>10.2?}   corgi {corgi_t:>10.2?}   → {faster}");
-}
-
-fn main() {
-    // ---------- 1. LINEAR-HEAVY (corgi's columnar strength) ----------
-    // Wide 6-field value; a chain of arithmetic Project maps + a filter, then arrange. All ops are
-    // corgi-compilable, so eval stays columnar; only the final arrange transcodes.
-    // Flat comma-separated projection fields (the pipe `(K ; V1, V2, ...)` already tuples the list;
-    // a `tuple(...)` field would NEST, so we list fields directly for a flat 6-wide value).
-    let linear_src = r#"
-        let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5], $0[0]);
-        let b = a | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);
-        let c = b | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);
-        let d = c | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);
-        let e = d | filter($1[0] != 999999);
-        export "result" = e | arrange;
-    "#;
-    let linear = compile(linear_src);
-
-    println!("1. LINEAR-HEAVY (3 wide arithmetic maps + filter + arrange; corgi columnar path):");
-    for &n in &[2_000usize, 20_000, 100_000] {
-        let mut seed = 0x1234_5678u64;
-        let input: Vec<(Row, Row)> = (0..n)
-            .map(|i| (tup(&[i as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64,
-                             (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64]),
-                      Value::unit()))
-            .collect();
-        let inputs = vec![input];
-        // sanity: identical output
-        assert_eq!(corgi::evaluate(&linear, &inputs), vec::evaluate(&linear, &inputs));
-        let vt = bench(5, || { std::hint::black_box(vec::evaluate(&linear, &inputs)); });
-        let ct = bench(5, || { std::hint::black_box(corgi::evaluate(&linear, &inputs)); });
-        report("linear-heavy", n, vt, ct);
-    }
-
-    // ---------- 2. REACH (recursive; join + distinct heavy, narrow rows) ----------
-    let reach = compile(r#"
-        let edges = input 0 | key($0[0] ; $0[1]);
-        let roots = input 1 | key($0[0] ;);
-        reach: {
-            let proposals = reach | join(edges, ($2 ;));
-            var reach = roots + proposals | distinct;
-        }
-        export "result" = reach::reach | arrange;
-    "#);
-
-    println!("\n2. REACH (recursive: join + distinct + concat + leave_dynamic; narrow rows):");
-    for &nodes in &[200usize, 1_000, 4_000] {
-        let mut seed = 0x9e37_79b9u64;
-        let n_edges = nodes * 3;
-        let edges: Vec<(Row, Row)> = (0..n_edges)
-            .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
-            .collect();
-        let roots = vec![(tup(&[0]), Value::unit())];
-        let inputs = vec![edges, roots];
-        assert_eq!(corgi::evaluate(&reach, &inputs), vec::evaluate(&reach, &inputs));
-        let vt = bench(3, || { std::hint::black_box(vec::evaluate(&reach, &inputs)); });
-        let ct = bench(3, || { std::hint::black_box(corgi::evaluate(&reach, &inputs)); });
-        report("reach", nodes, vt, ct);
-    }
-
-    // ---------- 2b. SCC (nested recursion: fwd/bwd label propagation via `min`) ----------
-    let scc = compile(r#"
-        let edges = input 0 | key($0[0] ; $0[1]);
-        let trans = edges | key($1 ; $0);
-        outer: {
-            let scc = edges + trim;
-            fwd: {
-                let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-                let labels = proposals + nodes | min;
-                var proposals = labels | join(scc, ($2 ; $1));
-            }
-            let trim_fwd = edges
-                | join(fwd::labels, ($1 ; $0, $2))
-                | join(fwd::labels, ($0 ; $1, $2))
-                | filter($1[1] == $1[2])
-                | key($0 ; $1[0]);
-            bwd: {
-                let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-                let labels = proposals + nodes | min;
-                var proposals = labels | join(trim_fwd, ($2 ; $1));
-            }
-            let trim_bwd = trans
-                | join(bwd::labels, ($1 ; $0, $2))
-                | join(bwd::labels, ($0 ; $1, $2))
-                | filter($1[1] == $1[2])
-                | key($0 ; $1[0]);
-            var trim = trim_bwd - edges;
-        }
-        export "result" = outer::scc | map(;) | arrange;
-    "#);
-
-    println!("\n2b. SCC — hand-written native DD vs DDIR-vec vs DDIR-corgi (the whole point of the exercise):");
-    for &nodes in &[200usize, 500, 800, 1_000] {
-        let n_edges = nodes * 2;
-        // Same random graph fed to all three (identical xorshift seed → identical edge sequence).
-        let mut seed = 0xc0ff_ee42u64;
-        let edges: Vec<(Row, Row)> = (0..n_edges)
-            .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
-            .collect();
-        let mut seed2 = 0xc0ff_ee42u64;
-        let native_edges: Vec<(usize, usize)> = (0..n_edges)
-            .map(|_| ((xorshift(&mut seed2) % nodes as u64) as usize, (xorshift(&mut seed2) % nodes as u64) as usize))
-            .collect();
-        let inputs = vec![edges];
-        // SCC is now correct in corgi — pin it.
-        assert_eq!(corgi::evaluate(&scc, &inputs), vec::evaluate(&scc, &inputs), "corgi != vec scc at n={nodes}");
-        let nt = bench(3, || native_scc_once(&native_edges));
-        let vt = bench(3, || { std::hint::black_box(vec::evaluate(&scc, &inputs)); });
-        let ct = bench(3, || { std::hint::black_box(corgi::evaluate(&scc, &inputs)); });
-        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  scc n={nodes:<5}  native {nt:>9.2?}   vec-DDIR {vt:>9.2?} ({:.1}x native)   corgi-DDIR {ct:>9.2?} ({:.1}x native, {:.2}x vec)",
-            vf / nf, cf / nf, cf / vf,
-        );
-    }
-
-    // ---------- 3. LINEAR COMPUTE ONLY (deep chain, NO arrange) — isolates the columnar eval ----------
-    // 8 wide arithmetic maps, exported without arrange (only ToCorgi in / FromCorgi out transcode
-    // bracket the columnar chain). This is where corgi's columnar scalar logic should actually pay.
-    let mut deep = String::from("let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5], $0[0]);\n");
-    let mut prev = 'a';
-    for i in 0..8 {
-        let cur = (b'b' + i) as char;
-        deep.push_str(&format!(
-            "let {cur} = {prev} | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);\n"
-        ));
-        prev = cur;
-    }
-    deep.push_str(&format!("export \"result\" = {prev};\n"));
-    let deep = compile(&deep);
-
-    println!("\n3. LINEAR COMPUTE ONLY (8 wide maps, NO arrange — isolates the columnar eval):");
-    for &n in &[20_000usize, 100_000] {
-        let mut seed = 0xdead_beefu64;
-        let input: Vec<(Row, Row)> = (0..n)
-            .map(|i| (tup(&[i as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64,
-                             (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64, (xorshift(&mut seed) % 1000) as i64]),
-                      Value::unit()))
-            .collect();
-        let inputs = vec![input];
-        assert_eq!(corgi::evaluate(&deep, &inputs), vec::evaluate(&deep, &inputs));
-        let vt = bench(5, || { std::hint::black_box(vec::evaluate(&deep, &inputs)); });
-        let ct = bench(5, || { std::hint::black_box(corgi::evaluate(&deep, &inputs)); });
-        report("linear-compute-8x", n, vt, ct);
-    }
-
-    println!("\n(Wall-clock includes a fixed timely single-worker setup per `evaluate` call, equal for both.)");
-}
diff --git a/interactive/examples/corgi_prof.rs b/interactive/examples/corgi_prof.rs
deleted file mode 100644
index 86820d475..000000000
--- a/interactive/examples/corgi_prof.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! Reach-only profiling harness: runs the corgi backend on recursive reachability in a tight loop so
-//! a sampling profiler (samply) isolates the recursive join+distinct hot path.
-//!
-//!   ~/.cargo/bin/samply record --save-only -o /tmp/reach.json.gz -- \
-//!       ~/.cargo/bin/cargo run --release -p interactive --example corgi_prof
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-fn tup(fields: &[i64]) -> Value {
-    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-fn main() {
-    let mut p = lower::lower_tree(parse::pipe::parse(
-        r#"
-        let edges = input 0 | key($0[0] ; $0[1]);
-        let roots = input 1 | key($0[0] ;);
-        reach: {
-            let proposals = reach | join(edges, ($2 ;));
-            var reach = roots + proposals | distinct;
-        }
-        export "result" = reach::reach | arrange;
-    "#,
-    ));
-    p.optimize();
-
-    let nodes = 4_000usize;
-    let mut seed = 0x9e37_79b9u64;
-    let n_edges = nodes * 3;
-    let edges: Vec<(Value, Value)> = (0..n_edges)
-        .map(|_| (tup(&[(xorshift(&mut seed) % nodes as u64) as i64, (xorshift(&mut seed) % nodes as u64) as i64]), Value::unit()))
-        .collect();
-    let roots = vec![(tup(&[0]), Value::unit())];
-    let inputs = vec![edges, roots];
-
-    let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(300);
-    let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
-    let mut acc = 0usize;
-    for _ in 0..iters {
-        let out = if backend == "vec" { vec::evaluate(&p, &inputs) } else { corgi::evaluate(&p, &inputs) };
-        acc += out.values().map(|v| v.len()).sum::<usize>();
-    }
-    std::hint::black_box(acc);
-    eprintln!("done {iters} iters backend={backend} (acc={acc})");
-}
diff --git a/interactive/examples/corgi_program.rs b/interactive/examples/corgi_program.rs
deleted file mode 100644
index 639a713db..000000000
--- a/interactive/examples/corgi_program.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-//! M3 (partial backend, end-to-end): run a real flat DDIR program through `render_tree::<CorgiBackend>`
-//! and check it matches the vec backend. Exercises Linear (key/filter), join, and reduce(count) — all
-//! corgi-native — composed via the real DDIR backend path. (Flat: no sub-scope, so `leave_dynamic`
-//! isn't reached; reduce works via the cursor-less `active_times` tactic.)
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_program
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn row(fields: &[i64]) -> Row {
-    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
-}
-
-fn main() {
-    let src = r#"
-        let a = input 0 | key($0[0] ; $0[1]);
-        let b = input 1 | key($0[0] ; $0[1]);
-        let j = a | join(b, ($0 ; tuple($1, $2)));
-        export "join"     = j;
-        export "count"    = j | count;
-        export "filtered" = j | filter($0 != 2);
-    "#;
-    let prog = lower::lower_tree(parse::pipe::parse(src));
-
-    let input0: Vec<(Row, Row)> = vec![
-        (row(&[1, 10]), Value::unit()),
-        (row(&[1, 11]), Value::unit()),
-        (row(&[2, 20]), Value::unit()),
-        (row(&[4, 40]), Value::unit()),
-    ];
-    let input1: Vec<(Row, Row)> = vec![
-        (row(&[1, 100]), Value::unit()),
-        (row(&[2, 200]), Value::unit()),
-        (row(&[3, 300]), Value::unit()),
-    ];
-    let inputs = vec![input0, input1];
-
-    let want = vec::evaluate(&prog, &inputs); // reference: the vec backend
-    let got = corgi::evaluate(&prog, &inputs); // the corgi backend
-
-    assert_eq!(got, want, "corgi backend output != vec backend");
-
-    println!("M3 end-to-end: a flat DDIR program (key + join + count + filter) via render_tree::<CorgiBackend>");
-    for name in ["join", "count", "filtered"] {
-        println!("  export {:?}: {} rows, == vec backend", name, got[name].len());
-    }
-    println!("  e.g. count = {:?}", got["count"].iter().map(|((k, v), d)| (k, v, d)).collect::<Vec<_>>());
-    println!("\nThe corgi backend renders a real multi-operator DDIR program correctly (vs vec).");
-}
diff --git a/interactive/examples/corgi_reach.rs b/interactive/examples/corgi_reach.rs
deleted file mode 100644
index 8aef198c6..000000000
--- a/interactive/examples/corgi_reach.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//! M4: run the canonical RECURSIVE DDIR program (`reach.ddp` — reachability) end-to-end through the
-//! corgi backend and check it matches the vec backend. This is the first program that exercises a
-//! dynamic sub-scope with a feedback `var` — i.e. `leave_dynamic` over `CorgiContainer` — plus join,
-//! distinct (reduce), concat (`+`), key, and arrange, all corgi-native.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reach
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn edge(s: i64, d: i64) -> (Row, Row) {
-    (Value::Tuple(vec![Value::Int(s), Value::Int(d)]), Value::unit())
-}
-fn node(n: i64) -> (Row, Row) {
-    (Value::Tuple(vec![Value::Int(n)]), Value::unit())
-}
-
-fn main() {
-    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/programs/reach.ddp");
-    let src = interactive::load_program(path);
-    let stmts = parse::pipe::parse(&src);
-    let mut prog = lower::lower_tree(stmts);
-    prog.optimize();
-
-    // A small graph: 1->2->3->4 and a disconnected 5->6; root = {1}. reach = {1,2,3,4}.
-    let edges = vec![edge(1, 2), edge(2, 3), edge(3, 4), edge(5, 6)];
-    let roots = vec![node(1)];
-    let inputs = vec![edges, roots];
-
-    let want = vec::evaluate(&prog, &inputs);
-    let got = corgi::evaluate(&prog, &inputs);
-
-    assert_eq!(got, want, "corgi backend != vec backend on reach.ddp");
-
-    // reach.ddp's export is `reach::reach | key(;)` — it collapses node identity, so `result` is a
-    // single (unit, unit) row whose diff is the COUNT of reachable nodes.
-    let total: i64 = got["result"].iter().map(|(_, d)| *d).sum();
-    println!("M4 RECURSIVE end-to-end: reach.ddp via render_tree::<CorgiBackend> == vec backend");
-    println!("  reach.ddp result == vec backend; reachable-node count from {{1}} = {total}");
-    assert_eq!(total, 4, "expected 4 reachable nodes");
-
-    // Identity-preserving variant (no `key(;)`) so we can name the reachable set.
-    let src2 = r#"
-        let edges = input 0 | key($0[0] ; $0[1]);
-        let roots = input 1 | key($0[0] ;);
-        reach: {
-            let proposals = reach | join(edges, ($2 ;));
-            var reach = roots + proposals | distinct;
-        }
-        export "result" = reach::reach | arrange;
-    "#;
-    let mut prog2 = lower::lower_tree(parse::pipe::parse(src2));
-    prog2.optimize();
-    let got2 = corgi::evaluate(&prog2, &inputs);
-    assert_eq!(got2, vec::evaluate(&prog2, &inputs), "corgi != vec on identity reach");
-    let reached: std::collections::BTreeSet<i64> = got2["result"]
-        .iter()
-        .map(|((k, _), _)| match k {
-            Value::Tuple(xs) if xs.len() == 1 => xs[0].as_int(),
-            other => panic!("unexpected reach key {other:?}"),
-        })
-        .collect();
-    println!("  reachable set from {{1}}: {reached:?}");
-    assert_eq!(reached, [1, 2, 3, 4].into_iter().collect());
-    println!("\nThe corgi backend runs a real RECURSIVE DDIR program (feedback var + leave_dynamic) correctly.");
-}
diff --git a/interactive/examples/corgi_reduce.rs b/interactive/examples/corgi_reduce.rs
deleted file mode 100644
index 22feb4cf1..000000000
--- a/interactive/examples/corgi_reduce.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//! M2(a): corgi can EXPRESS a reduce — group-by-key then fold each group — as one corgi program.
-//! This is the per-key scalar logic the incremental arrangement (M2b) will drive. Here we validate
-//! the LOGIC standalone (whole batch, non-incremental) vs a reference: sum-per-key and min-per-key.
-//!
-//!   ~/.cargo/bin/cargo run --release -p interactive --example corgi_reduce
-//!
-//! Program shape (built by hand):  input: List<(K,V)>  -group->  List<(K, List<V>)>
-//!   -map((k,vs) -> (k, REDUCE vs))->  List<(K, V)>     (one row; REDUCE = fold_add / fold_min)
-
-use std::collections::BTreeMap;
-
-use corgi::{ArithOp, Builder, CmpOp, Graph, NumOp, Op, Red, Value as CValue};
-
-/// Build `input: List<(K,V)> -> group -> map((k,vs) -> (k, vs `reduce`))`.
-fn reduce_program(reduce: Red) -> Graph<NumOp> {
-    let mut b = Builder::<NumOp>::default();
-    let input = b.input(); // List<Prod[K,V]>
-    let grouped = b.add(CmpOp::GroupKey, vec![input]); // List<Prod[K, List<V>]>
-
-    // MapList body: one element = Prod[K, List<V>]  ->  Prod[K, reduced V]
-    let body = {
-        let mut bb = Builder::<NumOp>::default();
-        let e = bb.input();
-        let k = bb.add(Op::Field(0), vec![e]);
-        let vs = bb.add(Op::Field(1), vec![e]);
-        let red = bb.add(ArithOp::Reduce(reduce), vec![vs]); // List<V> -> V
-        let out = bb.tuple(vec![k, red]);
-        bb.finish(out)
-    };
-    let mapped = b.add(Op::MapList(Box::new(body)), vec![grouped]);
-    b.finish(mapped)
-}
-
-/// Run a reduce program over `(keys, vals)` as one `List<(K,V)>` row; return key -> reduced.
-fn run_reduce(g: &Graph<NumOp>, keys: &[u64], vals: &[u64]) -> BTreeMap<u64, u64> {
-    let n = keys.len();
-    let pairs = CValue::Prod(vec![CValue::u64(keys.to_vec()), CValue::u64(vals.to_vec())]);
-    let input = CValue::List(vec![n].into(), Box::new(pairs)); // one row of n elements
-    let out = eval_graph_local(g, input);
-    let (_bounds, inner) = out.into_list("reduce out");
-    let cols = inner.into_prod("reduce pairs");
-    let ks = cols[0].clone().into_u64("k");
-    let vs = cols[1].clone().into_u64("v");
-    ks.into_iter().zip(vs).collect()
-}
-
-fn eval_graph_local(g: &Graph<NumOp>, v: CValue) -> CValue {
-    corgi::eval_graph(g, v)
-}
-
-fn main() {
-    let n = 10_000usize;
-    let keys: Vec<u64> = (0..n).map(|i| (i % 7) as u64).collect();
-    let vals: Vec<u64> = (0..n).map(|i| ((i * 13) % 101) as u64).collect();
-
-    // references
-    let mut ref_sum: BTreeMap<u64, u64> = BTreeMap::new();
-    let mut ref_min: BTreeMap<u64, u64> = BTreeMap::new();
-    for (&k, &v) in keys.iter().zip(&vals) {
-        *ref_sum.entry(k).or_insert(0) += v;
-        let e = ref_min.entry(k).or_insert(u64::MAX);
-        *e = (*e).min(v);
-    }
-
-    let g_sum = reduce_program(Red::Add);
-    let g_min = reduce_program(Red::Min);
-    let got_sum = run_reduce(&g_sum, &keys, &vals);
-    let got_min = run_reduce(&g_min, &keys, &vals);
-
-    assert_eq!(got_sum, ref_sum, "sum-per-key mismatch");
-    assert_eq!(got_min, ref_min, "min-per-key mismatch");
-
-    println!("M2(a): corgi expresses reduce (GroupKey + per-group fold)");
-    println!("  {n} updates, {} distinct keys", ref_sum.len());
-    println!("  sum-per-key:  OK   (e.g. key 0 -> {})", got_sum[&0]);
-    println!("  min-per-key:  OK   (e.g. key 0 -> {})", got_min[&0]);
-    println!("\ncorgi can group-by-key and fold each group in one program — the reduce logic the");
-    println!("incremental arrangement (M2b) will drive per changed key.");
-}
diff --git a/interactive/examples/corgi_smoke.rs b/interactive/examples/corgi_smoke.rs
deleted file mode 100644
index 6030467d5..000000000
--- a/interactive/examples/corgi_smoke.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-//! Rung-0 smoke test: prove we can drive corgi from inside the DDIR crate.
-//! Build a corgi program, run it over a column, read the result back.
-//! `~/.cargo/bin/cargo run -p interactive --example corgi_smoke`
-
-fn main() {
-    // A columnar program: per-row x -> x + 100. corgi ops are ALREADY columnar over a Prim
-    // column (the column IS the batch of rows), so no `map` wrapper — the op is the vectorized map.
-    // (`map`/MapList is only for mapping over the inner lists of a List column.)
-    let g = corgi::parse_ml("input add_u64 100").expect("parse");
-    let input = corgi::Value::u64(vec![1, 2, 3, 40, 900]);
-    let out = corgi::eval_graph(&g, input);
-    println!("corgi map(+100) over [1,2,3,40,900] = {}", corgi::show(&out));
-
-    // Shape inference (the dynamic-typing primitive we lean on): observe data -> Shape.
-    let sample = corgi::Value::u64(vec![7, 8, 9]);
-    println!("inferred shape of u64 column = {:?}", corgi::shape_of_value(&sample));
-
-    // Static shape check of the program against that input shape.
-    match corgi::shape_of(&g, &corgi::shape_of_value(&sample)) {
-        Ok(s) => println!("program output shape = {:?}", s),
-        Err(e) => println!("shape error: {e}"),
-    }
-}

From 6433d8f5a71744a579a61486db0ab834896ed472 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Sun, 12 Jul 2026 22:36:16 -0400
Subject: [PATCH 60/68] restore the gate's scc.ddp; the benchmark program is
 scc_bench.ddp
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The .ddp extraction overwrote the pre-existing gate program with the
benchmark's embedded SCC (different export shape, comments lost). The gate
kept passing because the benchmark program is also a valid corgi==vec check —
which is how it slipped through. scc.ddp is restored byte-identical;
ddir_bench loads scc_bench.ddp.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/examples/ddir_bench.rs          |  2 +-
 interactive/examples/programs/scc.ddp       | 52 ++++++++++++++-------
 interactive/examples/programs/scc_bench.ddp | 19 ++++++++
 3 files changed, 55 insertions(+), 18 deletions(-)
 create mode 100644 interactive/examples/programs/scc_bench.ddp

diff --git a/interactive/examples/ddir_bench.rs b/interactive/examples/ddir_bench.rs
index 0cebec9d2..796d0b10b 100644
--- a/interactive/examples/ddir_bench.rs
+++ b/interactive/examples/ddir_bench.rs
@@ -110,7 +110,7 @@ fn scc_edges(nodes: u64, seed0: u64) -> (Vec<(Value, Value)>, Vec<(usize, usize)
 }
 
 fn bench_scc() {
-    let p = program("scc");
+    let p = program("scc_bench");
     let seed0: u64 = std::env::var("SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(0xc0ff_ee42);
     let sizes = sizes(&[100_000, 250_000, 500_000, 1_000_000]);
 
diff --git a/interactive/examples/programs/scc.ddp b/interactive/examples/programs/scc.ddp
index d660f7c3b..91c673ddf 100644
--- a/interactive/examples/programs/scc.ddp
+++ b/interactive/examples/programs/scc.ddp
@@ -1,19 +1,37 @@
+-- Strongly Connected Components — pipe syntax
+-- input 0: edges (src, dst ;)
+
 let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
+let trans = edges | key($1 ; $0);
+
+outer: {
+    let scc = edges + trim;
+
+    fwd: {
+        let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+        let labels = proposals + nodes | min;
+        var proposals = labels | join(scc, ($2 ; $1));
     }
-    export "result" = outer::scc | map(;) | arrange;
+
+    let trim_fwd = edges
+        | join(fwd::labels, ($1 ; $0, $2))
+        | join(fwd::labels, ($0 ; $1, $2))
+        | filter($1[1] == $1[2])
+        | key($0 ; $1[0]);
+
+    bwd: {
+        let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+        let labels = proposals + nodes | min;
+        var proposals = labels | join(trim_fwd, ($2 ; $1));
+    }
+
+    let trim_bwd = trans
+        | join(bwd::labels, ($1 ; $0, $2))
+        | join(bwd::labels, ($0 ; $1, $2))
+        | filter($1[1] == $1[2])
+        | key($0 ; $1[0]);
+
+    var trim = trim_bwd - edges;
+}
+
+export "result" = outer::scc | map(;) | arrange | inspect(total);
diff --git a/interactive/examples/programs/scc_bench.ddp b/interactive/examples/programs/scc_bench.ddp
new file mode 100644
index 000000000..d660f7c3b
--- /dev/null
+++ b/interactive/examples/programs/scc_bench.ddp
@@ -0,0 +1,19 @@
+let edges = input 0 | key($0[0] ; $0[1]);
+    let trans = edges | key($1 ; $0);
+    outer: {
+        let scc = edges + trim;
+        fwd: {
+            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(scc, ($2 ; $1));
+        }
+        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        bwd: {
+            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
+            let labels = proposals + nodes | min;
+            var proposals = labels | join(trim_fwd, ($2 ; $1));
+        }
+        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
+        var trim = trim_bwd - edges;
+    }
+    export "result" = outer::scc | map(;) | arrange;

From 5957981ce35a361dd4f844dd0e90e37052e91e51 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Mon, 13 Jul 2026 09:02:40 -0400
Subject: [PATCH 61/68] interactive: gather the corgi backend internals under a
 corgi module

The five crate-root corgi_*.rs files become src/corgi/{container,chunk,join,
reduce,logic}.rs. No code change beyond the module paths: container is the
CorgiContainer on dataflow edges (was corgi_backend.rs), chunk the columnar
Chunk + arrangement plumbing, logic the DDIR-term compiler, join/reduce the
tactic bindings. backend/corgi.rs (the Backend impl, parallel to backend/vec.rs)
and col_times.rs (a generic columnar-time utility that imports no corgi) stay
where they are. Gate 6/6 both tactics; workspace passes -D warnings.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs                     | 12 ++++++------
 interactive/src/{corgi_chunk.rs => corgi/chunk.rs}   |  4 ++--
 .../src/{corgi_backend.rs => corgi/container.rs}     |  2 +-
 interactive/src/{corgi_join.rs => corgi/join.rs}     | 10 +++++-----
 interactive/src/{corgi_logic.rs => corgi/logic.rs}   |  0
 interactive/src/corgi/mod.rs                         | 11 +++++++++++
 .../src/{corgi_reduce_backend.rs => corgi/reduce.rs} |  2 +-
 interactive/src/lib.rs                               |  6 +-----
 8 files changed, 27 insertions(+), 20 deletions(-)
 rename interactive/src/{corgi_chunk.rs => corgi/chunk.rs} (99%)
 rename interactive/src/{corgi_backend.rs => corgi/container.rs} (98%)
 rename interactive/src/{corgi_join.rs => corgi/join.rs} (93%)
 rename interactive/src/{corgi_logic.rs => corgi/logic.rs} (100%)
 create mode 100644 interactive/src/corgi/mod.rs
 rename interactive/src/{corgi_reduce_backend.rs => corgi/reduce.rs} (99%)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index 20987752a..1a70fa7f2 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -22,12 +22,12 @@ use corgi::arrange::gather;
 use corgi::Value as CValue;
 
 use crate::backend::Backend;
-use crate::corgi_chunk::{chunks_to_columns, CorgiChunk, CorgiChunker};
-use crate::corgi_backend::CorgiContainer;
-use crate::corgi_join::CorgiJoinTactic;
-use crate::corgi_reduce_backend::CorgiReduceBackend;
+use crate::corgi::chunk::{chunks_to_columns, CorgiChunk, CorgiChunker};
+use crate::corgi::container::CorgiContainer;
+use crate::corgi::join::CorgiJoinTactic;
+use crate::corgi::reduce::CorgiReduceBackend;
 use differential_dataflow::operators::int_proxy::ProxyReduceTactic;
-use crate::corgi_logic::{compilable, compile_predicate, compile_projection};
+use crate::corgi::logic::{compilable, compile_predicate, compile_projection};
 use crate::ir::{Diff, LinearOp, Time, Value as DValue};
 use crate::parse::{Projection, Reducer};
 use crate::scope_ir as st;
@@ -297,7 +297,7 @@ pub fn evaluate(
     use differential_dataflow::input::Input;
     use differential_dataflow::AsCollection;
     use differential_dataflow::dynamic::pointstamp::PointStamp;
-    use crate::corgi_backend::CorgiContainer;
+    use crate::corgi::container::CorgiContainer;
 
     let names: Vec<String> = program.root.exports.iter().map(|e| e.name.clone()).collect();
     let mut txs = Vec::new();
diff --git a/interactive/src/corgi_chunk.rs b/interactive/src/corgi/chunk.rs
similarity index 99%
rename from interactive/src/corgi_chunk.rs
rename to interactive/src/corgi/chunk.rs
index 35473d4dd..6a5c614ef 100644
--- a/interactive/src/corgi_chunk.rs
+++ b/interactive/src/corgi/chunk.rs
@@ -516,12 +516,12 @@ where
     }
 }
 
-impl<T, R> timely::container::PushInto<&mut crate::corgi_backend::CorgiContainer<T, R>> for CorgiChunker<T, R>
+impl<T, R> timely::container::PushInto<&mut crate::corgi::container::CorgiContainer<T, R>> for CorgiChunker<T, R>
 where
     T: ColTime,
     R: Semigroup + Clone + 'static,
 {
-    fn push_into(&mut self, c: &mut crate::corgi_backend::CorgiContainer<T, R>) {
+    fn push_into(&mut self, c: &mut crate::corgi::container::CorgiContainer<T, R>) {
         if c.times.is_empty() {
             return;
         }
diff --git a/interactive/src/corgi_backend.rs b/interactive/src/corgi/container.rs
similarity index 98%
rename from interactive/src/corgi_backend.rs
rename to interactive/src/corgi/container.rs
index 5458c34e0..fe753670a 100644
--- a/interactive/src/corgi_backend.rs
+++ b/interactive/src/corgi/container.rs
@@ -12,7 +12,7 @@ use timely::progress::{PathSummary, Timestamp};
 use differential_dataflow::collection::containers::{Enter, Leave, Negate, ResultsIn};
 use differential_dataflow::difference::Abelian;
 
-use crate::corgi_logic::{infer_shape_cols, transcode, untranscode};
+use crate::corgi::logic::{infer_shape_cols, transcode, untranscode};
 use crate::ir::Value as DValue;
 
 type Row = DValue;
diff --git a/interactive/src/corgi_join.rs b/interactive/src/corgi/join.rs
similarity index 93%
rename from interactive/src/corgi_join.rs
rename to interactive/src/corgi/join.rs
index 0d5db50ae..e8aa26cd2 100644
--- a/interactive/src/corgi_join.rs
+++ b/interactive/src/corgi/join.rs
@@ -7,7 +7,7 @@
 //! lattice time-join + diff-multiply, runs the projection corgi program, and emits via the session.
 //!
 //! THIS ITERATION: struct + `defer` + a stub `work`, compiling as a valid `JoinTactic` (validates the
-//! generic-bound wiring). The join COMPUTE is already validated in `examples/corgi_join_mechanism.rs`.
+//! generic-bound wiring).
 
 use std::rc::Rc;
 
@@ -19,10 +19,10 @@ use corgi::Value as CValue;
 
 use differential_dataflow::trace::chunk::{Chunk, ChunkBatch};
 
-use crate::corgi_backend::CorgiContainer;
+use crate::corgi::container::CorgiContainer;
 use crate::col_times::ColTime;
-use crate::corgi_chunk::{flatten_batches, flatten_restricted, CorgiChunk};
-use crate::corgi_logic::compile_join_projection;
+use crate::corgi::chunk::{flatten_batches, flatten_restricted, CorgiChunk};
+use crate::corgi::logic::compile_join_projection;
 use crate::ir::Diff;
 use crate::parse::Term;
 type CBatch<T> = Rc<ChunkBatch<CorgiChunk<T, Diff>>>;
@@ -65,7 +65,7 @@ where
     // with the fresh keys and gather only matches (delta-proportional, not O(trace)); otherwise
     // (non-recursive / comparable sizes) a plain flatten is cheaper than the probe + reconsolidate.
     // Roles (left/right) are preserved for the projection.
-    let accumulated = |acc: &[CBatch<T>], fresh: &crate::corgi_chunk::SortedRun<T, Diff>| {
+    let accumulated = |acc: &[CBatch<T>], fresh: &crate::corgi::chunk::SortedRun<T, Diff>| {
         let acc_len: usize = acc.iter().flat_map(|b| b.chunks.iter()).map(|c| c.len()).sum();
         if acc_len > 2 * fresh.times.len() {
             flatten_restricted(acc, &fresh.keys)
diff --git a/interactive/src/corgi_logic.rs b/interactive/src/corgi/logic.rs
similarity index 100%
rename from interactive/src/corgi_logic.rs
rename to interactive/src/corgi/logic.rs
diff --git a/interactive/src/corgi/mod.rs b/interactive/src/corgi/mod.rs
new file mode 100644
index 000000000..bfa30191c
--- /dev/null
+++ b/interactive/src/corgi/mod.rs
@@ -0,0 +1,11 @@
+//! The corgi rendering substrate's internals: the columnar container on dataflow
+//! edges ([`container`]), the columnar chunk and its arrangement plumbing ([`chunk`]),
+//! the DDIR-term compiler ([`logic`]), and the join/reduce tactic bindings ([`join`],
+//! [`reduce`]). The `Backend` impl wiring these into rendering is
+//! [`crate::backend::corgi`].
+
+pub mod chunk;
+pub mod container;
+pub mod join;
+pub mod logic;
+pub mod reduce;
diff --git a/interactive/src/corgi_reduce_backend.rs b/interactive/src/corgi/reduce.rs
similarity index 99%
rename from interactive/src/corgi_reduce_backend.rs
rename to interactive/src/corgi/reduce.rs
index f1df55db6..116926843 100644
--- a/interactive/src/corgi_reduce_backend.rs
+++ b/interactive/src/corgi/reduce.rs
@@ -41,7 +41,7 @@ use corgi::arrange::{gather, gather_lanes, sort_blocks};
 use corgi::{Bounds, Shape, Value as CValue};
 
 use crate::col_times::ColTime;
-use crate::corgi_chunk::{columns_to_batch, CorgiChunk};
+use crate::corgi::chunk::{columns_to_batch, CorgiChunk};
 use crate::ir::Diff;
 use crate::parse::Reducer;
 
diff --git a/interactive/src/lib.rs b/interactive/src/lib.rs
index e7c52264b..93329759f 100644
--- a/interactive/src/lib.rs
+++ b/interactive/src/lib.rs
@@ -1,11 +1,7 @@
 pub mod parse;
 pub mod ir;
 pub mod col_times;
-pub mod corgi_logic;
-pub mod corgi_backend;
-pub mod corgi_chunk;
-pub mod corgi_join;
-pub mod corgi_reduce_backend;
+pub mod corgi;
 pub mod lower;
 pub mod scope_ir;
 pub mod backend;

From ece94576773391c65215bef142c3f813751a24c1 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Tue, 14 Jul 2026 13:11:08 -0400
Subject: [PATCH 62/68] interactive: gate to a test; remove benchmark tooling
 and working notes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Addresses review of the subsystem PR:
- corgi_progs (the corgi==vec gate) moves from examples/ to a tests/ integration
  test (tests/corgi_backend.rs) — it is a gate, so its home is cargo test / CI,
  not examples/. Runs the six canonical .ddp programs, one #[test] each.
- Remove the benchmark/measurement tooling that isn't a DDIR example: ddir_bench,
  corgi_scorecard, and the five benchmark-only programs (ast/ident/scc_bench/
  scc_compound/scc_plain .ddp — the latter three the duplicate-SCC sprawl). These
  are dev tooling, not part of the library; they stay on the dev branch and can
  land separately if the later perf PRs want reproducible in-tree numbers.
- Drop the working notes (SPIKE.md + two findings files, ~970 lines of markdown).

examples/ is back to DDIR programs plus the pre-existing server/dump binaries.
strongly_connected_at stays (a general algorithms/ addition, tested by tests/scc.rs).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 SPIKE.md                                      | 727 ------------------
 corgi-kernel-findings-scc.md                  | 120 ---
 int-proxy-columnar-findings.md                | 123 ---
 interactive/examples/corgi_progs.rs           |  83 --
 interactive/examples/corgi_scorecard.rs       | 215 ------
 interactive/examples/ddir_bench.rs            | 545 -------------
 interactive/examples/programs/ast.ddp         |  17 -
 interactive/examples/programs/ident.ddp       |  12 -
 interactive/examples/programs/scc_bench.ddp   |  19 -
 .../examples/programs/scc_compound.ddp        |  19 -
 interactive/examples/programs/scc_plain.ddp   |  19 -
 interactive/tests/corgi_backend.rs            |  49 ++
 12 files changed, 49 insertions(+), 1899 deletions(-)
 delete mode 100644 SPIKE.md
 delete mode 100644 corgi-kernel-findings-scc.md
 delete mode 100644 int-proxy-columnar-findings.md
 delete mode 100644 interactive/examples/corgi_progs.rs
 delete mode 100644 interactive/examples/corgi_scorecard.rs
 delete mode 100644 interactive/examples/ddir_bench.rs
 delete mode 100644 interactive/examples/programs/ast.ddp
 delete mode 100644 interactive/examples/programs/ident.ddp
 delete mode 100644 interactive/examples/programs/scc_bench.ddp
 delete mode 100644 interactive/examples/programs/scc_compound.ddp
 delete mode 100644 interactive/examples/programs/scc_plain.ddp
 create mode 100644 interactive/tests/corgi_backend.rs

diff --git a/SPIKE.md b/SPIKE.md
deleted file mode 100644
index 194d21571..000000000
--- a/SPIKE.md
+++ /dev/null
@@ -1,727 +0,0 @@
-# Spike: corgi as columnar scalar logic inside differential-dataflow
-
-**Goal.** Run corgi (`frankmcsherry/wip:corgi`) — or a light fork — as the scalar logic DD's
-join/reduce/linear operators invoke *where they would normally call a closure*, applied to **many
-rows at once** (columnar). Host = the DDIR crate (`interactive/`). Drive to a **measured viability
-conclusion**: does corgi-over-columns beat DDIR's per-row `ir::eval` interpreter, and from what
-column width? How much existing structure can we reuse; do we need a corgi-data CHUNK variant?
-
-This file is the durable log across loop iterations. **Read it first each iteration.**
-
----
-
-## PHASE 2 (2026-06-29): BUILD THE CORGI BACKEND (no transcode, corgi-native)
-
-Goal: corgi's columnar `Value` is DDIR's native row representation end-to-end; operators run
-`eval_graph`; conversion only at I/O boundaries. Frank: consult `chunk/vec.rs` + the `columnar/`
-stack as templates (don't copy literally). Phase-1 verdict (above) stands; this builds the real thing.
-
-### Design surface — much smaller than feared (verified this iteration)
-- `timely::Container` = just `Accountable + Default + 'static` (blanket impl, timely lib.rs:104). So
-  a custom container needs only `record_count` + `Default` + `'static`.
-- Backend container bound (`backend/mod.rs:39-42`) = `Container + Clone + ResultsIn<Summary> +
-  Enter<Time,Time,Inner=Self> + Leave<Time,Time,Outer=Self>`. **Enter/Leave are SAME-time =
-  IDENTITY** for DDIR's dynamic-timestamp model (comment `backend/mod.rs:38`). No `ContainerBytes`
-  in the bound → **not needed for single-worker** (`evaluate` uses `execute_directly`).
-- Container trait defs: `Negate::negate(self)->Self`; `Enter<T1,T2>{type InnerContainer; enter}`;
-  `Leave<T1,T2>{type OuterContainer; leave}`; `ResultsIn<TS>::results_in(self,&TS)->Self`
-  (`collection.rs:1314-1339`; `Vec<(D,T,R)>` reference impls at :1350-1376 — the template).
-- NOTE: `backend::col` is **commented out in this branch** (`backend/mod.rs:14`, "deferred on the
-  Value-model port") — so this is a fresh backend, not a col revival. `col.rs` readable for ideas.
-
-### The container (M1 foundation)
-`CorgiContainer<T, R>` = `{ keys: corgi::Value, vals: corgi::Value, times: Vec<T>, diffs: Vec<R> }`.
-**Payload (key/val) corgi-columnar; time/diff plain Rust Vecs** — corgi never touches time/lattice.
-Trait impls (all easy, time/diff in Rust, payload columns pass through or gather):
-- `Accountable::record_count` = `times.len()`. `Default`/`Clone`.
-- `Negate` = negate `diffs`. `Enter<T1,T2>`/`Leave<T1,T2>` = map times (identity for T1=T2=Time).
-- `ResultsIn` = map each time via `step.results_in`; on `None`, drop that row → `gather` the corgi
-  key/val columns by surviving indices (corgi `engine::gather`). Keep all four columns aligned.
-
-### Staged milestones
-- **M1 — container + corgi-native Linear, in a real dataflow (NO arrangement).** Linear is a
-  container-level unary: input `CorgiContainer` block → `eval_graph` on keys/vals → output block.
-  Ingest transcodes rows→block ONCE (boundary); egress block→rows ONCE. Between ops: zero
-  transcode. Example mirrors `corgi_linear_dataflow`/`corgi_chain` but with the native container →
-  should hit the eval-only ceiling. **This is the headline "no transcode" proof; do first.**
-- **M2 — corgi arrangement (for join/reduce).** Route A: a `Chunk` impl over corgi columns
-  (`chunk/vec.rs` template) → free `ChunkBatcher/Builder/Spine`; needs a cursor (navigates KEYS)
-  + merge/extract/advance/settle (corgi sort/merge). The scalar logic (join projection / reducer)
-  runs `eval_graph` over each key's VALUE-column slice (cursor gives the key run; corgi bulk-processes
-  its values). Pragmatic start: hybrid (existing `ValSpine` storage + corgi logic over per-key
-  slices) to prove reduce/join correctness, then move storage to corgi columns to kill transcode.
-- **M3 — wire `impl Backend for CorgiBackend`** (linear/arrange/join/reduce/as_collection/inspect/
-  leave_dynamic) + `render_tree::<CorgiBackend>`; run a real DDIR program end-to-end vs `evaluate`.
-
-### Boundary transcode is expected & fine (the only conversions):
-ingest (input rows→corgi block), egress (→rows), and any not-yet-ported op (interpreter fallback).
-Operator-to-operator flow is transcode-free. Reuse `corgi_logic::{transcode,untranscode,compile*}`.
-
----
-
-## ★ VERDICT (2026-06-28): VIABLE — strong win, recommended. ★
-
-corgi as DDIR's columnar scalar logic works, integrates soundly with differential-dataflow, and
-is a large measured win. Every question posed is answered:
-
-- **corgi as scalar logic over many rows** — YES. Compiles DDIR `Term` → corgi `Graph<NumOp>`,
-  runs columnar. Measured **50–135×** vs the per-row `ir::eval` interpreter on the map/filter/arith
-  core (eval-only), **5.4×** on list/fold aggregation. Crossover at **~10 rows** (below that,
-  `eval_graph` per-call setup loses). Examples: `corgi_bench`, `corgi_fold`.
-- **Inside a real DD dataflow** — YES, SOUND. `corgi_linear_dataflow` runs corgi as a DDIR Linear
-  map in a real differential computation; output matches the interpreter exactly incl. net-zero
-  retractions vanishing. corgi never touches time; the operator keeps (time,diff)/lattice in Rust.
-- **The cost lever** — the AoS↔SoA **transcode dominates** the per-call model (~85–95% at scale).
-  Storing data corgi-columnar amortizes it: a K-op chain stays ~flat (`corgi_chain`), so the win
-  GROWS with program depth (9×→22.5× over interp as K=1→16; 2–3.6× over per-op transcode).
-- **Reuse / CHUNK variant** — to START, nothing new is needed: the scalar-logic path runs over any
-  existing arrangement via per-call transcode. The corgi-columnar **CHUNK is the optimization**
-  that removes the transcode, and pays more the deeper the program. Two routes (see "ARCHITECTURE
-  FINDING"): via the `Chunk` trait (requires writing a cursor — it mandates `Navigable`), or
-  cursor-less via a corgi container + custom `Merger` + tactic (the true use of the #771–773 seam).
-- **Dynamic typing** — SOLVED. `infer_shape` forms the corgi `Shape` by observing the data; the
-  `Term` drives ops, the inferred shape drives layout. For sum types, scan the column for all arms
-  (the one genuinely data-dependent case; not yet built).
-- **corgi modifications needed** — NONE so far. Map/filter/arith/list/fold all hit existing ops.
-
-**Coverage:** DONE + measured — Var/Bound/Int/Tuple/Proj/Binary(arith,cmp,logical)/If/List/Fold.
-MAPPED but not built — Variant/Inject/Case (→ MapSum/Unwrap/CapSum; needs column-scan Sum shape
-inference + lane partition), Hash (compose or a light corgi op), signed/i64 (corgi `enc_i64`/
-`ToSigned`). None are blockers; all have a clear path.
-
-**Recommendation:** pursue it. Order: (1) land the `Term→Graph` compiler + transcoder as a real
-DDIR module [DONE here as `corgi_logic.rs`]; (2) wire corgi into the Linear operator behind a
-Backend flag [prototyped]; (3) corgi reduce tactic (closure already gets a per-key column slice);
-(4) corgi-columnar CHUNK to kill the transcode — biggest payoff, do once 1–3 prove out; (5) extend
-coverage to Variant/Case for the eqsat/datalog corpus.
-
-Artifacts (all GREEN, `~/.cargo/bin/cargo run --release -p interactive --example <name>`):
-`corgi_smoke`, `corgi_bench`, `corgi_linear_dataflow`, `corgi_chain`, `corgi_fold`;
-library module `interactive/src/corgi_logic.rs`.
-
----
-
-## Environment (durable)
-
-- Worktree: `/Users/mcsherry/Projects/dd-corgi-spike`, branch `corgi-scalar-spike`, base
-  `4eff165a` (= join-tactics: master-next `#772` + navigation-free join/reduce tactic drivers).
-- corgi clone (read-only study, light mods allowed): `/Users/mcsherry/Projects/wip/corgi`
-  (separate `wip` repo, `corgi/` dir, no-deps, ~2.1k LoC). Wired as path dep in
-  `interactive/Cargo.toml`: `corgi = { path = "../../wip/corgi" }`.
-- cargo NOT on PATH → use `~/.cargo/bin/cargo`. Build cmd: `cd <worktree> && ~/.cargo/bin/cargo build -p interactive`.
-  Cold build measured **~10s** (fast iteration available). Run long builds in background.
-
-## The plan: corgi = the scalar closure, NOT the tactic
-
-DD `master-next` made navigation optional and join/reduce drive over a pluggable **tactic**
-(`operators/join.rs:56 JoinTactic`, `operators/reduce.rs:28 ReduceTactic`; minimal batch =
-`BatchReader{len,description}` only, `trace/mod.rs:215`; `Navigable` opt-in `cursor/mod.rs:25`).
-corgi does NOT implement the tactic/merge engine — the tactic keeps navigation + all `(time,diff)`
-lattice algebra in Rust. corgi replaces the **scalar closure**: DDIR's `Term` programs
-(`interactive/src/parse/mod.rs:28`; `Projection`=`:86`, `Reducer`=`:89`, `LinearOp`=`ir.rs:37`)
-compile to a corgi `Graph<NumOp>`, run by one compiled `eval_graph` over columns. "No lattice in
-corgi" is therefore fine — corgi never sees time.
-
-**Why columns matter:** corgi only beats the inline interpreter when handed *wide* columns
-(`eval_graph` has per-call setup, `graph.rs:72`). Per-row corgi loses. The whole experiment is
-"how wide before corgi wins."
-
-**KEY INSIGHT (rung 0, verified):** corgi ops are *inherently columnar* — a `Prim` column IS the
-batch of rows, and each op is the SIMD/vectorized map. So a per-row scalar `Term` compiles to a
-**flat** corgi graph over the column (`Input` = the column); there is NO top-level `map` wrapper.
-`MapList`/`Fold` appear only when the `Term` itself maps/folds over an *inner* `List` (DDIR `Fold`,
-`FlatMap`). This makes the `Term → Graph` compile more direct than expected: binders are columns,
-`Field` projects a Prod-column's component (itself a column), arithmetic/compare ops are columnar.
-Pitfall found: `parse_ml("input map (x -> x add 100)")` panics ("MapList: expected a list") on a
-`Prim` — use `input add_u64 100`.
-
-### Staging ladder
-- **Rung 0 (DONE):** env up, corgi builds inside DDIR, API mapped, smoke test.
-- **Rung 1:** `Term → Graph<NumOp>` compiler (the load-bearing artifact) + `&[ir::Value] →
-  corgi::Value` columnar transcoder, both **shape-directed**. Standalone bench: corgi vs per-row
-  `ir::eval` on a map/filter `Term`, sweep column width → find crossover. (Lives as a module +
-  example *inside* `interactive/`, reusing real `Term`/`Value`/`ir::eval`.)
-- **Rung 2:** wire into DDIR's **Linear** operator (pure row-wise map/filter; no tactic needed —
-  `backend/mod.rs:46`, `vec.rs:114`) so it runs inside a real DD dataflow.
-- **Rung 3:** **Reduce** — its closure already gets a per-key `&[(val,diff)]` slice
-  (`reduce.rs:651`), a natural column; corgi reducer (Min/Distinct/Count/Collect →
-  Min/DedupList/Len/SortList+group). Big-group win first; key-batching for small groups later.
-- **Rung 4 (stretch):** corgi-columnar **CHUNK** batch (`Chunk` impl à la `trace/chunk/vec.rs`)
-  storing values as corgi columns so the column handed to corgi is a slice/Gather, not a
-  per-call transcode. This is where the "batch without cursor" feature earns its keep.
-- **Join** last (closure is per-`(val0,val1)` pair, `join.rs:99` → needs match-buffering).
-
-## Dynamic-typing approach (Frank's key concern)
-
-DDIR `Value = Int|Tuple|Variant|List` (`ir.rs:18`) is dynamically typed; corgi columns need a
-fixed `Shape` (`shape.rs`, `Prim(w)|Prod|Sum|List`). Resolution: **infer the corgi `Shape` by
-observing the data** (corgi `shape_of_value`) — i.e. the row type is formed from what actually
-flows. The `Term` drives the ops; the input `Shape` drives shape-dependent choices (e.g. `Proj` →
-`Field` on a Prod vs `Get`/`Gather` on a List, `Inject` arity). Output shape = `shape_of(graph,
-input_shape)`. Compiler signature: `compile(term: &Term, input_shape: &Shape) -> Graph<NumOp>`.
-
-## corgi API (locked, for the compiler)
-
-- Build: `corgi::Builder::<NumOp>::default()` → `.input()` / `.tuple(Vec<id>)` /
-  `.add(op: impl Into<NumOp>, vec![id]) ` / `.finish(out_id) -> Graph<NumOp>`. (`graph.rs:113`)
-- Run: `corgi::eval_graph(&g, value) -> Value` (CONSUMES arg, moves to last use). `graph.rs:72`.
-- Typecheck: `corgi::shape_of(&g, &input_shape) -> Result<Shape,String>`; `shape_of_value(&v)`.
-- Template for the compiler: corgi's own `frontend/ml.rs:479 lower(e, env, b)` — env maps
-  binders→node ids; near-identical shape to what I need.
-- `Value` ctors: `Value::u64(Vec<u64>)`, `Value::u8`, `Value::List(bounds.into(), Box<Value>)`,
-  `Value::Prod(Vec<Value>)`, sum via `Value::sum`/`sum_from_prim`. Lit broadcasts vs an input node.
-- i64: `corgi::{enc_i64, dec_i64}`; signed order via `ArithOp::ToSigned` ("signed"). Spike v1 can
-  assume small non-negative ints (plain u64) and add enc/dec when needed.
-
-### Term → corgi op map (from `frontend/mod.rs:83 resolve` + `ops/`)
-| DDIR `Term`/op | corgi |
-|---|---|
-| `Var(i)`/`Bound(k)` | env lookup (node id); Var absolute, Bound from innermost |
-| `Int(n)` | `Op::Lit(Value::u64(vec![n as u64]))` (broadcast vs input node) |
-| `Tuple` / `Spread` | `b.tuple(ids)` / splice fields |
-| `Proj(t,i)` | `Op::Field(i)` (Prod) **or** `get`/`Gather` (List) — shape-directed |
-| `Inject(tag,pay)` | `Op::Inject(tag,arity)` — const tag only (data-driven tag = stretch) |
-| `Case{arms,default}` | `Op::MapSum(arms)` + `Op::Unwrap` (cf ml.rs Match); default = stretch |
-| `Fold{list,init,step}` | pair `(init,list)` then `Op::Fold(body)`; mind binder order |
-| `If{c,t,e}` | masks + `Op::Select` (mask,then,else) — evaluates both arms (SIMD predication) |
-| `Unary(Neg)` | `ArithOp::Neg(U,64)`; `Len`→`Op::Len`; `Not`/`IsTag` = compose |
-| `Binary(Add/Sub/Mul)` | `ArithOp::Bin(op,U,64)` |
-| `Binary(Eq/Ne/Lt/Le)` | `CmpOp::Rel(Pred::_)`; `Gt/Ge` = swapped; `And/Or` = compose (mul/max) |
-| `Hash` | NO corgi op → light corgi mod, or compose mul/shr/and (stretch) |
-| `Reducer::{Min,Distinct,Count,Collect}` | `Min` / `DedupList` / `Len` / `SortList`+group |
-
-Most of LinearOp's map/filter core (Proj/Tuple/Int/Binary/If) maps 1:1 → start there.
-
----
-
-## Decision log
-- 2026-06-28: isolated worktree (not Frank's checkouts); corgi as path dep; spike code hosted in
-  `interactive/` reusing real `Term`/`ir::eval` (no duplication, stays honest, "in DDIR" per ask).
-- 2026-06-28: corgi-as-closure (rungs 1–3) works on existing arrangements via per-call transcode;
-  corgi-columnar CHUNK (rung 4) removes the transcode and is where the cursor-less batch matters.
-
-## Status / next
-- [x] Rung 0: env, build (cold ~10s / incremental ~0.1s), corgi API mapped, op table.
-- [x] Rung 0: smoke test `interactive/examples/corgi_smoke.rs` GREEN.
-- [x] Rung 1: `examples/corgi_bench.rs` — `infer_shape` (data→Shape), `transcode` (AoS→SoA),
-      `compile(Term→Graph<NumOp>)` for the map/filter core (Var/Bound/Int/Tuple/Proj/Binary/If),
-      crossover bench. **GREEN + correctness verified vs `ir::eval`.**
-- [x] Rung 2: `examples/corgi_linear_dataflow.rs` — corgi computes a DDIR Linear map **inside a
-      real DD dataflow** (container-level unary operator: transcode batch→corgi cols, `eval_graph`,
-      transcode back; (time,diff) pass through). Shared compiler/transcoder promoted to lib module
-      `src/corgi_logic.rs`. **VERIFIED == `ir::eval` reference incl. net-zero retractions vanishing.**
-      → Integration is SOUND; corgi composes with DD's incremental/differential semantics.
-      (This operator pays both transcodes = the rung-1 "floor"; the ceiling needs rung 4.)
-- [x] Rung 4 (measurement): `examples/corgi_chain.rs` — K-op chain, interp vs per-op-transcode
-      vs corgi-columnar. **GREEN + correctness.** corgi-columnar storage scales ~flat with depth.
-- [x] Q3 (partial, sufficient for verdict): List + Fold built & validated (`examples/corgi_fold.rs`,
-      5.4× over interp, correctness OK). Variant/Case/Hash mapped but not built (see VERDICT).
-- [x] **Phase-1 VERDICT written (top of file). Measured viability reached.**
-
-### Phase 2 status (build the corgi backend; spec at top under "PHASE 2")
-- [x] Studied references: `Backend` trait, `chunk/vec.rs` (Chunk+Cursor), `RecordedUpdates`
-      (`columnar/collection/container.rs`), container trait surface. Design locked (small surface).
-- [x] M1: `src/corgi_backend.rs` (`CorgiContainer<T,R>` = corgi key/val cols + Rust time/diff;
-      `Accountable/Default/Clone`, `from_updates`/`into_updates` boundary transcode) +
-      `examples/corgi_backend_linear.rs` (a real DD dataflow: ingest→K×corgi-Project→egress).
-      **GREEN, == interpreter.** 8 chained Linear ops, **2 transcodes total (ingest+egress), ZERO
-      between operators** (vs 2K in the per-op model). Container surface confirmed minimal:
-      `CapacityContainerBuilder<C>` needs only `C: Accountable+Default`; give_container ships whole
-      prebuilt blocks through `unary`/`Pipeline`. corgi `Value` self-describes (`shape_of_value`),
-      so the container needn't carry shapes. (Inline the K-chain in the dataflow closure — a generic
-      `fn over Stream<G,_>` trips timely's Stream-lifetime / `Scope` struct-vs-trait.)
-- [x] M2(a): `examples/corgi_reduce.rs` — corgi EXPRESSES reduce (`GroupKey` + per-group fold via
-      `MapList`/`ArithOp::Reduce`) — sum-per-key & min-per-key == reference. GREEN. The per-key
-      reduce logic is validated; M2(b) makes it incremental.
-- [ ] M2(b): incremental corgi arrangement — **DECISION: Route B (cursor-less + tactic)** (Frank,
-      2026-06-29). ← **NEXT**. Sub-plan:
-      - M2b-1: `CorgiBatch` (corgi key/val cols + Rust time/diff, sorted/consolidated, +
-        `Description`) impl `BatchReader` (NO Cursor) + `Batch`/`Merger` (merge two batches & advance
-        times to compaction frontier, fuel-bounded) — the intricate core; test in isolation
-        mirroring `chunk/vec.rs`'s merger tests.
-        - [x] **Corgi light mod DONE** (branch `dd-arrange-api` in `wip/corgi`): exposed
-          `corgi::arrange::{gather, gather_lanes, compare_at}`. `compare_at` = scalar wrapper over
-          `compare_idx` (new, `ops/cmp/order.rs`); `mod order` → `pub(crate)`. **All 45 corgi tests
-          pass; interactive builds against it.** NOTE: `sort_perm`/`concat` are `#[cfg(test)]`-gated
-          → NOT used. Build a sort via Rust `indices.sort_by(|i,j| compare_at(kv,i,kv,j))`; build
-          merge output via `gather_lanes(&[Some(&kv1),Some(&kv2)], tags, off)` (avoids `concat`).
-          corgi structural order = leaf, Prod field-wise, List LENGTH-FIRST, Sum tag-then-payload —
-          a total order; consistent use is all correctness needs (compare as multisets, not vs DDIR Ord).
-        - [x] **`CorgiBatch` + merge DONE & TESTED** (`src/corgi_arrange.rs`): `CorgiBatch<T,R>`
-          (corgi key/val cols + Rust time/diff + `Description`) impl `BatchReader` (no Cursor);
-          `from_unsorted` (sort via `compare_at` + `gather`, consolidate); `merge` (two-pointer over
-          (k,v) groups via `compare_at`, per-group advance-to-frontier + consolidate in Rust, output
-          via `gather_lanes`). **Property test: 300 random merges == reference (union+advance+
-          consolidate); sort/consolidate test passes.** The intricate incremental core works over
-          corgi-native columns. (Eager merge — fuel/grading sophistication deferred; correctness first.)
-- [~] M2b-2: wire `CorgiBatch` into the DD trace machinery.
-      - [x] `Batch` + `Merger` (`CorgiMerger`, eager wrapper over `merge`) DONE & TESTED
-        (`merger_trait_drives` passes). KEY: `Batch`/`BatchReader`/`Builder` are blanket-impl'd for
-        `Rc<B>` (`trace/mod.rs:327` rc_blanket_impls), so `Spine<Rc<CorgiBatch>>` exists for free.
-      - [ ] `Builder` (DD trait) + `Batcher` + `arrange_core` wiring — the fiddliest plumbing
-        (Batcher/Chunker generics; `arrange_core` at `operators/arrange/arrangement.rs:346`).
-- [x] M2b-3 (mechanism, de-risk): `examples/corgi_reduce_trace.rs` — Route-B reduce MECHANISM
-      verified end-to-end over a manual corgi trace. Accumulate `CorgiBatch`es via `merge`
-      (consolidated per (key,val)); corgi **Count** reducer (GroupKey + `fold_add` over the diff
-      column — retractions just subtract; i64-as-u64 add is bit-correct). 4 steps incl. retraction
-      to zero (key vanishes) + multi-val key — **each step == reference. GREEN.** The full Route-B
-      reduce mechanism (trace-maintenance + corgi reduce) works; only the live-operator wiring remains.
-- [ ] M2b-2-finish + live tactics: **DECISION (Frank 2026-06-29): keep looping, do the FULL tactic
-      wiring** (arrange_core + reduce_with_tactic/join_with_tactic — the proper Route-B Backend). ← **NEXT**
-      Sub-plan (test each piece; expect several iterations; all mechanisms already proven):
-      - [x] **`Builder` DONE & TESTED** (`CorgiBatchBuilder`, `builder_builds_corgi_batch` passes):
-        `Input = Vec<((key,val),T,R)>` (rows), `Output = CorgiBatch`; `done`/`seal` transcode the
-        sorted chain → corgi columns via `build_batch` (`infer_shape`+`transcode`+`from_unsorted`).
-        `RcBuilder<CorgiBatchBuilder>` → `Rc<CorgiBatch>` (blanket).
-      - **DESIGN DECISION:** `Ba::Output = Vec<((key,val),T,R)>` (rows) → **reuse the existing
-        `MergeBatcher` + its vec-row `Merger`** (`merge_batcher.rs:283`) as the Batcher (big
-        simplification). Cost: one transcode rows→corgi at the Builder (arrangement-ingest boundary,
-        once per batch) — NOT operator-to-operator. The reduce/join tactics read corgi columns from
-        the stored `CorgiBatch`, so the corgi-native compute property holds. (A corgi batcher-side
-        Merger to drop even the ingest round-trip is a later optimization.)
-      - [x] **Batcher + chunker + `arrange_core` DONE — COMPILES & RUNS**
-        (`examples/corgi_arrange_smoke.rs`). `impl DrainContainer for CorgiContainer` (drain =
-        untranscode to rows) lets the stock `ContainerChunker<Vec<Upd>>` chunk a corgi-container
-        stream; Batcher = `MergeBatcher<VecMerger<(Value,Value),T,R>>` (reused, like ord_neu);
-        Builder = `RcBuilder<CorgiBatchBuilder>`; Trace = `Spine<Rc<CorgiBatch>>`. Full 6-generic
-        `arrange_core` wiring compiles and a 1000-update arrange runs clean. **The arrangement is wired.**
-      - [!] `CorgiReduceTactic::retire` — **WALL HIT (2026-06-29), surfaced to Frank.** DD's
-        incremental reduce core is `HistoryReplayer` (interesting-times algorithm, `reduce.rs:448-758`,
-        ~300 lines of DD's subtlest logic) and it is **cursor-coupled**: `compute` takes
-        `C1/C2/C3: Cursor`, `replay_key` walks cursors, and the default `CursorTactic` even *requires*
-        `B1: Navigable` (`reduce.rs:258`). A cursor-less Route-B reduce ⇒ reimplement that
-        interesting-times machinery over corgi columns — DD's hardest code, very high-risk to get
-        right unattended (partially-ordered iterative times). M2b-3 proved the SINGLE-TIME reduce
-        mechanism; the general multi-time incremental `retire` is the gap. Options for Frank: (a)
-        simplified single-time/totally-ordered CorgiReduceTactic (tractable, covers many DDIR reduces,
-        documents the limit); (b) HYBRID — give CorgiBatch a thin cursor, reuse the proven
-        `HistoryReplayer`/CursorTactic with corgi as the per-key `logic` (correct + general, but
-        reintroduces a cursor + per-key-slice transcode); (c) Frank designs the cursor-less `retire`.
-        NOTE: JOIN is likely more tractable cursor-less (bilinear, no interesting-times).
-        **DECISION (Frank 2026-06-29): option (c) — Frank designs the cursor-less `retire`.** Reduce
-        operator PAUSED pending his design; the M2b-3 mechanism + the arrangement are ready for it.
-      - [x] **JOIN MECHANISM DONE & TESTED** (`examples/corgi_join_mechanism.rs`): cursor-less
-        equijoin compute — merge-join two corgi batches' key columns via `compare_at`, cross-product
-        matched val runs via `gather`, multiply diffs (Rust). 300 randomized cases + a directed case
-        == reference hash-join, incl. retractions (negative product diffs). GREEN.
-      - [~] `CorgiJoinTactic::{defer,work}` + `join_with_tactic` — wrap the mechanism in the tactic:
-        - [x] **Skeleton COMPILES** (`src/corgi_join.rs`): `CorgiJoinTactic<T>` + `CorgiDeferred<T>`
-          + `defer` (queues bilinear units to todo0/todo1 by `Fresh`, sets advance flags) + stub
-          `work`, as a valid `impl JoinTactic<Rc<CorgiBatch>, Rc<CorgiBatch>, CB>`. Bound gotchas
-          resolved: `CB` is the **composite** `timely::ContainerBuilder` (not `timely::container::`),
-          + `CB: PushInto<((Row,Row),T,Diff)>` for `session.give`; structs need `T: Timestamp`
-          (hold `Capability<T>`). The generic-bound wiring is validated.
-        - [x] **`work` DONE + JOIN LIVE IN A REAL DATAFLOW** (`examples/corgi_join_dataflow.rs`):
-          `work` merges each side's batch list (`merge_one`), merge-joins by key (`compare_at`),
-          cross-products matched val runs (`gather`) with `t0.join(t1)` + `d0*d1`, runs the projection
-          corgi program (`compile_join_projection`, Var0=key/Var1=val0/Var2=val1), and emits via
-          `session_with_builder(&cap).give(((k,v),t,d))`. Wired with `join_with_tactic` over two
-          `arrange_core` corgi traces. **Output == reference hash-join incl. a retraction** (net-zero
-          `(2,6)` excluded → `{(1,110),(1,120),(2,205),(2,305)}`). **The cursor-less corgi JOIN
-          operator works end-to-end over corgi-native storage + compute via the #771–773 seam.**
-      - [ ] (old) `CorgiJoinTactic::{defer,work}` + `join_with_tactic` — wrap the mechanism in the tactic:
-        `defer` queues bilinear units (Vec<B0>×Vec<B1>, by `Fresh`) + capability + advance flags;
-        `work` drains under fuel, runs the join mechanism per unit, joins times via the lattice +
-        multiplies diffs, emits via the `OutputBuilderSession`/`JoinSession` (capability). Bilinear:
-        accumulate each side's batch list (merge to one run first). Test join in a real dataflow vs
-        reference. The output-session/capability + batch-list mgmt is fiddly timely plumbing —
-        surface if too subtle. ← **NEXT**
-      - M2b-2: `Batcher`/`Builder` + a `Spine<Rc<CorgiBatch>>`; `arrange` a collection.
-      - M2b-3: `CorgiReduceTactic::retire` runs the M2(a) reduce program in bulk over batches;
-        `reduce_with_tactic`; test incremental reduce (with retractions) vs reference.
-      - M2b-4: `CorgiJoinTactic` (defer/work); `join_with_tactic`; test vs reference.
-- [ ] M3: `impl Backend for CorgiBackend` + `render_tree` a real program vs `evaluate`.
-  - PARTIAL BACKEND (Frank's post-join step): Linear (M1) + arrange (M2b-2) + join (M2b-4) all work
-    live; reduce = Frank's design. A `Backend` impl with `reduce` stubbed (`todo!()`) + `render_tree`
-    on a reduce-free DDIR program (map/filter/join) would show corgi composing through the real DDIR
-    backend path. Full M3 (with reduce) awaits Frank's `retire`.
-    - [x] **Container bounds DONE** (`src/corgi_backend.rs`): `Negate` (negate diffs), `Enter<T,T>`/
-      `Leave<T,T>` (identity — DDIR same-Time dynamic model), `ResultsIn<T::Summary>` (map times via
-      `step.results_in`, drop `None` rows via `gather` of the corgi cols) — all generic, time/diff in
-      Rust. `CorgiContainer` now satisfies the `Backend::Container` bound. COMPILES.
-    - [x] **`Backend` impl SHAPE COMPILES** (`src/backend/corgi.rs`, `pub mod corgi` in backend/mod.rs):
-      `enum CorgiBackend` with `Container = CorgiContainer<Time,Diff>`, `Arr = Arranged<TraceAgent<
-      Spine<Rc<CorgiBatch<Time,Diff>>>>>`. `arrange` real (the arrange_core stack); linear/join/
-      as_collection/reduce/inspect/leave_dynamic = `todo!()`. A `render_tree::<CorgiBackend>` wrapper
-      compiles → **the full Backend wiring + render_tree bounds are validated.** Note: `leave_dynamic`
-      is Vec-specific in DD (`dynamic/mod.rs:40`, truncates per-record times) → corgi needs a custom
-      unary over `CorgiContainer.times`.
-    - [x] **`linear` + `join` bodies DONE (compile).** `linear` = container-level fold of LinearOps
-      (`apply_ops`: Project=corgi `eval_graph`, Filter=corgi mask+`gather`, Negate=Rust;
-      EnterAt/LiftIter/FlatMap=todo!). `join` = `join_with_tactic`+`CorgiJoinTactic` → Vec-rows →
-      ToCorgi unary → `Collection<Time,CorgiContainer>`. **CorgiBackend now implements ALL
-      non-reduce operators (linear/arrange/join real); reduce/as_collection/inspect/leave_dynamic =
-      todo!.** Compiles.
-    - [ ] REMAINING for an end-to-end `render_tree::<CorgiBackend>` run (pre-reduce PLUMBING):
-      `leave_dynamic` (custom unary truncating `CorgiContainer.times`), a corgi `evaluate` harness
-      (mirror `vec.rs:182` — ingest/iterative/render_tree/leave/capture/convert), `as_collection`
-      (cursor-less, if exports hit it), + a test program. NOTE: this harness will integrate with
-      Frank's reduce design, so best coordinated with it.
-
-## ★ PERF (2026-07-01): END-TO-END corgi vs vec — nuanced; compute wins, arrange loses ★
-`examples/corgi_perf.rs` — `corgi::evaluate` vs `vec::evaluate`, median wall-clock, single worker,
-release. (Phase-1's 50–135× was EVAL-ONLY microbench; end-to-end the scalar eval is a small slice.)
-```
-scenario              n         vec        corgi      verdict
-linear-compute-8x     100k     157.6ms     48.6ms     corgi 3.2x FASTER   (8 wide maps, NO arrange)
-linear-compute-8x      20k      31.0ms      8.7ms     corgi 3.6x FASTER
-linear-heavy          100k     113.4ms    136.0ms     corgi 1.2x slower   (3 maps+filter+ARRANGE)
-linear-heavy           20k      21.4ms     23.3ms     corgi 1.1x slower
-reach                 4000      13.9ms     43.6ms     corgi 3.1x slower   (recursion: join+distinct)
-reach                 1000       3.6ms     11.6ms     corgi 3.2x slower
-reach                  200       0.86ms     2.0ms     corgi 2.4x slower
-```
-**Read:** (1) corgi's columnar scalar logic is a REAL end-to-end win (~3.2–3.6×) when scalar compute
-dominates and data stays columnar between ops (deep linear chain, no arrange) — even paying transcode
-in/out. (2) But the ARRANGEMENT machinery dominates real programs: add ONE arrange to the linear chain
-and the 3× win collapses to ~parity (the arrange is the swing factor — same chain, ±arrange). (3)
-Recursive/join-heavy programs are 2–3× SLOWER. WHY corgi loses on arrange-heavy/recursive:
-- **corgi's arrange is correctness-first, unoptimized:** `CorgiMerger` does the whole merge on the first
-  `work` call (no fuel/batching), the sort is a discrimination sort over corgi columns, and every merge
-  re-materializes columns via `gather_lanes`. DD's `ValSpine` (vec backend) is a mature fueled spine.
-- **join/reduce run ROW-WISE anyway:** the join tactic emits via `session.give` per row; reduce runs
-  the DDIR reducer in Rust over per-key slices + `active_times` OVER-derives interesting times. So corgi
-  pays transcode/untranscode at these boundaries with NO columnar compute win to offset it.
-- **eval isn't the bottleneck** in these programs (narrow rows, few arith ops/key), so accelerating it
-  (corgi's strength) barely moves end-to-end wall-clock, while the transcode tax is pure overhead.
-**Takeaway:** the corgi-as-scalar-logic thesis is validated where it should hold (compute-bound wide
-linear work: 3×+), but a corgi backend only beats vec end-to-end if the arrangement layer is also made
-competitive (fueled merge, keep join/reduce columnar) — otherwise arrange/transcode overhead dominates.
-Next perf levers, in impact order: fueled/batched `CorgiMerger`; columnar join emit (build corgi cols
-directly, skip `session.give` row round-trip); columnar reduce (avoid untranscode per key). ----
-
-## ★★★★ M5 DONE (2026-06-30): ALL 6 CANONICAL PROGRAMS RUN == vec (Sum rung landed) ★★★★
-binders now passes — columnar Variant (the Sum rung) is implemented. The corgi backend renders every
-canonical `.ddp` (`reach, scc, stable, unnest, adt, binders`) identically to vec. 32 interactive tests
-(+4 Sum round-trip), all 5 corgi dataflow examples, 27 corgi tests — all green.
-
-**The Sum rung (DDIR `Variant` ↔ corgi `Value::Sum`), all in `corgi_logic.rs`:**
-- `infer_shape_cols(rows)` — NEW all-rows column scan (vs `infer_shape`'s single sample): a `Variant`
-  column's `Shape::Sum` is the union of every arm that appears (a sample shows only one tag), so it
-  scans, building one lane per `0..=max_tag` (absent tag → `None` = ⊥). `from_updates` now uses it.
-- `transcode` `Sum` arm: per-row tag column + one packed lane per committed variant (its rows in row
-  order); `Value::sum_opt(tags, lanes)` derives each row's within-lane offset; absent arms stay ⊥.
-- `untranscode` `Sum` arm: untranscode each committed lane, then per row pull its payload from its lane
-  at the recorded OFFSET (robust to gather/merge reordering — not a sequential cursor). Uses the public
-  `Value::into_sum`/`sum_opt` — NO corgi mod needed (engine already had Sum gather/compare/merge).
-- transcode/untranscode are now TOTAL over `Shape` (Prim/Unit/Prod/List/Sum) — dead catch-alls removed.
-In binders the Sum column is created by the row-wise `key` Project (`Node(list ...)`) and consumed one
-op later by the row-wise `map`'s `case` (into_updates→ir::eval), so its full lifecycle is transcode+
-untranscode; merge/gather over Sum columns aren't exercised by these programs (corgi engine supports
-them, but that path is unverified here). `LiftIter` is implemented but untested (no program uses it).
-**No remaining backend todo!s; Variant no longer a gap.** ---- previous milestones below ----
-
-## ★★★ M4 (2026-06-30): REAL CANONICAL PROGRAMS RUN — 5/6 == vec backend ★★★
-All backend `todo!`s cleared; the corgi backend now runs real `.ddp` programs (incl. RECURSIVE ones)
-end-to-end and matches vec. `examples/corgi_progs.rs` (PROG=<name> or all) + `examples/corgi_reach.rs`:
-```
-reach   OK   (recursion: feedback var + join + distinct + concat + leave_dynamic)
-scc     OK   (recursion + enter_at + min + nested scopes + negate)
-stable  OK   (recursion + min + arrange)
-unnest  OK   (flatmap + collect: List round-trip through the relational layer)
-adt     OK   (con/case/Inject — variant is transient, eliminated within one ir::eval)
-binders FAIL (persists a Variant IN a collection → needs columnar Sum; the known "later rung")
-```
-**Backend todo!s cleared this milestone:**
-1. **`leave_dynamic`** — custom `OperatorBuilder` unary mirroring DD's `dynamic/mod.rs:40`: strips all
-   but `level-1` PointStamp coords from the capability AND each `CorgiContainer.times` entry; sets the
-   input connection summary `retain: Some(level-1)` so progress tracking stays correct. UNLOCKS all
-   recursive programs.
-2. **`EnterAt`/`LiftIter`/`FlatMap`** — correctness-first ROW-WISE path in `apply_ops` (untranscode →
-   vec-style transform → `from_updates`), parity with `backend::vec::render_linear`; `level` threaded
-   in. (Columnar fast-path is future; these are corner ops.)
-3. **Row-wise Project/Filter fallback** — `corgi_logic::compilable(term)` gates: terms the corgi
-   compiler can't lower (List, Case/Inject, Unary, Hash) fall back to `ir::eval` (parity with vec),
-   keeping the columnar fast-path for the common case. UNLOCKS unnest's `list(...)` projection + adt's
-   `case`. `untranscode` gained a `List` arm (inverse of transcode: ends + flat → per-row Lists).
-4. **Collect / as_collection / inspect** — already worked.
-
-**THE BIG BUG fixed en route (affected ALL unit-valued data):** the compiler emitted an empty tuple
-`Term::Tuple([])` (DDIR unit) as corgi `Prod([])` — an empty product with NO row-count witness — so
-any unit key/val silently produced ZERO rows downstream (`key($0[0];)`, `key(;)`, distinct/count
-outputs, concat of unit collections). Fix: `compile` emits `Op::Unit` over the anchor (a length-
-carrying `Unit` column) for an empty field list. This is why `reach`/`distinct` initially returned
-empty. NOTE: ill-typed CONCAT of heterogeneous val shapes (e.g. `Prod[Prim]` + `Unit`) still can't be
-columnar (vec tolerates it via dynamic typing); real programs keep concat operands shape-uniform.
-
-REMAINING (the Sum rung, clearly scoped, NOT a backend todo!): columnar Variant — `Shape::Sum` in
-`infer_shape`(needs to SCAN all rows for arms, not just sample row[0])/`transcode`/`untranscode`. corgi's
-engine already has Sum `gather`/`compare`/merge arms; only the DDIR transcode layer lacks them. Only
-`binders` needs it (persists a variant in a collection). `LiftIter` is implemented but untested (no
-canonical program uses it). ---- previous milestones below ----
-
-## ★★ M3 DONE (2026-06-30): END-TO-END render_tree::<CorgiBackend> == vec backend ★★
-A whole flat DDIR program runs through the corgi backend and matches the vec backend exactly:
-```
-let a = input 0 | key($0[0] ; $0[1]);
-let b = input 1 | key($0[0] ; $0[1]);
-let j = a | join(b, ($0 ; tuple($1, $2)));
-export "join" = j;  export "count" = j | count;  export "filtered" = j | filter($0 != 2);
-```
-`examples/corgi_program.rs`: `corgi::evaluate(&prog,&inputs) == vec::evaluate(&prog,&inputs)` for all
-three exports (join 3 rows, count 2 rows, filtered 3 rows). Exercises Linear (key/filter), join, AND
-reduce(count) composed via the real DDIR `render_tree` path. All 5 corgi examples + 28 interactive +
-27 corgi tests pass.
-
-**Three issues found & fixed making the end-to-end work (all in `corgi_logic.rs`/`corgi_arrange.rs`):**
-1. **`Spread` in projections** — DDIR's parser makes EVERY projection key/val a `Term::Tuple`, and a
-   bare `$n` field becomes `Term::Spread(Var n)` (flat-row splice). The map/filter-core compiler didn't
-   handle `Spread`. Fix: shape-directed compile — `compile`/`compile_projection`/`compile_predicate`/
-   `compile_join_projection` now take `env_shapes: &[Shape]`; the `Tuple` arm splices a `Spread`'s
-   `Prod` fields via `shape_of_place`. Tactics/`apply_ops` pass shapes from `shape_of_value` of the
-   actual columns (so the join tactic now holds key/val `Term`s and compiles per work-unit).
-2. **Empty-batch shape mismatch in `merge`** — `Batch::empty` carries a `Unit(0)` placeholder shape;
-   the spine merges empties with real batches → `gather_lanes`' cross-source shape check panicked. Fix:
-   substitute the non-empty side's `kv` for any empty source (never indexed, since no tag points to it).
-3. **Cross-shape `Eq`/`Ne`** — `filter($0 != 2)` compares the 1-tuple key (`Prod[Prim]`) to `Int 2`
-   (`Prim`); vec does structural `Value` compare (always-unequal), but corgi's `CmpOp::Rel` needs equal
-   shapes. Fix: `infer_term_shape` + fold cross-shape `Eq`→0 / `Ne`→1 to a constant column.
-
-NOTE: keys/vals are ALWAYS tuples (`Prod`) in real DDIR programs (parser wraps every projection field
-list in `Term::Tuple`). The earlier hand-built examples used scalar keys; the backend handles both.
-Remaining backend `todo!`: `leave_dynamic` (only needed for SUB-SCOPE/iterative programs — flat
-programs never reach it), and `EnterAt`/`LiftIter`/`FlatMap` linear ops + `Collect` reducer + Variant.
-
-## ★ PHASE 2 STATUS (2026-06-29): corgi backend — operators LIVE except reduce ★
-Built & tested, all over corgi-native storage + `eval_graph` compute, cursor-less (Route B):
-- **Linear** — corgi-native container + map/filter in a real dataflow, no inter-op transcode (M1).
-- **arrange** — `arrange_core` → `Spine<Rc<CorgiBatch>>` (CorgiBatch: BatchReader/Batch/Merger/Builder;
-  merge 300-case property test; reused `MergeBatcher`; one rows→corgi transcode at ingest-boundary).
-- **join** — `CorgiJoinTactic` + `join_with_tactic`, LIVE in a real dataflow == reference (incl.
-  retraction); merge-join + cross-product + projection all over corgi columns via the #771–773 seam.
-- **reduce** — ✅ **DONE (cursor-less, live)** via Frank's `active_times`: `CorgiReduceTactic`
-  (`src/corgi_reduce.rs`) + `reduce_with_tactic`, wired in `Backend::reduce`. retire = per changed
-  key → `active_times` (over-deriving join-closure) → at each active time accumulate input-as-of-t,
-  run the reducer (Rust DDIR reducers, matching vec), diff vs (output + emitted-so-far), route to
-  held buckets; pended→held frontier. Test `examples/corgi_reduce_dataflow.rs`: directed Count
-  (retraction-to-zero) + **120 randomized Count == reference** + Min/Distinct (min changes under
-  retraction). Needed a 1-line corgi mod: `Unit` arm in `compare_idx` (Distinct's unit payload).
-- corgi light mod: `corgi::arrange::{gather, gather_lanes, compare_at}` (branch `dd-arrange-api`; 45 tests pass).
-Verdict: Route B (cursor-less corgi batch + custom tactics) is VALIDATED for **all four operators —
-Linear, arrange, join, AND reduce** — each live in a real dataflow over corgi-native storage via the
-#771–773 seam, tested vs reference. `Backend for CorgiBackend` implements linear/arrange/join/reduce
-(as_collection/inspect/leave_dynamic still todo!, only needed for an end-to-end render_tree harness).
-Files: `interactive/src/corgi_{logic,backend,arrange,join,reduce}.rs` + `backend/corgi.rs`; corgi
-mods on branch `dd-arrange-api` (`arrange` facade + `compare_idx` Unit arm).
-
-### M2(b) FORK — the incremental arrangement (the big build); routes:
-- **Route A (Chunk trait, à la `chunk/vec.rs`):** impl `Chunk` over corgi columns → free
-  Batcher/Builder/Spine + reuses DD's fueled merge/advance/settle harness. BUT requires a `Cursor`
-  (Navigable), and `Cursor`'s assoc types are `BatchContainer`/`Layout`-bound (`chunk/vec.rs` leans
-  entirely on `Vector<((K,V),T,R)>`). corgi columns are NOT `BatchContainer`s → heavy glue
-  (impl BatchContainer for corgi leaves, or store a parallel DD-container copy for navigation).
-- **Route B (cursor-less, the #771–773 seam):** corgi batch = `BatchReader` only (len/description,
-  NO Cursor) + a custom `ReduceTactic`/`JoinTactic` that reads corgi columns in BULK (eval_graph,
-  GroupKey) + `Batch`/`Merger` over corgi columns (merge/advance via corgi sort). Avoids the
-  BatchContainer glue entirely (plays to corgi's bulk nature) BUT reimplements the incremental
-  merge/advance + the tactic defer/work/retire protocols.
-- Both are large + intricate (fueled merge, frontier/capability mgmt) — the high-risk core where
-  Frank's review matters. Recommendation: **Route B** (genuine use of the cursor-less tactic seam;
-  corgi is bulk-columnar, not step-navigated; sidesteps the Cursor↔BatchContainer impedance).
-  Trade: reimplement incremental merge vs fight the container glue. Awaiting Frank's routing.
-
-### RUNG 4 RESULTS (chain of K Linear `x->x+c` ops, n=100k, ns/row over whole chain)
-| K | interp | per-op xcode | columnar | col vs interp | col vs per-op |
-|---|---|---|---|---|---|
-| 1 | 25.7 | 5.8 | 2.9 | 9.0× | 2.0× |
-| 4 | 75.0 | 14.2 | 5.0 | 15.1× | 2.9× |
-| 16 | 282.9 | 44.8 | 12.6 | 22.5× | 3.6× |
-
-**Conclusion:** columnar ≈ `2·xcode + K·eval` (flat-ish); per-op ≈ `K·(2·xcode + eval)`; interp
-steepest. So the **deeper the program, the bigger the corgi win**, and storing data corgi-columnar
-(amortizing transcode across ops) beats per-op transcode 2–3.6× and widening. Strong case for a
-corgi-data CHUNK/container once the scalar-logic path exists.
-
-### ARCHITECTURE FINDING — where corgi-columnar data should live
-- The `Chunk` trait (arrangement storage, #744) **requires `Navigable<Cursor: Cursor>`**
-  (`trace/chunk/mod.rs:73`). So a corgi-columnar *arrangement via `Chunk`* must still implement a
-  cursor — it is NOT the "cursor-less batch." Route A (via `Chunk`): write a corgi cursor + the 5
-  chunk ops (merge/extract/advance/settle/bounds), get Batcher/Builder/Spine free; add a bulk
-  columnar accessor for the corgi fast path. Most reuse; you write a cursor.
-- The genuinely **cursor-less** path is the operator layer (#771–773): `join_with_tactic`/
-  `reduce_with_tactic` need only `BatchReader` (`len`/`description`), not `Navigable`. Route B: a
-  corgi container holding columns + `Batch`/`Merger` over corgi's own sort/merge + a custom tactic
-  that bulk-applies corgi. Maximal "no cursor"; you reimplement merge/advance + the tactic.
-- For Frank's stated goal (corgi = the *scalar logic*, not the navigator), neither is needed to
-  START: rungs 1–3 run over ANY existing arrangement via per-call transcode. corgi-columnar storage
-  (A or B) is the *optimization* that removes the transcode the rung-4 bench shows dominates.
-- Rung 3 (reduce) DEPRIORITIZED: the reduce closure already receives a per-key column slice
-  `&[(val,diff)]` (`reduce.rs:651`), so corgi-as-reducer is the *same* mechanism proven in rungs
-  1–2; building it adds marginal evidence vs the CHUNK question Frank explicitly asked.
-
-### RUNG 1 RESULTS (release, non-negative ints, rows = Tuple([a,b]))
-| metric | map (a+b, a*3) | filter (a<b) |
-|---|---|---|
-| crossover (corgi eval beats interp) | ~10 rows | ~10 rows |
-| corgi eval-only peak speedup | **79× @10k** | **135× @100k** |
-| corgi eval ns/row (≥1k) | 0.8–1.6 | 0.3–0.6 |
-| interp ns/row | 61–73 | 37–40 |
-| **with per-call transcode** | 6–11× | 4–7× |
-| transcode share of corgi-total @1M | ~85% (1.6 vs 12 ns/row) | ~95% (0.6 vs 10.6) |
-
-**Conclusions (measured):**
-1. corgi-as-columnar-scalar-logic is a **large win** — 50–135× on eval past the ~10-row crossover.
-   Any real batch (100s–1000s of rows) is far past crossover. Below ~10 rows corgi loses to
-   `eval_graph` per-call setup (n=1: 0.23–0.27×).
-2. **The transcode (`&[ir::Value]`→corgi columns) dominates** the corgi-as-closure model — ~10
-   ns/row, ~85–95% of total at scale. So in the naive per-call-transcode form the win is capped at
-   ~4–11×. **To unlock the full 50–135×, data must already be corgi-columnar → motivates the
-   corgi-data CHUNK (rung 4); the per-call transcode is exactly what storing columns removes.**
-3. Compile is direct: the map/filter core is ~1:1 onto corgi ops; `infer_shape` handles the
-   dynamic typing (Shape from data). No corgi modification needed for this subset.
-
-### Open questions
-1. ~~Crossover width~~ → ~10 rows. (ANSWERED)
-2. ~~Transcode cost~~ → dominates (~85–95% at scale). (ANSWERED — drives rung-4 case)
-3. How rich a `Term` subset for real programs (datalog/eqsat need Variant/List/Fold/Hash)? (OPEN)
-4. Does it run inside a real DD dataflow, and does corgi-columnar storage actually remove the
-   transcode in that setting? (rung 2 → rung 4)
-
----
-
-## ★ CHUNK BACKEND + TRANSCODE REMOVAL + BOUNDARY MODEL (2026-07-02)
-
-Branch `corgi-chunk` off `master-next` (has #778 Chunk/NavigableChunk split). corgi on
-`dd-arrange-api`. Both pushed to frankmcsherry forks. Correctness gate: `corgi_progs` (all 6
-canonical programs vs `vec`) after EVERY change; `corgi_scorecard` = per-operator triage.
-
-### Result — measured, per operator (corgi/vec, scorecard)
-`CorgiChunk: Chunk` (cursor-less) is the arrangement; the fueled `ChunkBatchMerger` comes free.
-Removing the columns↔rows transcode boundaries (they were self-inflicted, not inherent):
-- `as_collection` reads chunk columns straight into a CorgiContainer (no untranscode).
-- join emits corgi columns via `give_container` into a `CapacityContainerBuilder<CorgiContainer>`
-  (no untranscode + per-row give + re-transcode; no `JoinToCorgi` unary).
-- arrange ingest: `CorgiChunker` sort-consolidates each input container's columns directly into
-  CorgiChunks (replacing `ContainerChunker`'s drain-to-rows), ACCUMULATING to TARGET so it emits
-  few large chunks (else columnar per-chunk set-up dominates on many small batches).
-
-| operator | before | after |
-|---|---|---|
-| map8 / filter (no arrange) | 0.30x / 0.75x | unchanged — columnar eval wins |
-| arrange | 1.5x | 0.90x (BEATS vec) |
-| join | 1.5x | 0.70x (BEATS vec) |
-| reduce_distinct/count | 2.0x | 1.30-1.35x (reduce still row-wise) |
-| reach | 1.9x | 1.45x |
-
-Thesis validated: vec spends ~22% of reach in `Value::cmp`/`partial_cmp` (pointer-chasing nested
-enums); corgi ~5% (columnar `compare_idx`). corgi beats vec wherever it stays columnar; it only
-loses where it drops back to `Value` rows — now just the reduce.
-
-### Multi-record primitives exposed in corgi `arrange` (dd-arrange-api)
-`sort_perm` (discrimination argsort), `compare_idx` (batched compare), `find_ranges` (single-row
-`find` = equal-range probe → multi-record merge-join/semijoin). Fixed a real corgi bug:
-`Reduce(Red::Add)` used checked `.sum()` while its Scan sibling wraps — made it wrapping so raw
-two's-complement diff sums are correct.
-
-### Reduce: proven building blocks, NOT yet wired (row-wise reduce still runs)
-- `columnar_sum_by_key` (Count) and `columnar_distinct_keys` (two-level (key,val) consolidate) —
-  pure corgi ML (`group -> map(fold_add) -> filter`) via `parse_ml`+`eval_graph`, tested.
-- Count fast-path landed (skip needless per-value consolidation): reduce_count 1.39x->1.30x.
-- Diffs cross as RAW two's-complement u64 bits (`ne 0` drop = sign-agnostic). "present" simplified
-  to net!=0 (ignore signed sign) -> keeps everything on the raw-bit path, no signed encoding yet.
-- `group_offsets(key_col) -> (perm, ends)` — integers-only boundary primitive, tested.
-
-### ★ DESIGN CAPTURE — a data-blind reduce tactic (the reusable DD asset)
-A framework that presents outward as (int-id, time, diff) can supply a reduce tactic that owns ALL
-the time navigation, backend-agnostic. Only integers cross the boundary; the value never becomes a
-`Value` in DD.
-
-Tactic (DD) owns — the hard part, written once: interesting-times (`active_times`), wave/interval
-navigation, per-(key,interesting-time) delta (desired vs current output), `pending`, held
-capabilities, output-trace maintenance — all over `(key-id: u64, val-id: u64, time: T, diff: R)`.
-
-Backend (corgi) supplies:
-1. present-as-ints (input): each record -> (key-id, val-id) as u64 hashes; times/diffs DD-native.
-2. value callback (consolidate): given input record indices (a key's rows <= t), return reduced
-   output as `[(out-val-id, diff)]` — backend runs its columnar value logic. Reducer semantics live
-   here. (`group_offsets` + `gather` + the consolidate blocks are the pieces.)
-3. mint output ids: Min/Distinct REUSE ids (min = an input val-id; distinct = the unit-id) — easy.
-   Count/Collect create NEW objects -> mint an id. HASHING is the id function: same output value ->
-   same id, globally consistent across the output->input boundary (a reduce output is a downstream
-   input). Collisions = accepted risk. This is why ids should be HASHES not per-batch indices —
-   indices are stable only within a batch; hashes are stable everywhere without a registry.
-4. materialize (egress): id -> value to build the output arrangement (or build it columnar by id).
-
-The one structural cost: cross-retire `pending` must be keyed by the stable hash-id, not a
-per-retire group index — this ripples through the delta logic, so the columnar reduce is a REDESIGN
-of `retire` into id/hash space, not a patch. Also carries the workload trade-off: columnar
-consolidate wins on wide/batch reduction but must PRESERVE the changed-key restriction (columnar
-semijoin) so small-delta recursion (reach) doesn't regress to O(accumulated x rounds).
-
-Next effort (well-scoped, primitives ready): rewrite `retire` in id/hash space — read changed keys'
-input as columns, `group_offsets` -> per-group `active_times` -> per (group,wave-time) hand corgi
-the include-index list -> consolidate -> delta/emit keyed by hash -> columnar output.
-
-## ★ INT-PROXY FRAMEWORK LANDED UPSTREAM; CORGI-BACKEND HAND-OFF (2026-07-03)
-
-The boundary model above is now a complete, tested framework in the DD crate — PR #781
-(`frankmcsherry/differential-dataflow@int-proxy`, ~3k lines, unmerged/settling; this branch is
-rebased onto it). It is corgi-free by construction; corgi is its first real backend. READ ORDER:
-`operators/int_proxy/mod.rs` (the boundary contract + design notes), then `reduce.rs` / `join.rs`
-(backend traits + tactics), `reference.rs` (the in-memory backend to mimic), `trace/chunk/
-int_proxy.rs` (ProxyChunk), `tests/int_proxy.rs` (the assessment harness).
-
-### What the framework is (names changed from the earlier note: ids -> int_proxy, Id* -> Proxy*)
-- `ProxyChunk<T,R>`: sorted, consolidated `((key_hash, value_id), time, diff)` columns; a #778
-  `Chunk` (not Navigable). `from_unsorted` = int sort+consolidate returning REPRESENTATIVE
-  PROVENANCE (sorted-run index -> original record) — the alignment a backend keeps.
-- `ProxyReduceBackend` (reduce.rs): `key_hashes` (delta scan), `present_input(history, novel,
-  changed-keys filter)`, `present_output(batches, filter)`, `reduce`/`reduce_many`, `materialize`.
-  The tactic makes ONE `reduce_many` crossing PER RETIRE: every `(key, interesting time)` moment is
-  a bracket (group_offsets-shaped `ends`; keys repeat, one bracket per moment; brackets non-empty).
-  Desired outputs depend only on input accumulations, so no time ordering constrains the batch —
-  the order-sensitive delta bookkeeping stays in the tactic. THIS is corgi's crossing: override
-  `reduce_many`, run the columnar consolidate blocks over all brackets at once.
-- `ProxyJoinBackend` (join.rs): `present0/present1(batches, filter)` + `cross(matched index
-  lists, times, diffs)`. The tactic presents the FRESH side first and passes its key hashes as the
-  accumulated side's filter — the join analogue of the changed-key restriction (interface-level;
-  without it any backend is forced O(trace) per fresh batch).
-- Contracts: `key_hash` = stable pure function of the key, backend-wide (pending + changed-key
-  filter + join sides rely on it). `value_id` = per-computation bijection with value equality ONLY
-  (never outlives a join unit / one retire; `materialize` resolves ids before anything escapes).
-  Hashing is one scheme, not a requirement — exact per-retire registries are collision-free and
-  valid. corgi: `corgi::hash` (#6, on master; WIDTH-BLIND unsigned — keep signed/float widths
-  consistent across join inputs and output→input) serves both, or exact ids via `group_offsets`.
-- The tactics carry the row operators' history-replay machinery in id space (`history.rs`:
-  IdHistory = ValueHistory with u64 values; reduce discovery ports `history_replay::compute`;
-  join ports `JoinThinker::think`) — the row suite's `reduce_scaling`/`join_scaling` shapes are
-  linear (tests `proxy_*_scaling` pin it). Interesting-time discovery is LAZY now (no explicit
-  `active_times` closure).
-
-### Assessment harness to reuse (tests/int_proxy.rs) — corgi should replicate the middle layer
-1. Tactic alone: identity backend + 300-case Product-grid brute-force oracle (no values, no hash).
-2. Backend contract: reference backend vs the ROW operators (join; count/distinct/min reduces;
-   scripted Product-time pending test) — the corgi backend replaces this layer 1:1.
-3. Asymptotics: counting-wrapper gates (presented records must be delta-proportional; single-key
-   rounds vs a 20k-key trace) + scaling shapes + the `--ignored` wall-clock bench (steady state:
-   reduce ~1.4x row, join ~1.0x; bulk load 2-4.5x = the per-row presentation constants corgi's
-   columnar primitives exist to beat).
-
-### The corgi backend plan (reduce first; keep CorgiJoinTactic — it already beats vec)
-- `present_input/present_output`: flatten via existing `merge_chains`/`flatten_batches` machinery
-  restricted to changed keys by `find_ranges` SEMIJOIN (never scan-and-filter: the reference
-  backend's seek-based presents are the model; a scan re-imports O(trace) per retire), then
-  `corgi::hash` the key/val columns, `ProxyChunk::from_unsorted`, keep the reps vec + gathered
-  real columns as alignment.
-- `reduce_many` override: ONE crossing — gather the brackets' value rows by rep index
-  (`gather_lanes`), run the columnar consolidate/Count/Distinct blocks across all brackets
-  (`group_offsets` shape matches `ends` by design), mint output ids by `corgi::hash` of the
-  produced column, record id→value.
-- `materialize`: build output key/val columns from id→value, order by corgi structural order
-  (`sort_perm`), emit CorgiChunk batches in TARGET-SIZED chunks (a single giant chunk makes
-  `settle`'s split path quadratic — reference.rs learned this the hard way; also consider fixing
-  `VecChunk::settle`'s split upstream).
-- Swap `CorgiReduceTactic` -> `ProxyReduceTactic<corgi backend>`; delete the row-wise retire.
-- Traps already hit once, don't repeat: capacity leaks in per-retire maps (shrink or rebuild —
-  `retain`/`clear` keep the table); presenting by scan instead of seek; giant-chunk settle.
-- Gate `cargo run --release -p interactive --example corgi_progs` after EVERY change (scc is the
-  sharp case; the empty-frontier downgrade is already in the tactic). `corgi_scorecard` for the
-  perf verdict: the target is closing reduce's 1.3x vs vec.
-
-### Suitability review (the point of the hand-off): confirm or disconfirm, from corgi's seat
-- Does `present` map cheaply onto corgi columns (hash op + find_ranges + gather + from_unsorted)?
-- Does the `reduce_many` bracket shape line up with `group_offsets`/the consolidate ML blocks?
-- Is the per-record `(rep, diff)` entry list the right currency, or does corgi want columnar
-  (vid-run) brackets? Interface pressure flows back to #781 as evidence, not as corgi types.
-- Diffs cross as DD-native `R` here (not raw u64 bits) — reconcile with the raw-bits convention
-  inside corgi's blocks at corgi's own boundary.
diff --git a/corgi-kernel-findings-scc.md b/corgi-kernel-findings-scc.md
deleted file mode 100644
index 586c5ab79..000000000
--- a/corgi-kernel-findings-scc.md
+++ /dev/null
@@ -1,120 +0,0 @@
-# Corgi kernel findings — SCC on the DDIR corgi backend (2026-07-11)
-
-Profile-grounded asks for the corgi kernel, from an `samply` capture of `interactive`'s SCC
-(`corgi_scc_prof`, N=1000, ITERS=200, corgi backend, baseline `corgi-on-mn @ 8681e193`, arm64).
-19,537 samples @ 1kHz. The corgi backend is a cursor-less `Chunk` arrangement: keys/vals are corgi
-`Value` columns (`Prod([keys, vals])`), and merge/advance/sort drive ordering through corgi's
-structural-compare + discrimination-sort kernels.
-
-**Headline:** on SCC (corgi's worst case — control-heavy, compute-light, tiny integer keys, unit
-values), the dominant *corgi* cost is **structural comparison + discrimination sort**, not compute
-and not (as I'd earlier guessed) column allocation. Numbers below are the honest split.
-
----
-
-## 1. Structural compare / discrimination sort — the big corgi lever (~20% of total)
-
-| corgi fn | self % | total % | driven from |
-|---|---|---|---|
-| `ops::cmp::order::compare::compare_idx` | 4.0 | **14.7** | `CorgiChunk::merge` (merge_batcher) + `CorgiChunk::advance` (spine compaction) |
-| `ops::cmp::order::discriminate::sort_blocks` | 0.1 | 6.0 | `sort_consolidate` → `sort_perm` |
-| `ops::cmp::order::discriminate::sort_leaf_blocks` | 3.2 | 5.4 | (under `sort_blocks`) |
-| `value::Prim::cmp_idx` | 1.4 | 3.2 | (leaf under `compare_idx`) |
-| `ops::cmp::CmpOp::eval` | 1.4 | 3.5 | |
-
-Call context (from stacks): `compare_idx` is almost entirely **arrangement maintenance** —
-`CorgiChunk::merge` (the two-pointer merge's per-pair `(key,val)` compare) and `CorgiChunk::advance`
-(the compaction's group-boundary scan). It **recurses through the `Prod([key,val])` structure per
-comparison** (`compare_idx → compare_idx → Prim::cmp_idx`), i.e. it re-walks the product shape and
-re-dispatches to the leaf on every comparison. For SCC the keys are a single `Prim(64)` (a graph
-node id), so this is a lot of shape-walking to reach one `u64` compare.
-
-**Ask — radix / flat sort-key at the leaves.** This is the known "compare_idx interpreted-comparison
-tax" axis. Precompute a **flat, radix-friendly sort-key column once** per chunk (or expose a kernel
-that does), so that:
-- merge run-head compares read a `u64`/byte directly instead of re-walking `Prod` + dispatching per
-  comparison, and
-- `from_unsorted` / `sort_perm` can **radix-sort** (O(n), skip comparison) instead of
-  comparison-sort (`sort_leaf_blocks` + `compare_idx`).
-
-For primitive keys this could go from ~20% to near-nothing (a `u64` radix), and it's a general win
-(not SCC-specific): every arrangement merge/consolidate in every DDIR program pays this tax. The
-backend already leans on `compare_idx`/`sort_perm`/`sort_blocks` as the ordering primitives, so a
-flat-sort-key variant (or a `radix_sort_perm(col) -> perm` + `compare_prekey(prekey, ia, ib)`)
-slots in without a backend redesign.
-
-**Confirmed to GROW with scale (N=100000 profile, /tmp/scc_corgi_bigN.json.gz, 42.8k samples):**
-`compare_idx` rises **14.7% → 21.9%** total (5.2% self), now driven overwhelmingly by
-**`CorgiChunk::merge` = 22% total** (the arrangement merge, which was not even top-10 at N=1000).
-`sort_leaf_blocks` 5.4% → 6.3%. So the structural-order machinery is ~28% of total at N=100k and
-climbing — this is *the* corgi lever, and it gets bigger at the sizes Frank actually runs (n=1m).
-
-## 2. Column re-gather — real but smaller (~4–5% of total)
-
-| corgi fn | self % | total % |
-|---|---|---|
-| `engine::gather_lanes` | 0.1 | 3.0 |
-| `value::Prim::gather_lanes` | 1.0 | 1.3 |
-| `engine::gather` / `Prim::gather` | 0.5 | 0.6 |
-
-Every `merge`/`advance`/`present`/`settle` builds a **new** column via `gather`/`gather_lanes`
-(fresh `Arc<Vec>`), re-materializing the repeated key column. This is the "flat SoA re-gathered per
-merge" axis. It's a smaller bucket than I'd initially estimated — **not** the dominant allocation
-(see the correction below) — but it's pure churn: the merge output's key column is a permutation/
-concatenation of inputs we already hold.
-
-**Ask (secondary):** cheap column *views*/*slices* and/or in-place gather, so the merge/advance
-paths can reorder/concatenate without allocating a fresh backing `Vec` each time. Lower priority
-than (1).
-
-## Allocation attribution (malloc ≈ 43% of samples)
-
-An earlier note of mine attributed ~32% of runtime to "corgi column churn." **The profile does not
-support that** — corgi's own `gather*` is only ~4–5%. The `malloc` is not diffuse once attributed;
-it's a handful of identifiable sites (percentages are *total* samples; they overlap in their
-descendant `malloc`, so they don't sum to 43%):
-
-| allocating site | total % | owner | notes |
-|---|---|---|---|
-| `SmallVec::extend` (PointStamp materialization) | 10.7 | backend/framework | timestamps; partly addressed by `ColTimes`, rest is reduce/compaction |
-| `corgi_chunk::sort_consolidate` | 7.7 | **backend (ours)** | fresh perm + reordered `times_s`/`diffs_s`/`keep` per consolidate; **same code that pays item-1 compare/sort CPU** |
-| `consolidate_updates_slice_slow` (reduce **bridge**) | 7.7 | **tactic-facing** | the `Vec<((u64,u64),T,R)>` consolidation — replaced by the columnar `ProxyBridgeBuilder`/`from_unsorted` |
-| `ValueHistory::build` (replay) | 3.4 | **tactic** | columnarized in `fm/int-proxy-columnar` `history.rs` |
-| `gather` / `gather_lanes` (corgi columns) | ~4–5 | **corgi** | item 2 above |
-| `register_keys`/`register_vals` + hashbrown rehash | <1 | backend | IdMaps |
-
-`RawVec::finish_grow` (6.8%) + `grow_one` (5.9%) are the `malloc`-under-Vec-growth *inside* the rows
-above, not a separate bucket.
-
-**Reading for each owner:**
-- **corgi:** biggest lever is compare/sort CPU (item 1), not allocation (gather is ~4–5%). A radix
-  sort-key (item 1) also removes `sort_consolidate`'s permutation allocation — the one place the
-  corgi ask and a backend cleanup compound.
-- **tactic (int_proxy):** the reduce-bridge `consolidate_updates` (7.7%) and `ValueHistory` (3.4%)
-  are *exactly* what the columnar bridge (`fm/int-proxy-columnar`) already targets. Nothing new to
-  build — but the payoff is **N- and workload-dependent**: at N=1000 (this profile) they're ~11%
-  combined; at large N the arrangement dominates and they shrink; on shallow-time programs the
-  columnar machinery's overhead outweighs the alloc removed. A shallow-time fast-path is the open
-  item there. **Confirmed at N=100000:** the bridge `consolidate_updates` shrinks 7.7% → 5.4% and
-  `ValueHistory::build` 3.4% → 1.9% (combined 11% → 7.3%) as the arrangement merge (22%) takes over
-  — so the columnar bridge's payoff genuinely fades with scale, and a shallow-time fast-path (not
-  more columnar machinery) is the right investment for the tactic. Also new at scale:
-  `collect_present` (OUR reduce present's changed-key scan over accumulated history) rises to 10.8%
-  total / **8.3% self** — a backend O(history) semijoin cost worth its own look.
-- **backend (ours):** `sort_consolidate` (7.7%) is ours to cut via buffer reuse (and it rides the
-  corgi radix-key win).
-
-## What NOT to change (backend-side, not corgi's problem)
-
-- Timestamp materialization (`PointStamp` `try_grow`, ~11%) is the DDIR backend's job — already
-  partly addressed by columnar times (`ColTimes`), the rest is reduce-tactic/compaction work.
-- `CorgiChunk::advance` (13.3% total) and the reduce `retire` (50% total) are backend/framework;
-  corgi appears inside them only via items 1 & 2 above.
-
-## Reference
-
-- Backend: `interactive/src/corgi_chunk.rs` (merge/advance/sort_consolidate — the `compare_idx` /
-  `sort_perm` callers), `interactive/src/corgi_reduce_backend.rs`.
-- Kernels of interest: `compare_idx`, `sort_perm`, `sort_blocks`, `sort_leaf_blocks`, `gather`,
-  `gather_lanes` in the corgi crate.
-- Profile: `/tmp/scc_corgi.json.gz` (Firefox format; `samply load` or pollard).
diff --git a/int-proxy-columnar-findings.md b/int-proxy-columnar-findings.md
deleted file mode 100644
index f32e85cf8..000000000
--- a/int-proxy-columnar-findings.md
+++ /dev/null
@@ -1,123 +0,0 @@
-# A columnar backend on `int_proxy`: validation + gaps
-
-A field report from wiring a **dynamic-shape columnar backend** (corgi) into the `int_proxy`
-reduce/join framework. Two audiences: (1) reviewers of the `int_proxy` PR, who get a second,
-independent consumer that validates the trait surface and drove a correctness fix; (2) anyone
-thinking about columnar / non-`Ord`-keyed storage in differential, who gets a concrete map of
-what the framework already gives and what it's missing.
-
-## The pieces
-
-| Layer | Location |
-|---|---|
-| `int_proxy` framework (reduce/join over `(key_hash, value_id)`) | `TimelyDataflow/differential-dataflow#781` |
-| corgi DDIR backend (the consumer; `interactive` crate, `SPIKE.md`, benches) | `frankmcsherry/differential-dataflow @ corgi-chunk` |
-| corgi kernel crate (the `arrange` API: `find_ranges`, `sort_blocks`, content-hash, …) | `frankmcsherry/wip @ dd-arrange-api` |
-
-The DD-core work is #781; the corgi backend stacked on top lives entirely in the `interactive`
-crate. One caveat for reviewers: `corgi-chunk` currently carries **~148 lines of framework
-improvements ahead of #781** — an MSD-bucket sort in `ProxyChunk::from_unsorted`, reduce
-buffer-reuse, and test extensions — that were developed against the backend and should be pushed
-back onto the `int-proxy` branch so the PR carries its own improvements. So diff `pr781..corgi-chunk`
-for the true backend delta, but don't assume the DD subtree equals the PR verbatim.
-
-## Why `int_proxy` is the right (and only) extension point here
-
-DD's native operators (`reduce_abelian`, `join_core`) are monomorphized over **static** key/value
-types: the cursor yields `&K`/`&V`, the reduce closure is `Fn(&K, &[(&V, R)], …)`. corgi has no
-such types — keys and values are `corgi::Value`, a **runtime** shape (`corgi::Shape`) determined
-by the DDIR program, stored columnar (`Prim = Arc<Vec<uN>>`). There is no compile-time `K`/`V`.
-
-`int_proxy` is the bridge: it runs reduce/join over `(key_hash: u64, value_id: u64)` integer
-proxies, so the *framework* never needs the key/value types, and the *backend* owns the
-dynamic-shape materialization behind the proxies. This is the essential **static-vs-dynamic
-columnar-shape divide** — `columnar/`/`ColChunk` serve compile-time shapes; a corgi-style backend
-serves runtime shapes; `int_proxy` connects them. Native cursor tactics are structurally
-unavailable to such a backend, which is exactly the gap `int_proxy` fills.
-
-## What got validated
-
-- All 6 canonical DDIR programs (map/filter/join/reduce/distinct/nested-recursion) match the
-  vec backend exactly, including **SCC** — the sharp case for interesting-times.
-- The corgi backend surfaced and drove the **`seed_times` correctness fix**: seed interesting
-  times from the *batch's own support*, not the consolidated/merged view. Accumulation-preserving
-  compaction can advance a stored record onto a novel retraction's exact time and cancel it in the
-  merged view, erasing a seed the reduce needed. Formalized in Lean (`Model.lean`,
-  `scenario1_cancels`, `seedSet = support ∪ pending`). This is a framework-level result #781 now
-  carries — a second backend independently exercised the interesting-times machinery hard enough
-  to find it.
-
-## Empirical findings (SCC, `e = 2n`, single worker, from-scratch to fixpoint)
-
-Three-way: hand-written native DD `strongly_connected` vs DDIR-vec vs DDIR-corgi (identical graph).
-
-| n | native | DDIR-vec | DDIR-corgi | corgi/vec |
-|---|---|---|---|---|
-| 1,000 | 26 ms | 37 ms | 83 ms | 2.24× |
-| 100,000 | 4.00 s | 2.92 s | 7.18 s | 2.46× |
-| 500,000 | 25.9 s | 20.3 s | 52.5 s | 2.59× |
-| 1,000,000 | 56.2 s | 44.5 s | 112.8 s | 2.54× |
-
-corgi holds a flat ~2.5× vs vec to 1M (no superlinear blow-up). Two apples-to-apples notes:
-
-- **DDIR-vec beats native above ~10k nodes** (0.7–0.8× native). The DDIR SCC uses
-  `enter_at($1[0])` — log-bucketed prioritized iteration (`256·(64−leading_zeros)`); native
-  `strongly_connected` uses plain `propagate` (all labels at inner round 0). So the `native`
-  column runs a *less prioritized algorithm* and is only a loose reference; **corgi-vs-vec is the
-  fair comparison** (identical DDIR program).
-- On linear/map-heavy programs corgi is **3× faster** than vec (columnar `eval_graph` vs per-tuple
-  `ir::eval`). SCC is corgi's *worst* case — control-heavy, compute-light.
-
-### Where the 2.5× goes (self-time, SCC n=800, both backends 200 identical iters → samples comparable)
-
-| bucket | DDIR-vec | DDIR-corgi |
-|---|---|---|
-| comparison / ordering | ~515 samples | ~600 |
-| framework + glue | ~925 | ~1,020 |
-| **allocation** (malloc + SmallVec + raw_vec) | **~700** | **~2,900** |
-| total | 3,703 | 7,923 (2.14×) |
-
-**The entire gap is allocation.** Comparison is a tie (vec's single biggest cost is compiled
-`Value::cmp`, 13%; corgi's structural `compare_idx` is comparable). Framework is a tie —
-`int_proxy` costs corgi nothing over DD's native cursor reduce. corgi's engine kernels are only
-~16% self; the `interactive` glue ~3.4% self.
-
-The allocation is **not** the value columns — those are already columnar (`Prim = Arc<Vec>`,
-refcount clones). It's the **per-row timestamp**: `times: Vec<Product<u64, PointStamp<u64>>>`,
-where `PointStamp` is a per-row heap `SmallVec` (spills under nested scopes), cloned on every merge
-`emit`/`to_vec` and allocated on every lattice `Product::join`.
-
-## What the framework is "missing" for columnar backends
-
-1. **A columnar `Time`/`Diff` container path a dynamic-shape backend can reuse.** DD's own
-   `columnar/` module already has it: `ColChunk`/`UpdatesTyped` store `times: Lists<ContainerOf<Time>>`,
-   and `Time = Product<u64, PointStamp<u64>>` derives `Columnar`, so the time column is SoA (outer
-   `u64` column + inner `Vecs` = flat coords + bounds) — **the per-row `PointStamp` heap object
-   never arises**. The catch: `ColChunk<U>` requires `U: ColumnarUpdate` = *static* `(K,V,T,R)`, so
-   a dynamic-shape backend can't adopt it wholesale for keys/vals. The reusable piece is the
-   `Time`/`Diff` container specifically. Making that path usable independent of static key/value
-   types would delete the single largest cost (the ~37% bucket) for any such backend.
-
-2. **Hash-ordered comparison + O(1) probe (optional).** Since `int_proxy` already keys on
-   `key_hash`, comparisons could be `u64`-hash rather than structural, and a Robin-Hood table
-   sorted by hash with a rank/select side index gives sorted + immutable + mergeable + **O(1)
-   lookup** — attacking both the join probe and the merge-scan compares. Caveat: it's a join/merge
-   win, not a reduce-`min` win (min is over values, not hashes), which is why a naive hash-sort
-   regressed reduce/reach in an earlier experiment.
-
-3. **A general columnar *kernel* surface.** A backend like this wants segmented sort / argmin
-   returning positions, batched range-find (`find_ranges`), and content-hash — not ad-hoc "arrange"
-   helpers. The corgi `arrange` API (`frankmcsherry/wip @ dd-arrange-api`) is a first cut.
-
-## Repro
-
-```
-# corgi backend branch (path-deps the corgi kernel crate at ../../wip/corgi):
-cargo run --release -p interactive --example corgi_progs      # correctness gate (6 programs vs vec)
-cargo run --release -p interactive --example corgi_perf       # linear / reach / three-way SCC
-N=100000,500000,1000000 cargo run --release -p interactive --example corgi_scc_big   # large-N SCC
-```
-
-Net: `int_proxy` is a working, correctness-validated extension point for non-`Ord`-keyed backends;
-the remaining cost for a columnar consumer is timestamp allocation, and DD already contains the
-columnar timestamp representation that fixes it — it just isn't reachable without static K/V today.
diff --git a/interactive/examples/corgi_progs.rs b/interactive/examples/corgi_progs.rs
deleted file mode 100644
index 6673933f9..000000000
--- a/interactive/examples/corgi_progs.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-//! Run a canonical `.ddp` program through BOTH the corgi and vec backends and compare. Usage:
-//!   PROG=reach ~/.cargo/bin/cargo run --release -p interactive --example corgi_progs
-//! Picks inputs by program (small graphs). Reports OK / FAIL / panic per program; with no PROG,
-//! runs the whole set.
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse};
-
-type Row = Value;
-
-fn tup(fields: &[i64]) -> Row {
-    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
-}
-fn rows(rs: &[&[i64]]) -> Vec<(Row, Row)> {
-    rs.iter().map(|f| (tup(f), Value::unit())).collect()
-}
-
-/// Per-program inputs (arity matches each `.ddp`'s `input N` usage).
-fn inputs_for(prog: &str) -> Vec<Vec<(Row, Row)>> {
-    let edges = rows(&[&[1, 2], &[2, 3], &[3, 4], &[5, 6], &[4, 2]]);
-    match prog {
-        "reach" => vec![edges, rows(&[&[1]])],
-        "scc" => vec![edges],
-        // stable: edges (l_node, l_pref, r_node, r_pref)
-        "stable" => vec![rows(&[&[1, 1, 10, 1], &[1, 2, 11, 1], &[2, 1, 10, 2], &[2, 2, 11, 2]])],
-        "unnest" => vec![rows(&[&[1, 2], &[3, 4]])],
-        "adt" => vec![edges],
-        "binders" => vec![rows(&[&[1, 2], &[3, 4]])],
-        other => panic!("no inputs configured for {other}"),
-    }
-}
-
-fn run_one(prog: &str) -> bool {
-    let path = format!("{}/examples/programs/{prog}.ddp", env!("CARGO_MANIFEST_DIR"));
-    let src = interactive::load_program(&path);
-    let stmts = parse::pipe::parse(&src);
-    let mut tree = lower::lower_tree(stmts);
-    tree.optimize();
-    let inputs = inputs_for(prog);
-
-    let want = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| vec::evaluate(&tree, &inputs)));
-    let got = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| corgi::evaluate(&tree, &inputs)));
-    match (want, got) {
-        (Ok(w), Ok(g)) => {
-            let ok = w == g;
-            println!("[{}] {prog}", if ok { "OK  " } else { "FAIL" });
-            if !ok {
-                println!("   vec  : {w:?}");
-                println!("   corgi: {g:?}");
-            }
-            ok
-        }
-        (Err(_), _) => {
-            println!("[VEC-PANIC] {prog} (reference itself panicked; skipping)");
-            true
-        }
-        (Ok(_), Err(_)) => {
-            println!("[CORGI-PANIC] {prog}");
-            false
-        }
-    }
-}
-
-fn main() {
-    std::panic::set_hook(Box::new(|_| {})); // quiet panics; we report them
-    let all = ["reach", "scc", "stable", "unnest", "adt", "binders"];
-    let progs: Vec<String> = match std::env::var("PROG") {
-        Ok(p) => vec![p],
-        Err(_) => all.iter().map(|s| s.to_string()).collect(),
-    };
-    let mut all_ok = true;
-    for p in &progs {
-        all_ok &= run_one(p);
-    }
-    println!("\n{}", if all_ok { "all programs match vec backend" } else { "some programs differ — see above" });
-}
diff --git a/interactive/examples/corgi_scorecard.rs b/interactive/examples/corgi_scorecard.rs
deleted file mode 100644
index bde27e61d..000000000
--- a/interactive/examples/corgi_scorecard.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-//! Operator scorecard — the standing per-operator perf-triage harness for the corgi backend.
-//!
-//! Each case is a minimal DDIR program that isolates ONE backend operator so its corgi-vs-vec ratio
-//! is read directly, instead of reverse-engineered from a whole program. Every case also asserts
-//! corgi == vec (correctness gate) before timing.
-//!
-//! Two modes:
-//!   * scorecard (default):  bench every case, print `vec | corgi | ratio | target | verdict`.
-//!       ~/.cargo/bin/cargo run --release -p interactive --example corgi_scorecard
-//!   * profile one case:     PROG=<name> BACKEND=<corgi|vec> ITERS=<n> loops that case (for samply).
-//!       BACKEND=corgi ITERS=400 samply record ... -- .../corgi_scorecard   # PROG=reduce_distinct etc.
-//!
-//! Targets encode the thesis: parity with vec is the FLOOR (never lose on an operator), beating vec
-//! is the GOAL (columnar corgi should avoid the row backend's interpretation + Value pointer-chasing).
-
-// The suite runs on mimalloc (as a real deployment would — ddir_server does): the
-// system allocator was 27-28% of both DDIR backends' SCC profiles. One binary per
-// benchmark, so every column (native/fair/vec/corgi) shares the same allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::{lower, parse, scope_ir};
-
-type Row = Value;
-
-fn tup(fields: &[i64]) -> Row {
-    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
-}
-
-fn xorshift(s: &mut u64) -> u64 {
-    *s ^= *s << 13;
-    *s ^= *s >> 7;
-    *s ^= *s << 17;
-    *s
-}
-
-fn compile(src: &str) -> scope_ir::Program {
-    let mut p = lower::lower_tree(parse::pipe::parse(src));
-    p.optimize();
-    p
-}
-
-/// Median wall-clock over `iters` runs (min 3), after a warmup.
-fn bench<F: FnMut()>(iters: usize, mut f: F) -> Duration {
-    f();
-    let mut ts: Vec<Duration> = (0..iters.max(3))
-        .map(|_| { let t = Instant::now(); f(); t.elapsed() })
-        .collect();
-    ts.sort();
-    ts[ts.len() / 2]
-}
-
-/// A wide 6-field keyed collection: `(key ; f1..f6)`. Shared input for the compute/arrange cases.
-fn wide_input(n: usize, seed: u64) -> Vec<(Row, Row)> {
-    let mut s = seed;
-    (0..n)
-        .map(|i| {
-            let f = |s: &mut u64| (xorshift(s) % 1000) as i64;
-            (tup(&[i as i64, f(&mut s), f(&mut s), f(&mut s), f(&mut s), f(&mut s)]), Value::unit())
-        })
-        .collect()
-}
-
-/// Edges over `nodes` (key = src, val = dst) — for join / reduce / reach.
-fn edges(nodes: usize, fanout: usize, seed: u64) -> Vec<(Row, Row)> {
-    let mut s = seed;
-    (0..nodes * fanout)
-        .map(|_| (tup(&[(xorshift(&mut s) % nodes as u64) as i64, (xorshift(&mut s) % nodes as u64) as i64]), Value::unit()))
-        .collect()
-}
-
-/// A scorecard case: the operator it isolates, its program, inputs, sizes, and target ratio.
-struct Case {
-    name: &'static str,
-    isolates: &'static str,
-    src: String,
-    inputs: fn(usize) -> Vec<Vec<(Row, Row)>>,
-    sizes: Vec<usize>,
-    target: f64, // corgi/vec ratio we're aiming at (<=1 = parity-or-better)
-}
-
-fn cases() -> Vec<Case> {
-    // 8 wide arithmetic maps, NO arrange — pure columnar compute.
-    let mut map8 = String::from("let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5], $0[0]);\n");
-    let mut prev = 'a';
-    for i in 0..8 {
-        let cur = (b'b' + i) as char;
-        map8.push_str(&format!(
-            "let {cur} = {prev} | map($0 ; $1[0]+$1[1], $1[1]+$1[2], $1[2]+$1[3], $1[3]+$1[4], $1[4]+$1[5], $1[0]);\n"
-        ));
-        prev = cur;
-    }
-    map8.push_str(&format!("export \"r\" = {prev};\n"));
-
-    vec![
-        Case {
-            name: "map8",
-            isolates: "linear (map, columnar eval, no arrange)",
-            src: map8,
-            inputs: |n| vec![wide_input(n, 0xdead_beef)],
-            sizes: vec![20_000, 100_000],
-            target: 0.5,
-        },
-        Case {
-            name: "filter",
-            isolates: "linear (filter, no arrange)",
-            src: "let a = input 0 | key($0[0] ; $0[1], $0[2], $0[3], $0[4], $0[5]);\n\
-                   let b = a | filter($1[0] != 999999);\n\
-                   let c = b | filter($1[1] != 999999);\n\
-                   export \"r\" = c | filter($1[2] != 999999);\n".into(),
-            inputs: |n| vec![wide_input(n, 0x1234_5678)],
-            sizes: vec![20_000, 100_000],
-            target: 0.6,
-        },
-        Case {
-            name: "arrange",
-            isolates: "arrange (build + as_collection + transcode)",
-            src: "export \"r\" = input 0 | key($0[0] ; $0[1]) | arrange;\n".into(),
-            inputs: |n| vec![wide_input(n, 0x0a0a_0a0a)],
-            sizes: vec![20_000, 100_000],
-            target: 1.0,
-        },
-        Case {
-            name: "join",
-            isolates: "join (non-recursive, find merge-join)",
-            src: "let a = input 0 | key($0[0] ; $0[1]);\n\
-                  let b = input 1 | key($0[0] ; $0[1]);\n\
-                  export \"r\" = a | join(b, ($1 ; $2)) | arrange;\n".into(),
-            inputs: |n| vec![edges(n, 2, 0x11), edges(n, 2, 0x22)],
-            sizes: vec![5_000, 20_000],
-            target: 1.0,
-        },
-        Case {
-            name: "reduce_distinct",
-            isolates: "reduce (distinct, non-recursive)",
-            src: "export \"r\" = input 0 | key($0[0] ; $0[1]) | distinct | arrange;\n".into(),
-            inputs: |n| vec![edges(n, 4, 0x33)],
-            sizes: vec![5_000, 20_000],
-            target: 1.0,
-        },
-        Case {
-            name: "reduce_count",
-            isolates: "reduce (count, non-recursive)",
-            src: "export \"r\" = input 0 | key($0[0] ; $0[1]) | count | arrange;\n".into(),
-            inputs: |n| vec![edges(n, 4, 0x44)],
-            sizes: vec![5_000, 20_000],
-            target: 1.0,
-        },
-        Case {
-            name: "reach",
-            isolates: "integration (recursive join + distinct)",
-            src: "let edges = input 0 | key($0[0] ; $0[1]);\n\
-                  let roots = input 1 | key($0[0] ;);\n\
-                  reach: {\n\
-                    let proposals = reach | join(edges, ($2 ;));\n\
-                    var reach = roots + proposals | distinct;\n\
-                  }\n\
-                  export \"r\" = reach::reach | arrange;\n".into(),
-            inputs: |n| vec![edges(n, 3, 0x9e37), vec![(tup(&[0]), Value::unit())]],
-            sizes: vec![1_000, 4_000],
-            target: 1.0,
-        },
-    ]
-}
-
-fn verdict(ratio: f64, target: f64) -> &'static str {
-    if ratio <= target { "✓ AT TARGET" }
-    else if ratio < 1.0 { "win, below target" }
-    else if ratio < 1.3 { "~ near parity" }
-    else { "✗ SLOW" }
-}
-
-fn main() {
-    let prog = std::env::var("PROG").ok();
-
-    // Profile mode: loop one case's largest size on one backend (for samply).
-    if let Some(name) = prog {
-        let case = cases().into_iter().find(|c| c.name == name).unwrap_or_else(|| panic!("no case {name}"));
-        let p = compile(&case.src);
-        let n = *case.sizes.last().unwrap();
-        let inputs = (case.inputs)(n);
-        let backend = std::env::var("BACKEND").unwrap_or_else(|_| "corgi".into());
-        let iters: usize = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(400);
-        let mut acc = 0usize;
-        for _ in 0..iters {
-            let out = if backend == "vec" { vec::evaluate(&p, &inputs) } else { corgi::evaluate(&p, &inputs) };
-            acc += out.values().map(|v| v.len()).sum::<usize>();
-        }
-        std::hint::black_box(acc);
-        eprintln!("done {name} backend={backend} iters={iters} (acc={acc})");
-        return;
-    }
-
-    // Scorecard mode.
-    println!("{:<16} {:<44} {:>8} {:>10} {:>10} {:>7} {:>7}  {}",
-             "case", "isolates", "n", "vec", "corgi", "ratio", "target", "verdict");
-    println!("{}", "-".repeat(130));
-    for case in cases() {
-        let p = compile(&case.src);
-        for &n in &case.sizes {
-            let inputs = (case.inputs)(n);
-            assert_eq!(corgi::evaluate(&p, &inputs), vec::evaluate(&p, &inputs), "MISMATCH in {}", case.name);
-            let vt = bench(5, || { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-            let ct = bench(5, || { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-            let ratio = ct.as_secs_f64() / vt.as_secs_f64();
-            println!("{:<16} {:<44} {:>8} {:>9.2?} {:>9.2?} {:>6.2}x {:>6.2}x  {}",
-                     case.name, case.isolates, n, vt, ct, ratio, case.target, verdict(ratio, case.target));
-        }
-    }
-    println!("\nfloor = parity (ratio 1.0); goal = beat vec (ratio < 1.0). Profile a case: PROG=<name> BACKEND=corgi samply record ...");
-}
diff --git a/interactive/examples/ddir_bench.rs b/interactive/examples/ddir_bench.rs
deleted file mode 100644
index 796d0b10b..000000000
--- a/interactive/examples/ddir_bench.rs
+++ /dev/null
@@ -1,545 +0,0 @@
-//! The DDIR benchmark runner: interpreted programs from `examples/programs/*.ddp`,
-//! compiled twins and input generators registered here by bench name.
-//!
-//!   ddir_bench <bench>        bench ∈ { scc, scc-compound, ident, ast }
-//!
-//! Environment:
-//!   N=a,b,..   sizes (per-bench defaults below)
-//!   CHECK=0/1  correctness assertions (default: first size only)
-//!   SEED=      graph seed (scc)          CHAIN=  chain length (ident)
-//!   BACKEND=corgi|vec|native|native-fair with ITERS=k — profiling mode: loop ONE
-//!   column at the first size, no table (a samply target; replaces the prof twins).
-//!
-//! Fairness: the scc twins include `strongly_connected_at` with the same enter_at
-//! log-bucketing the DDIR programs apply, so compiled and interpreted run the same
-//! algorithm. Correctness: corgi == vec asserted per checked row; ident and ast also
-//! check both backends and the compiled twin against closed-form oracles;
-//! scc-compound additionally maps its compound encoding back and compares against
-//! the plain-encoding program.
-
-// The suite runs on mimalloc (as a real deployment would): one binary, so every
-// column shares the allocator.
-#[global_allocator]
-static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
-use std::time::{Duration, Instant};
-
-use interactive::backend::{corgi, vec};
-use interactive::ir::Value;
-use interactive::scope_ir::Program;
-use interactive::{lower, parse};
-
-use differential_dataflow::algorithms::graphs::scc::{strongly_connected, strongly_connected_at};
-use differential_dataflow::input::Input;
-use differential_dataflow::operators::iterate::Variable;
-use timely::dataflow::operators::probe::Handle;
-use timely::order::Product;
-
-fn xorshift(s: &mut u64) -> u64 { *s ^= *s << 13; *s ^= *s >> 7; *s ^= *s << 17; *s }
-
-fn tup(fields: &[i64]) -> Value { Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect()) }
-
-fn once<F: FnMut()>(mut f: F) -> Duration { let t = Instant::now(); f(); t.elapsed() }
-
-fn program(name: &str) -> Program {
-    let path = format!("{}/examples/programs/{name}.ddp", env!("CARGO_MANIFEST_DIR"));
-    let mut p = lower::lower_tree(parse::pipe::parse(&interactive::load_program(&path)));
-    p.optimize();
-    p
-}
-
-fn sizes(default: &[u64]) -> Vec<u64> {
-    std::env::var("N").ok()
-        .map(|s| s.split(',').filter_map(|x| x.trim().parse().ok()).collect())
-        .unwrap_or_else(|| default.to_vec())
-}
-
-fn checked(i: usize) -> bool {
-    std::env::var("CHECK").ok().map(|s| s != "0").unwrap_or(i == 0)
-}
-
-/// Profiling mode: `BACKEND=` set — loop that one column `ITERS` times at the first size.
-fn prof_mode() -> Option<(String, usize)> {
-    std::env::var("BACKEND").ok().map(|b| {
-        let iters = std::env::var("ITERS").ok().and_then(|s| s.parse().ok()).unwrap_or(1);
-        (b, iters)
-    })
-}
-
-fn consolidated(export: &[((Value, Value), i64)]) -> Vec<((Value, Value), i64)> {
-    let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
-    for ((k, v), d) in export { *map.entry((k.clone(), v.clone())).or_insert(0) += d; }
-    map.into_iter().filter(|(_, d)| *d != 0).collect()
-}
-
-// ---------------------------------------------------------------------------------------
-// scc — B1: SCC four ways at n = 100k..1m, e = 2n.
-// ---------------------------------------------------------------------------------------
-
-fn native_scc_once(edges: &[(usize, usize)], fair: bool) {
-    let edges = edges.to_vec();
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, graph) = scope.new_collection::<(usize, usize), isize>();
-            if fair {
-                strongly_connected_at(graph, |x| *x as u64).probe_with(&mut probe);
-            } else {
-                strongly_connected(graph).probe_with(&mut probe);
-            }
-            input
-        });
-        for &(s, d) in &edges { input.insert((s, d)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-}
-
-fn scc_edges(nodes: u64, seed0: u64) -> (Vec<(Value, Value)>, Vec<(usize, usize)>) {
-    let n_edges = nodes * 2;
-    let mut seed = seed0;
-    let rows: Vec<(Value, Value)> = (0..n_edges)
-        .map(|_| (tup(&[(xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64]), Value::unit()))
-        .collect();
-    let mut seed = seed0;
-    let native: Vec<(usize, usize)> = (0..n_edges)
-        .map(|_| ((xorshift(&mut seed) % nodes) as usize, (xorshift(&mut seed) % nodes) as usize))
-        .collect();
-    (rows, native)
-}
-
-fn bench_scc() {
-    let p = program("scc_bench");
-    let seed0: u64 = std::env::var("SEED").ok().and_then(|s| s.parse().ok()).unwrap_or(0xc0ff_ee42);
-    let sizes = sizes(&[100_000, 250_000, 500_000, 1_000_000]);
-
-    if let Some((backend, iters)) = prof_mode() {
-        let nodes = sizes[0];
-        let (rows, native) = scc_edges(nodes, seed0);
-        let inputs = vec![rows];
-        for i in 0..iters {
-            match backend.as_str() {
-                "corgi" => { std::hint::black_box(corgi::evaluate(&p, &inputs)); }
-                "vec" => { std::hint::black_box(vec::evaluate(&p, &inputs)); }
-                "native" => native_scc_once(&native, false),
-                "native-fair" => native_scc_once(&native, true),
-                other => panic!("scc: unknown BACKEND {other}"),
-            }
-            println!("done scc backend={backend} n={nodes} iter={i}");
-        }
-        return;
-    }
-
-    println!("SCC large-N — native DD / fair native (enter_at) / DDIR-vec / DDIR-corgi (e = 2n):");
-    for (i, &nodes) in sizes.iter().enumerate() {
-        let (rows, native) = scc_edges(nodes, seed0);
-        let n_edges = nodes * 2;
-        let inputs = vec![rows];
-        let check = checked(i);
-        if check {
-            assert_eq!(corgi::evaluate(&p, &inputs), vec::evaluate(&p, &inputs), "corgi != vec at n={nodes}");
-        }
-        let nt = once(|| native_scc_once(&native, false));
-        let ft = once(|| native_scc_once(&native, true));
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, ff, vf, cf) = (nt.as_secs_f64(), ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={nodes:<8} e={n_edges:<9}  native {nt:>8.2?}   fair(enter_at) {ft:>8.2?} ({:.2}x nat)   vec-DDIR {vt:>8.2?} ({:.2}x fair)   corgi-DDIR {ct:>8.2?} ({:.2}x fair, {:.2}x vec){}",
-            ff / nf, vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
-
-// ---------------------------------------------------------------------------------------
-// scc-compound — B2: nodes are (group, index) tuples; compound keys and labels throughout.
-// ---------------------------------------------------------------------------------------
-
-const GROUP_BITS: u64 = 10;
-
-fn node_val(x: u64) -> Value {
-    Value::Tuple(vec![Value::Int((x >> GROUP_BITS) as i64), Value::Int((x & ((1 << GROUP_BITS) - 1)) as i64)])
-}
-
-fn decode(v: &Value) -> i64 {
-    match v {
-        Value::Tuple(fs) => match (&fs[0], &fs[1]) {
-            (Value::Int(g), Value::Int(i)) => (g << GROUP_BITS) | i,
-            other => panic!("decode: unexpected node fields {other:?}"),
-        },
-        other => panic!("decode: unexpected node {other:?}"),
-    }
-}
-
-fn native_scc_compound_once(edges: &[(u64, u64)]) {
-    let enc = |x: u64| ((x >> GROUP_BITS) as i64, (x & ((1 << GROUP_BITS) - 1)) as i64);
-    let edges: Vec<((i64, i64), (i64, i64))> = edges.iter().map(|&(s, d)| (enc(s), enc(d))).collect();
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, graph) = scope.new_collection::<((i64, i64), (i64, i64)), isize>();
-            strongly_connected_at(graph, |n| n.0 as u64).probe_with(&mut probe);
-            input
-        });
-        for &(s, d) in &edges { input.insert((s, d)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-}
-
-fn bench_scc_compound() {
-    let p_compound = program("scc_compound");
-    let p_plain = program("scc_plain");
-    let sizes = sizes(&[100_000, 150_000]);
-
-    let gen = |nodes: u64| -> (Vec<(u64, u64)>, Vec<(Value, Value)>) {
-        let n_edges = nodes * 2;
-        let mut seed = 0xc0ff_ee42u64;
-        let raw: Vec<(u64, u64)> = (0..n_edges)
-            .map(|_| (xorshift(&mut seed) % nodes, xorshift(&mut seed) % nodes))
-            .collect();
-        let rows = raw.iter()
-            .map(|&(s, d)| (Value::Tuple(vec![node_val(s), node_val(d)]), Value::unit()))
-            .collect();
-        (raw, rows)
-    };
-
-    if let Some((backend, iters)) = prof_mode() {
-        let nodes = sizes[0];
-        let (raw, rows) = gen(nodes);
-        let inputs = vec![rows];
-        for i in 0..iters {
-            match backend.as_str() {
-                "corgi" => { std::hint::black_box(corgi::evaluate(&p_compound, &inputs)); }
-                "vec" => { std::hint::black_box(vec::evaluate(&p_compound, &inputs)); }
-                "native" | "native-fair" => native_scc_compound_once(&raw),
-                other => panic!("scc-compound: unknown BACKEND {other}"),
-            }
-            println!("done scc-compound backend={backend} n={nodes} iter={i}");
-        }
-        return;
-    }
-
-    println!("scc-compound (B2) — nodes are (group,index) tuples; fair native / DDIR-vec / DDIR-corgi (e = 2n):");
-    for (i, &nodes) in sizes.iter().enumerate() {
-        let n_edges = nodes * 2;
-        let (raw_edges, compound_rows) = gen(nodes);
-        let inputs = vec![compound_rows];
-
-        let check = checked(i);
-        if check {
-            let vec_out = vec::evaluate(&p_compound, &inputs);
-            assert_eq!(corgi::evaluate(&p_compound, &inputs), vec_out, "corgi != vec at n={nodes}");
-
-            // Encoding cross-check: compound output mapped back == plain-program output.
-            let plain_rows: Vec<(Value, Value)> = raw_edges.iter()
-                .map(|&(s, d)| (Value::Tuple(vec![Value::Int(s as i64), Value::Int(d as i64)]), Value::unit()))
-                .collect();
-            let plain_out = vec::evaluate(&p_plain, &vec![plain_rows]);
-            let remap = |t: &Value| match t {
-                Value::Tuple(fs) => Value::Tuple(fs.iter().map(|f| Value::Int(decode(f))).collect()),
-                other => panic!("unexpected row {other:?}"),
-            };
-            let mut mapped: Vec<((Value, Value), i64)> = consolidated(&vec_out["result"]).into_iter()
-                .map(|((k, v), d)| ((remap(&k), remap(&v)), d))
-                .collect();
-            mapped.sort();
-            assert_eq!(mapped, consolidated(&plain_out["result"]), "compound != plain (mapped) at n={nodes}");
-        }
-
-        let ft = once(|| native_scc_compound_once(&raw_edges));
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p_compound, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p_compound, &inputs)); });
-        let (ff, vf, cf) = (ft.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={nodes:<8} e={n_edges:<9}  native(fair) {ft:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
-            vf / ff, cf / ff, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
-
-// ---------------------------------------------------------------------------------------
-// ident — B3: pointer-doubling representatives + two term-resolution joins.
-// ---------------------------------------------------------------------------------------
-
-#[allow(clippy::type_complexity)]
-fn native_ident_once(
-    parents: &[(i64, i64)],
-    terms: &[(i64, i64, i64)],
-    capture: bool,
-) -> Option<(Vec<((i64, i64), isize)>, Vec<((i64, (i64, i64)), isize)>)> {
-    use timely::dataflow::operators::capture::{Capture, Event, Extract};
-
-    let parents = parents.to_vec();
-    let terms = terms.to_vec();
-    let (reps_tx, reps_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
-    let (res_tx, res_rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, (i64, i64)), u64, isize)>>>();
-
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let (mut p_in, mut t_in) = worker.dataflow::<u64, _, _>(|scope| {
-            let (p_in, parent) = scope.new_collection::<(i64, i64), isize>();
-            let (t_in, term_rows) = scope.new_collection::<(i64, (i64, i64)), isize>();
-
-            let outer = parent.scope();
-            let reps = outer.scoped::<Product<u64, usize>, _, _>("Find", |inner| {
-                let parent = parent.enter(inner);
-                let (doubled_var, doubled) = Variable::new(inner, Product::new(Default::default(), 1));
-                let reps = doubled.concat(parent).reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
-                let reps_arr = reps.clone().arrange_by_key();
-                let next = reps
-                    .clone()
-                    .map(|(x, r)| (r, x))
-                    .arrange_by_key()
-                    .join_core(reps_arr, |_r, &x, &r2| Some((x, r2)));
-                doubled_var.set(next);
-                reps.leave(outer)
-            });
-
-            let reps_arr = reps.clone().arrange_by_key();
-            let by_a = term_rows.map(|(id, (a, b))| (a, (id, b))).arrange_by_key();
-            let with_a = by_a.join_core(reps_arr.clone(), |_a, &(id, b), &ra| Some((b, (id, ra))));
-            let resolved = with_a
-                .arrange_by_key()
-                .join_core(reps_arr, |_b, &(id, ra), &rb| Some((id, (ra, rb))));
-
-            resolved.clone().probe_with(&mut probe);
-            if capture {
-                reps.inner.capture_into(reps_tx);
-                resolved.inner.capture_into(res_tx);
-            }
-            (p_in, t_in)
-        });
-
-        for &(x, p) in &parents { p_in.insert((x, p)); }
-        for &(id, a, b) in &terms { t_in.insert((id, (a, b))); }
-        p_in.advance_to(1); p_in.flush();
-        t_in.advance_to(1); t_in.flush();
-        while probe.less_than(p_in.time()) { worker.step(); }
-    });
-
-    if capture {
-        let mut reps: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
-        for (_, batch) in reps_rx.extract() {
-            for (d, _, r) in batch { *reps.entry(d).or_insert(0) += r; }
-        }
-        let mut res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
-        for (_, batch) in res_rx.extract() {
-            for (d, _, r) in batch { *res.entry(d).or_insert(0) += r; }
-        }
-        Some((
-            reps.into_iter().filter(|(_, r)| *r != 0).collect(),
-            res.into_iter().filter(|(_, r)| *r != 0).collect(),
-        ))
-    } else {
-        None
-    }
-}
-
-fn bench_ident() {
-    let p = program("ident");
-    let sizes = sizes(&[100_000, 1_000_000]);
-    let chain: u64 = std::env::var("CHAIN").ok().and_then(|s| s.parse().ok()).unwrap_or(64);
-
-    let gen = |nodes: u64| {
-        let n_terms = nodes * 2;
-        let parents: Vec<(i64, i64)> = (0..nodes)
-            .map(|x| (x as i64, if x % chain == 0 { x as i64 } else { (x - 1) as i64 }))
-            .collect();
-        let mut seed = 0xdead_beef_u64;
-        let terms: Vec<(i64, i64, i64)> = (0..n_terms)
-            .map(|j| ((nodes + j) as i64, (xorshift(&mut seed) % nodes) as i64, (xorshift(&mut seed) % nodes) as i64))
-            .collect();
-        let parent_rows: Vec<(Value, Value)> = parents.iter().map(|&(x, p)| (tup(&[x, p]), Value::unit())).collect();
-        let term_rows: Vec<(Value, Value)> = terms.iter().map(|&(id, a, b)| (tup(&[id, a, b]), Value::unit())).collect();
-        (parents, terms, vec![parent_rows, term_rows])
-    };
-
-    if let Some((backend, iters)) = prof_mode() {
-        let nodes = sizes[0];
-        let (parents, terms, inputs) = gen(nodes);
-        for i in 0..iters {
-            match backend.as_str() {
-                "corgi" => { std::hint::black_box(corgi::evaluate(&p, &inputs)); }
-                "vec" => { std::hint::black_box(vec::evaluate(&p, &inputs)); }
-                "native" => { native_ident_once(&parents, &terms, false); }
-                other => panic!("ident: unknown BACKEND {other}"),
-            }
-            println!("done ident backend={backend} n={nodes} iter={i}");
-        }
-        return;
-    }
-
-    println!("ident-join (B3) — pointer-doubling reps + 2 term-resolution joins (chains of {chain}, terms = 2n):");
-    for (i, &nodes) in sizes.iter().enumerate() {
-        let n_terms = nodes * 2;
-        let root = |x: u64| (x - x % chain) as i64;
-        let (parents, terms, inputs) = gen(nodes);
-
-        let check = checked(i);
-        if check {
-            let expect_reps: Vec<((Value, Value), i64)> = (0..nodes)
-                .map(|x| ((tup(&[x as i64]), tup(&[root(x)])), 1))
-                .collect();
-            let mut expect_res: Vec<((Value, Value), i64)> = Default::default();
-            {
-                let mut map: std::collections::BTreeMap<(Value, Value), i64> = Default::default();
-                for &(id, a, b) in &terms {
-                    *map.entry((tup(&[id]), tup(&[root(a as u64), root(b as u64)]))).or_insert(0) += 1;
-                }
-                expect_res.extend(map.into_iter());
-            }
-
-            let vec_out = vec::evaluate(&p, &inputs);
-            assert_eq!(consolidated(&vec_out["reps"]), expect_reps, "vec reps != oracle at n={nodes}");
-            assert_eq!(consolidated(&vec_out["resolved"]), expect_res, "vec resolved != oracle at n={nodes}");
-            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={nodes}");
-
-            let (nat_reps, nat_res) = native_ident_once(&parents, &terms, true).unwrap();
-            let expect_nat_reps: Vec<((i64, i64), isize)> =
-                (0..nodes).map(|x| ((x as i64, root(x)), 1)).collect();
-            assert_eq!(nat_reps, expect_nat_reps, "native reps != oracle at n={nodes}");
-            let mut expect_nat_res: std::collections::BTreeMap<(i64, (i64, i64)), isize> = Default::default();
-            for &(id, a, b) in &terms {
-                *expect_nat_res.entry((id, (root(a as u64), root(b as u64)))).or_insert(0) += 1;
-            }
-            let expect_nat_res: Vec<_> = expect_nat_res.into_iter().collect();
-            assert_eq!(nat_res, expect_nat_res, "native resolved != oracle at n={nodes}");
-        }
-
-        let nt = once(|| { native_ident_once(&parents, &terms, false); });
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={nodes:<8} terms={n_terms:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
-            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
-
-// ---------------------------------------------------------------------------------------
-// ast — B4: list build + flatmap + variant/case/fold + min (8 elements per row).
-// ---------------------------------------------------------------------------------------
-
-const H: i64 = 500_000;
-
-/// The per-row logic, shared by the oracle and the native twin.
-fn explode(a: i64, b: i64) -> impl Iterator<Item = (i64, i64)> {
-    let elems = [a, b, a + b, a * b, a - b + 32768, b * b, a * a, a + b * b];
-    elems.into_iter().enumerate().map(move |(pos, e)| {
-        let bucket = pos as i64 + 8 * if e < H { 0 } else { 1 };
-        let payload = a + e + a * e + e * e;
-        (bucket, payload)
-    })
-}
-
-fn native_ast_once(rows: &[(i64, i64)], capture: bool) -> Option<Vec<((i64, i64), isize)>> {
-    use timely::dataflow::operators::capture::{Capture, Event, Extract};
-    let rows = rows.to_vec();
-    let (tx, rx) = std::sync::mpsc::channel::<Event<u64, Vec<((i64, i64), u64, isize)>>>();
-
-    timely::execute_directly(move |worker| {
-        let mut probe = Handle::new();
-        let mut input = worker.dataflow::<u64, _, _>(|scope| {
-            let (input, data) = scope.new_collection::<(i64, i64), isize>();
-            let buckets = data
-                .flat_map(|(a, b)| explode(a, b))
-                .reduce(|_k, s, t| t.push((*s[0].0, 1isize)));
-            buckets.clone().probe_with(&mut probe);
-            if capture { buckets.inner.capture_into(tx); }
-            input
-        });
-        for &(a, b) in &rows { input.insert((a, b)); }
-        input.advance_to(1);
-        input.flush();
-        while probe.less_than(input.time()) { worker.step(); }
-    });
-
-    if capture {
-        let mut out: std::collections::BTreeMap<(i64, i64), isize> = Default::default();
-        for (_, batch) in rx.extract() {
-            for (d, _, r) in batch { *out.entry(d).or_insert(0) += r; }
-        }
-        Some(out.into_iter().filter(|(_, r)| *r != 0).collect())
-    } else {
-        None
-    }
-}
-
-fn bench_ast() {
-    let p = program("ast");
-    let sizes = sizes(&[1_000_000, 4_000_000]);
-
-    let gen = |n_rows: u64| {
-        let mut seed = 0xfeed_f00d_u64;
-        let rows: Vec<(i64, i64)> = (0..n_rows)
-            .map(|_| ((xorshift(&mut seed) % 32_768) as i64, (xorshift(&mut seed) % 32_768) as i64))
-            .collect();
-        let ddir: Vec<(Value, Value)> = rows.iter().map(|&(a, b)| (tup(&[a, b]), Value::unit())).collect();
-        (rows, vec![ddir])
-    };
-
-    if let Some((backend, iters)) = prof_mode() {
-        let n_rows = sizes[0];
-        let (rows, inputs) = gen(n_rows);
-        for i in 0..iters {
-            match backend.as_str() {
-                "corgi" => { std::hint::black_box(corgi::evaluate(&p, &inputs)); }
-                "vec" => { std::hint::black_box(vec::evaluate(&p, &inputs)); }
-                "native" => { native_ast_once(&rows, false); }
-                other => panic!("ast: unknown BACKEND {other}"),
-            }
-            println!("done ast backend={backend} n={n_rows} iter={i}");
-        }
-        return;
-    }
-
-    println!("ast-compute (B4) — list build + flatmap + variant/case/fold + min (8 elems/row):");
-    for (i, &n_rows) in sizes.iter().enumerate() {
-        let (rows, inputs) = gen(n_rows);
-
-        let check = checked(i);
-        if check {
-            let mut mins: std::collections::BTreeMap<i64, i64> = Default::default();
-            for &(a, b) in &rows {
-                for (bucket, payload) in explode(a, b) {
-                    mins.entry(bucket).and_modify(|m| *m = (*m).min(payload)).or_insert(payload);
-                }
-            }
-            let expect: Vec<((Value, Value), i64)> =
-                mins.iter().map(|(&k, &v)| ((tup(&[k]), tup(&[v])), 1)).collect();
-            let expect_nat: Vec<((i64, i64), isize)> =
-                mins.iter().map(|(&k, &v)| ((k, v), 1)).collect();
-
-            let vec_out = vec::evaluate(&p, &inputs);
-            assert_eq!(consolidated(&vec_out["result"]), expect, "vec != oracle at n={n_rows}");
-            assert_eq!(corgi::evaluate(&p, &inputs), vec_out, "corgi != vec at n={n_rows}");
-            assert_eq!(native_ast_once(&rows, true).unwrap(), expect_nat, "native != oracle at n={n_rows}");
-        }
-
-        let nt = once(|| { native_ast_once(&rows, false); });
-        let vt = once(|| { std::hint::black_box(vec::evaluate(&p, &inputs)); });
-        let ct = once(|| { std::hint::black_box(corgi::evaluate(&p, &inputs)); });
-        let (nf, vf, cf) = (nt.as_secs_f64(), vt.as_secs_f64(), ct.as_secs_f64());
-        println!(
-            "  n={n_rows:<9}  native {nt:>8.2?}   vec-DDIR {vt:>8.2?} ({:.2}x nat)   corgi-DDIR {ct:>8.2?} ({:.2}x nat, {:.2}x vec){}",
-            vf / nf, cf / nf, cf / vf, if check { "  [checked]" } else { "" },
-        );
-    }
-}
-
-fn main() {
-    match std::env::args().nth(1).as_deref() {
-        Some("scc") => bench_scc(),
-        Some("scc-compound") => bench_scc_compound(),
-        Some("ident") => bench_ident(),
-        Some("ast") => bench_ast(),
-        other => {
-            eprintln!("usage: ddir_bench <scc|scc-compound|ident|ast>  (got {other:?})");
-            std::process::exit(1);
-        }
-    }
-}
diff --git a/interactive/examples/programs/ast.ddp b/interactive/examples/programs/ast.ddp
deleted file mode 100644
index d4d21c473..000000000
--- a/interactive/examples/programs/ast.ddp
+++ /dev/null
@@ -1,17 +0,0 @@
-con Fwd(1) = 0;
-    con Bwd(1) = 1;
-
-    let rows = input 0 | key($0[0] ; $0[1]);
-    let lists = rows | map($0 ; list($0[0], $1[0], $0[0] + $1[0], $0[0] * $1[0], $0[0] - $1[0] + 32768, $1[0] * $1[0], $0[0] * $0[0], $0[0] + $1[0] * $1[0]));
-    let exploded = lists | flatmap($1[0]);
-    let tagged = exploded
-        | map( $1[0] + 8 * if($1[1] < 500000, 0, 1)
-             ; case if($1[1] < 250000,
-                       Fwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)),
-                       Bwd(fold(list($0[0], $1[1], $0[0] * $1[1], $1[1] * $1[1]), 0, ^0 + ^1)))
-               {
-                 Fwd(s) => s,
-                 Bwd(s) => s,
-               } );
-    let buckets = tagged | min;
-    export "result" = buckets | arrange;
diff --git a/interactive/examples/programs/ident.ddp b/interactive/examples/programs/ident.ddp
deleted file mode 100644
index 51335de30..000000000
--- a/interactive/examples/programs/ident.ddp
+++ /dev/null
@@ -1,12 +0,0 @@
-let parent = input 0 | key($0[0] ; $0[1]);
-    let terms  = input 1 | key($0[0] ; $0[1], $0[2]);
-    find: {
-        let reps = doubled + parent | min;
-        var doubled = reps | key($1 ; $0) | join(reps, ($1 ; $2));
-    }
-    let by_a    = terms | key($1[0] ; $0, $1[1]);
-    let with_a  = by_a  | join(find::reps, ($1[0] ; $1[1], $2));
-    let by_b    = with_a | key($1[0] ; $0, $1[1]);
-    let resolved = by_b | join(find::reps, ($1[0] ; $1[1], $2));
-    export "reps" = find::reps | arrange;
-    export "resolved" = resolved | arrange;
diff --git a/interactive/examples/programs/scc_bench.ddp b/interactive/examples/programs/scc_bench.ddp
deleted file mode 100644
index d660f7c3b..000000000
--- a/interactive/examples/programs/scc_bench.ddp
+++ /dev/null
@@ -1,19 +0,0 @@
-let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | map(;) | arrange;
diff --git a/interactive/examples/programs/scc_compound.ddp b/interactive/examples/programs/scc_compound.ddp
deleted file mode 100644
index a935a1c53..000000000
--- a/interactive/examples/programs/scc_compound.ddp
+++ /dev/null
@@ -1,19 +0,0 @@
-let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0][0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0][0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | arrange;
diff --git a/interactive/examples/programs/scc_plain.ddp b/interactive/examples/programs/scc_plain.ddp
deleted file mode 100644
index 1a2d61ae2..000000000
--- a/interactive/examples/programs/scc_plain.ddp
+++ /dev/null
@@ -1,19 +0,0 @@
-let edges = input 0 | key($0[0] ; $0[1]);
-    let trans = edges | key($1 ; $0);
-    outer: {
-        let scc = edges + trim;
-        fwd: {
-            let nodes = edges | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(scc, ($2 ; $1));
-        }
-        let trim_fwd = edges | join(fwd::labels, ($1 ; $0, $2)) | join(fwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        bwd: {
-            let nodes = trans | key($1 ; $1) | enter_at($1[0]);
-            let labels = proposals + nodes | min;
-            var proposals = labels | join(trim_fwd, ($2 ; $1));
-        }
-        let trim_bwd = trans | join(bwd::labels, ($1 ; $0, $2)) | join(bwd::labels, ($0 ; $1, $2)) | filter($1[1] == $1[2]) | key($0 ; $1[0]);
-        var trim = trim_bwd - edges;
-    }
-    export "result" = outer::scc | arrange;
diff --git a/interactive/tests/corgi_backend.rs b/interactive/tests/corgi_backend.rs
new file mode 100644
index 000000000..d3faad679
--- /dev/null
+++ b/interactive/tests/corgi_backend.rs
@@ -0,0 +1,49 @@
+//! The corgi backend's correctness gate: each canonical `.ddp` program must evaluate
+//! identically through the corgi backend and the reference vec backend.
+
+use interactive::backend::{corgi, vec};
+use interactive::ir::Value;
+use interactive::{lower, parse};
+
+fn tup(fields: &[i64]) -> Value {
+    Value::Tuple(fields.iter().map(|&n| Value::Int(n)).collect())
+}
+fn rows(rs: &[&[i64]]) -> Vec<(Value, Value)> {
+    rs.iter().map(|f| (tup(f), Value::unit())).collect()
+}
+
+/// Per-program inputs (arity matches each `.ddp`'s `input N` usage).
+fn inputs_for(prog: &str) -> Vec<Vec<(Value, Value)>> {
+    let edges = rows(&[&[1, 2], &[2, 3], &[3, 4], &[5, 6], &[4, 2]]);
+    match prog {
+        "reach" => vec![edges, rows(&[&[1]])],
+        "scc" => vec![edges],
+        // stable: edges (l_node, l_pref, r_node, r_pref)
+        "stable" => vec![rows(&[&[1, 1, 10, 1], &[1, 2, 11, 1], &[2, 1, 10, 2], &[2, 2, 11, 2]])],
+        "unnest" => vec![rows(&[&[1, 2], &[3, 4]])],
+        "adt" => vec![edges],
+        "binders" => vec![rows(&[&[1, 2], &[3, 4]])],
+        other => panic!("no inputs configured for {other}"),
+    }
+}
+
+/// Evaluate `prog` through both backends and assert the outputs match.
+fn assert_backends_agree(prog: &str) {
+    let path = format!("{}/examples/programs/{prog}.ddp", env!("CARGO_MANIFEST_DIR"));
+    let src = interactive::load_program(&path);
+    let mut tree = lower::lower_tree(parse::pipe::parse(&src));
+    tree.optimize();
+    let inputs = inputs_for(prog);
+    assert_eq!(
+        corgi::evaluate(&tree, &inputs),
+        vec::evaluate(&tree, &inputs),
+        "corgi backend disagrees with the vec backend on {prog}",
+    );
+}
+
+#[test] fn reach() { assert_backends_agree("reach"); }
+#[test] fn scc() { assert_backends_agree("scc"); }
+#[test] fn stable() { assert_backends_agree("stable"); }
+#[test] fn unnest() { assert_backends_agree("unnest"); }
+#[test] fn adt() { assert_backends_agree("adt"); }
+#[test] fn binders() { assert_backends_agree("binders"); }

From 0d26ff4edbcaddde2f4a30c08c77998af4e780ca Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Tue, 14 Jul 2026 13:21:49 -0400
Subject: [PATCH 63/68] interactive: move col_times into the corgi module
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

col_times exists to serve CorgiChunk (its own doc says so) and is used only by
the corgi backend's modules — it belongs in src/corgi/, not at the crate root.
No code change beyond the module path (crate::col_times -> crate::corgi::col_times).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/src/corgi/chunk.rs           | 2 +-
 interactive/src/{ => corgi}/col_times.rs | 0
 interactive/src/corgi/join.rs            | 2 +-
 interactive/src/corgi/mod.rs             | 1 +
 interactive/src/corgi/reduce.rs          | 2 +-
 interactive/src/lib.rs                   | 1 -
 6 files changed, 4 insertions(+), 4 deletions(-)
 rename interactive/src/{ => corgi}/col_times.rs (100%)

diff --git a/interactive/src/corgi/chunk.rs b/interactive/src/corgi/chunk.rs
index 6a5c614ef..40792e975 100644
--- a/interactive/src/corgi/chunk.rs
+++ b/interactive/src/corgi/chunk.rs
@@ -34,7 +34,7 @@ use corgi::Value as CValue;
 
 use columnar::Columnar;
 
-use crate::col_times::{ColTime, ColTimes};
+use crate::corgi::col_times::{ColTime, ColTimes};
 use crate::ir::Value as DValue;
 
 use std::cmp::Ordering;
diff --git a/interactive/src/col_times.rs b/interactive/src/corgi/col_times.rs
similarity index 100%
rename from interactive/src/col_times.rs
rename to interactive/src/corgi/col_times.rs
diff --git a/interactive/src/corgi/join.rs b/interactive/src/corgi/join.rs
index e8aa26cd2..f8589840f 100644
--- a/interactive/src/corgi/join.rs
+++ b/interactive/src/corgi/join.rs
@@ -20,7 +20,7 @@ use corgi::Value as CValue;
 use differential_dataflow::trace::chunk::{Chunk, ChunkBatch};
 
 use crate::corgi::container::CorgiContainer;
-use crate::col_times::ColTime;
+use crate::corgi::col_times::ColTime;
 use crate::corgi::chunk::{flatten_batches, flatten_restricted, CorgiChunk};
 use crate::corgi::logic::compile_join_projection;
 use crate::ir::Diff;
diff --git a/interactive/src/corgi/mod.rs b/interactive/src/corgi/mod.rs
index bfa30191c..56fc484f5 100644
--- a/interactive/src/corgi/mod.rs
+++ b/interactive/src/corgi/mod.rs
@@ -5,6 +5,7 @@
 //! [`crate::backend::corgi`].
 
 pub mod chunk;
+pub mod col_times;
 pub mod container;
 pub mod join;
 pub mod logic;
diff --git a/interactive/src/corgi/reduce.rs b/interactive/src/corgi/reduce.rs
index 116926843..1f89d4cce 100644
--- a/interactive/src/corgi/reduce.rs
+++ b/interactive/src/corgi/reduce.rs
@@ -40,7 +40,7 @@ use differential_dataflow::operators::int_proxy::reduce::{ProxyReduceBackend, Re
 use corgi::arrange::{gather, gather_lanes, sort_blocks};
 use corgi::{Bounds, Shape, Value as CValue};
 
-use crate::col_times::ColTime;
+use crate::corgi::col_times::ColTime;
 use crate::corgi::chunk::{columns_to_batch, CorgiChunk};
 use crate::ir::Diff;
 use crate::parse::Reducer;
diff --git a/interactive/src/lib.rs b/interactive/src/lib.rs
index 93329759f..ba3b3a95b 100644
--- a/interactive/src/lib.rs
+++ b/interactive/src/lib.rs
@@ -1,6 +1,5 @@
 pub mod parse;
 pub mod ir;
-pub mod col_times;
 pub mod corgi;
 pub mod lower;
 pub mod scope_ir;

From 430c619dcc66ea2c3250f15e73580613dfb5aea7 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Tue, 14 Jul 2026 14:09:14 -0400
Subject: [PATCH 64/68] interactive: trim the corgi dependency comment

Drop the local-dev path note and the reference to a findings file that no longer
exists; keep the git rev pin (explicit and reproducible) with a one-line purpose.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/Cargo.toml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/interactive/Cargo.toml b/interactive/Cargo.toml
index c8d083d65..c31ee2212 100644
--- a/interactive/Cargo.toml
+++ b/interactive/Cargo.toml
@@ -13,8 +13,7 @@ workspace = true
 
 [dependencies]
 columnar = { workspace = true }
-# Local dev: `path = "../../wip/corgi"`. Pinned to a git rev so the branch builds standalone
-# (frankmcsherry/wip @ dd-arrange-api) — see int-proxy-columnar-findings.md.
+# The columnar kernels for the interpreted backend, pinned by git rev.
 corgi = { git = "https://github.com/frankmcsherry/wip", rev = "1301b281501d5e70ab63f9405412770a3250d985" }
 differential-dataflow = { workspace = true }
 mimalloc = "0.1.48"

From f1ebb5e7e76633e8d1279cfcaa444c1d8a64860a Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Tue, 14 Jul 2026 14:11:48 -0400
Subject: [PATCH 65/68] backend/corgi.rs: refresh the stale module header

The header described an early milestone: Spine<Rc<CorgiBatch>> (the arrangement
is a ChunkSpine<CorgiChunk> now), reduce 'awaits' a retire design (it is
implemented via the tactics), and a 'this iteration ... = todo!()' note (nothing
is todo). Rewrite it to describe the current, complete substrate.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index 1a70fa7f2..c5a3d1ae6 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -1,10 +1,12 @@
-//! corgi-native rendering substrate (Route B): corgi columns are the native representation, the
-//! arrangement is `Spine<Rc<CorgiBatch>>` (cursor-less), and the scalar logic is `eval_graph`.
-//! Parallels `backend::vec`. Linear/arrange/join are corgi-native; `reduce` awaits Frank's
-//! cursor-less `retire` design (the operator's interesting-times machinery).
+//! The corgi rendering substrate: corgi columns are the native representation on dataflow edges,
+//! arrangements are chains of sorted columnar chunks (`ChunkSpine<CorgiChunk>`, cursor-less), and
+//! scalar logic runs columnar via `eval_graph`. Parallels the row-wise `backend::vec`, which stays
+//! the correctness reference.
 //!
-//! This iteration: the `Backend` impl SHAPE compiles (arrange + leave_dynamic real; linear/join/
-//! as_collection/reduce/inspect = `todo!()`), validating the trait wiring + `render_tree::<CorgiBackend>`.
+//! All `Backend` methods are corgi-native: `linear` folds a `LinearOp` chain over each container
+//! ([`apply_ops`], columnar fast paths with row-wise fallbacks); `arrange` ingests columns without
+//! a row round-trip; `join`/`reduce` run through whole-chunk tactics ([`CorgiJoinTactic`], the
+//! rank/int-proxy reduce backends) over the columnar chunks.
 
 use timely::dataflow::Scope;
 use timely::dataflow::channels::pact::Pipeline;

From 26d39d468570381406c4929112955ee371b03c06 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Tue, 14 Jul 2026 14:13:42 -0400
Subject: [PATCH 66/68] backend/corgi.rs: hoist the type aliases above their
 first use

CC/Row/Upd/CTrace were defined ~110 lines below apply_ops, whose signature reads
in terms of CC. Move them to just after the imports so the shorthands are in
scope where the reader first meets them.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index c5a3d1ae6..e71a6e6de 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -34,6 +34,13 @@ use crate::ir::{Diff, LinearOp, Time, Value as DValue};
 use crate::parse::{Projection, Reducer};
 use crate::scope_ir as st;
 
+/// A DDIR row, an update, the corgi container on dataflow edges, and the columnar trace —
+/// the shorthands the `Backend` methods below are written in terms of.
+type Row = DValue;
+type Upd = ((Row, Row), Time, Diff);
+type CC = CorgiContainer<Time, Diff>;
+type CTrace = differential_dataflow::trace::chunk::ChunkSpine<CorgiChunk<Time, Diff>>;
+
 /// Apply a `LinearOp` chain to one corgi container (the corgi-native row-wise compute per batch).
 /// Project = corgi `eval_graph`; Filter = corgi mask + `gather`; Negate = Rust — all columnar.
 /// The time/list-shaping ops (EnterAt/LiftIter/FlatMap) take a correctness-first row-wise path
@@ -149,10 +156,6 @@ fn append_iter(val: DValue, iter: i64) -> DValue {
     }
 }
 
-type Row = DValue;
-type Upd = ((Row, Row), Time, Diff);
-type CC = CorgiContainer<Time, Diff>;
-type CTrace = differential_dataflow::trace::chunk::ChunkSpine<CorgiChunk<Time, Diff>>;
 
 /// The corgi rendering substrate.
 pub enum CorgiBackend {}

From 6d69c796c9348cb41acb4caec9874c6aebeeb617 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Tue, 14 Jul 2026 14:15:46 -0400
Subject: [PATCH 67/68] backend/corgi.rs: document CorgiBackend as an
 uninhabited type-level tag

Explain the empty enum: it is never a value, only a type carrying the Backend
impl (selected via render_tree::<CorgiBackend>); the empty enum makes it
unconstructable. Mirrors VecBackend.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 interactive/src/backend/corgi.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/interactive/src/backend/corgi.rs b/interactive/src/backend/corgi.rs
index e71a6e6de..ef228c546 100644
--- a/interactive/src/backend/corgi.rs
+++ b/interactive/src/backend/corgi.rs
@@ -157,7 +157,10 @@ fn append_iter(val: DValue, iter: i64) -> DValue {
 }
 
 
-/// The corgi rendering substrate.
+/// The corgi rendering substrate. An uninhabited type used only as a type-level tag: it
+/// carries the [`Backend`] impl (a namespace of rendering functions selected by type) and is
+/// never a value — rendering goes through `render_tree::<CorgiBackend>`. The empty enum (vs a
+/// unit struct) makes constructing one impossible, signalling "type only". Mirrors `VecBackend`.
 pub enum CorgiBackend {}
 
 impl Backend for CorgiBackend {

From cd67ea4836fdc6c077067ba4378680a6069eebc6 Mon Sep 17 00:00:00 2001
From: Frank McSherry <fmcsherry@me.com>
Date: Wed, 15 Jul 2026 08:30:58 -0400
Subject: [PATCH 68/68] Remove strongly_connected_at; revert scc to master-next

strongly_connected_at was added for the benchmarks' fair-compiled SCC baseline;
those benchmarks left this PR, orphaning it (tests/scc.rs was its only remaining
user). Its scc_at tests exposed a PRE-EXISTING nondeterminism in propagate_at/
propagate_core (the rotated reduce_abelian propagation): scc_at_10_20_1000 is
flaky under 3 workers (the plain scc test, which uses a local iterate+enter_at
reachability, is deterministic). Rather than carry an orphaned API whose tests
surface someone else's bug, revert scc.rs + tests/scc.rs to master-next. The API
can return with the benchmark tooling once propagate_core's determinism is fixed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../src/algorithms/graphs/scc.rs              | 30 +++++--------------
 differential-dataflow/tests/scc.rs            | 24 ++++-----------
 2 files changed, 13 insertions(+), 41 deletions(-)

diff --git a/differential-dataflow/src/algorithms/graphs/scc.rs b/differential-dataflow/src/algorithms/graphs/scc.rs
index 32477c52a..c66f93ba3 100644
--- a/differential-dataflow/src/algorithms/graphs/scc.rs
+++ b/differential-dataflow/src/algorithms/graphs/scc.rs
@@ -9,7 +9,7 @@ use crate::{VecCollection, ExchangeData};
 use crate::lattice::Lattice;
 use crate::difference::{Abelian, Multiply};
 
-use super::propagate::propagate_at;
+use super::propagate::propagate;
 
 /// Returns the subset of edges in the same strongly connected component.
 pub fn strongly_connected<'scope, T, N, R>(graph: VecCollection<'scope, T, (N,N), R>) -> VecCollection<'scope, T, (N,N), R>
@@ -19,23 +19,6 @@ where
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
     R: From<i8>
-{
-    strongly_connected_at(graph, |_| 0)
-}
-
-/// Returns the subset of edges in the same strongly connected component.
-///
-/// This variant introduces node labels in rounds indicated by `logic`, as in `propagate_at`:
-/// small labels can complete their propagation before larger labels are introduced, which can
-/// substantially reduce the total work performed.
-pub fn strongly_connected_at<'scope, T, N, R, F>(graph: VecCollection<'scope, T, (N,N), R>, logic: F) -> VecCollection<'scope, T, (N,N), R>
-where
-    T: Timestamp + Lattice + Hash,
-    N: ExchangeData + Hash,
-    R: ExchangeData + Abelian,
-    R: Multiply<R, Output=R>,
-    R: From<i8>,
-    F: Fn(&N)->u64+Clone+'static,
 {
     use timely::order::Product;
     let outer = graph.scope();
@@ -47,21 +30,20 @@ where
         use crate::operators::iterate::Variable;
         let (variable, inner) = Variable::new_from(edges.clone(), Product::new(Default::default(), 1));
 
-        let result = trim_edges(trim_edges(inner, edges, logic.clone()), trans, logic);
+        let result = trim_edges(trim_edges(inner, edges), trans);
         variable.set(result.clone());
         result.leave(outer)
     })
 }
 
-fn trim_edges<'scope, T, N, R, F>(cycle: VecCollection<'scope, T, (N,N), R>, edges: VecCollection<'scope, T, (N,N), R>, logic: F)
+fn trim_edges<'scope, T, N, R>(cycle: VecCollection<'scope, T, (N,N), R>, edges: VecCollection<'scope, T, (N,N), R>)
     -> VecCollection<'scope, T, (N,N), R>
 where
     T: Timestamp + Lattice + Hash,
     N: ExchangeData + Hash,
     R: ExchangeData + Abelian,
     R: Multiply<R, Output=R>,
-    R: From<i8>,
-    F: Fn(&N)->u64+Clone+'static,
+    R: From<i8>
 {
     let outer = edges.inner.scope();
     outer.region_named("TrimEdges", |region| {
@@ -72,7 +54,9 @@ where
                          .map_in_place(|x| x.0 = x.1.clone())
                          .consolidate();
 
-        let labels = propagate_at(cycle, nodes, logic).arrange_by_key();
+        // NOTE: With a node -> int function, can be improved by:
+        // let labels = propagate_at(&cycle, &nodes, |x| *x as u64);
+        let labels = propagate(cycle, nodes).arrange_by_key();
 
         edges.arrange_by_key()
              .join_core(labels.clone(), |e1,e2,l1| [(e2.clone(),(e1.clone(),l1.clone()))])
diff --git a/differential-dataflow/tests/scc.rs b/differential-dataflow/tests/scc.rs
index 306299ed1..c1e702ff7 100644
--- a/differential-dataflow/tests/scc.rs
+++ b/differential-dataflow/tests/scc.rs
@@ -19,17 +19,11 @@ use differential_dataflow::lattice::Lattice;
 type Node = usize;
 type Edge = (Node, Node);
 
-#[test] fn scc_10_20_1000() { test_sizes(10, 20, 1000, Config::process(3), false); }
-#[test] fn scc_100_200_10() { test_sizes(100, 200, 10, Config::process(3), false); }
-#[test] fn scc_100_2000_1() { test_sizes(100, 2000, 1, Config::process(3), false); }
+#[test] fn scc_10_20_1000() { test_sizes(10, 20, 1000, Config::process(3)); }
+#[test] fn scc_100_200_10() { test_sizes(100, 200, 10, Config::process(3)); }
+#[test] fn scc_100_2000_1() { test_sizes(100, 2000, 1, Config::process(3)); }
 
-// The library's prioritized variant (`strongly_connected_at`, labels log-bucketed by node id)
-// against the same sequential oracle.
-#[test] fn scc_at_10_20_1000() { test_sizes(10, 20, 1000, Config::process(3), true); }
-#[test] fn scc_at_100_200_10() { test_sizes(100, 200, 10, Config::process(3), true); }
-#[test] fn scc_at_100_2000_1() { test_sizes(100, 2000, 1, Config::process(3), true); }
-
-fn test_sizes(nodes: usize, edges: usize, rounds: usize, config: Config, prioritized: bool) {
+fn test_sizes(nodes: usize, edges: usize, rounds: usize, config: Config) {
 
     let mut edge_list = Vec::new();
 
@@ -51,7 +45,7 @@ fn test_sizes(nodes: usize, edges: usize, rounds: usize, config: Config, priorit
     // }
 
     let mut results1 = scc_sequential(edge_list.clone());
-    let mut results2 = scc_differential(edge_list.clone(), config, prioritized);
+    let mut results2 = scc_differential(edge_list.clone(), config);
 
     results1.sort();
     results1.sort_by(|x,y| x.1.cmp(&y.1));
@@ -169,7 +163,6 @@ fn assign(node: usize, root: usize, reverse: &HashMap<usize, Vec<usize>>, compon
 fn scc_differential(
     edges_list: Vec<((usize, usize), usize, isize)>,
     config: Config,
-    prioritized: bool,
 )
 -> Vec<((usize, usize), usize, isize)>
 {
@@ -188,12 +181,7 @@ fn scc_differential(
 
             let (edge_input, edges) = scope.new_collection();
 
-            let result = if prioritized {
-                differential_dataflow::algorithms::graphs::scc::strongly_connected_at(edges, |x| *x as u64)
-            } else {
-                _strongly_connected(edges)
-            };
-            result
+            _strongly_connected(edges)
                 .consolidate()
                 .inner
                 .capture_into(send);