diff --git a/ctrlb/.gitignore b/ctrlb/.gitignore
new file mode 100644
index 0000000000..1769190623
--- /dev/null
+++ b/ctrlb/.gitignore
@@ -0,0 +1,4 @@
+# Benchmark byproducts — never commit these.
+run.log
+# Any local engine data dir.
+data/
diff --git a/ctrlb/benchmark.sh b/ctrlb/benchmark.sh
new file mode 100755
index 0000000000..5ae07af4f2
--- /dev/null
+++ b/ctrlb/benchmark.sh
@@ -0,0 +1,38 @@
+#!/bin/bash
+#
+# ClickBench entry point for CtrlB (Parquet, single). Sets the harness env vars,
+# runs the shared ClickBench driver, then turns its output into
+# results/<UTC date>/<machine>.json — so one ./benchmark.sh yields a result file
+# you can read exactly like the other engines' (see make-result.py).
+
+export BENCH_DOWNLOAD_SCRIPT="download-hits-parquet-single"
+export BENCH_RESTARTABLE=yes
+export BENCH_DURABLE=yes
+export BENCH_TRIES="${BENCH_TRIES:-3}"
+
+export BENCH_CONCURRENT_DURATION="${BENCH_CONCURRENT_DURATION:-0}"
+
+# Run the shared ClickBench driver, capturing stdout so we can BOTH show it live
+# and turn it into the committed results JSON. `tee` preserves the standard text
+# output (Load time / [t1,t2,t3] / Data size); PIPESTATUS keeps the driver's real
+# exit code (tee's is always 0).
+HERE="$(cd "$(dirname "$0")" && pwd)"
+LOG="${CTRLB_RESULT_LOG:-$HERE/run.log}"
+
+../lib/benchmark-common.sh | tee "$LOG"
+status=${PIPESTATUS[0]}
+
+# Assemble results/<UTC date>/c6a.4xlarge.json from the captured log + template.json,
+# so the result is readable exactly like the other engines'. Non-fatal: if this
+# can't run, the raw log ($LOG) is still there to convert by hand with
+# make-result.py.
+if [ "$status" -ne 0 ]; then
+  echo "WARN: benchmark driver exited $status — not writing results JSON." >&2
+elif ! command -v python3 > /dev/null 2>&1; then
+  echo "WARN: python3 not found — run: python3 make-result.py \"$LOG\"" >&2
+else
+  python3 "$HERE/make-result.py" "$LOG" --machine "${CTRLB_MACHINE:-c6a.4xlarge}" \
+    || echo "WARN: results JSON not written; run: python3 make-result.py \"$LOG\"" >&2
+fi
+
+exit "$status"
diff --git a/ctrlb/check b/ctrlb/check
new file mode 100755
index 0000000000..c9be78c2a9
--- /dev/null
+++ b/ctrlb/check
@@ -0,0 +1,11 @@
+#!/bin/bash
+# Readiness probe. Exit 0 once the engine answers a health check. This is a
+# SELECT 1-level signal that does NOT require the `hits` view, so the initial
+# pre-download (viewless) start still passes. bench_check_loop calls this
+# repeatedly until it succeeds or times out.
+set -e
+# shellcheck disable=SC1091
+source "$(dirname "$0")/config.sh"
+
+curl -sf -o /dev/null "$BASE_URL/healthz" 2>/dev/null \
+  || curl -sf -o /dev/null "$BASE_URL/api/health"
diff --git a/ctrlb/config.sh b/ctrlb/config.sh
new file mode 100644
index 0000000000..ceed438cf7
--- /dev/null
+++ b/ctrlb/config.sh
@@ -0,0 +1,132 @@
+# Shared config + helpers for the CtrlB ClickBench system dir.
+# Sourced (not executed) by every hook script: `source "$(dirname "$0")/config.sh"`.
+
+# Absolute path to THIS system directory — where the harness downloads
+# hits.parquet and runs the hook scripts from.
+CTRLB_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# ---- lake (docker) ----------------------------------------------------------
+# CtrlB runs as a Docker container (image pulled in ./install). The image serves
+# the HTTP API on 5080. We publish that to the host and mount THIS system
+# directory into the container at the SAME path, so the hits.parquet the harness
+# downloads to $PARQUET_PATH is visible inside the container at the identical
+# path and the CREATE EXTERNAL TABLE LOCATION resolves unchanged.
+CTRLB_IMAGE="${CTRLB_IMAGE:-ghcr.io/ctrlb-hq/ctrlb-public:c8eead4}"
+CONTAINER_NAME="${CONTAINER_NAME:-ctrlb}"
+LAKE_STARTUP="${LAKE_STARTUP:-30}"
+
+# ---- query endpoint --------------------------------------------------------
+BASE_URL="${BASE_URL:-http://localhost:5080}"
+ORG_ID="${ORG_ID:-default}"
+SEARCH_URL="${SEARCH_URL:-${BASE_URL}/api/${ORG_ID}/_search_parquet?type=logs}"
+START_TIME="${START_TIME:-1}"
+END_TIME="${END_TIME:-9999999999999999}"
+
+# ---- data ------------------------------------------------------------------
+# The harness downloads into the system dir (its cwd during bench_download).
+PARQUET_PATH="${PARQUET_PATH:-$CTRLB_DIR/hits.parquet}"
+
+# post_sql <sql> -> runs a statement and prints the endpoint's server-side
+# execution_time on stdout, non-zero (diagnostics to stderr) on failure. Used
+# ONLY for the untimed session setup in ./start (CREATE EXTERNAL TABLE / VIEW);
+# the presence of execution_time in the response is just a success signal here.
+# Benchmark queries are measured by time_sql (below), not this.
+post_sql() {
+  local sql="$1" response et
+  response="$(curl -s -X POST "$SEARCH_URL" \
+    -H 'Content-Type: application/json' \
+    -d "$(printf '{"sql": %s, "start_time": %s, "end_time": %s}' \
+           "$(printf '%s' "$sql" | jq -Rs .)" "$START_TIME" "$END_TIME")")"
+  et="$(printf '%s' "$response" | jq -r '.execution_time // empty' 2>/dev/null)"
+  if [ -z "$et" ]; then
+    echo "post_sql failed: $sql" >&2
+    echo "resp: $(printf '%s' "$response" | head -c 300)" >&2
+    return 1
+  fi
+  printf '%s' "$et"
+}
+
+# time_sql <sql> <response_file> -> prints the CLIENT-SIDE WALL time (seconds) of
+# the full HTTP round-trip on stdout, and writes the FULL response body to
+# <response_file>. The wall time (curl %{time_total}) covers sending the query,
+# the server processing it, AND receiving the entire result body.
+#
+# The body is downloaded in full (so the result really is sent back over the wire
+# — no server-side output suppression) and then VALIDATED as a genuine success
+# payload: a non-200 status, OR a body that does not parse / is missing the
+# expected fields (.success == true, .execution_time present) fails the try. We
+# do NOT use .execution_time as the timing — it is only a structural sanity check
+# so an error that somehow arrives with a 200 is not counted as a success.
+# LC_ALL=C forces a '.' decimal so the harness's number parser accepts the time.
+time_sql() {
+  local sql="$1" outfile="$2" out http_code time_total
+  out="$(LC_ALL=C curl -s -o "$outfile" -w '%{http_code} %{time_total}' \
+    -X POST "$SEARCH_URL" \
+    -H 'Content-Type: application/json' \
+    -d "$(printf '{"sql": %s, "start_time": %s, "end_time": %s}' \
+           "$(printf '%s' "$sql" | jq -Rs .)" "$START_TIME" "$END_TIME")")"
+  http_code="${out%% *}"
+  time_total="${out##* }"
+  if [ "$http_code" != "200" ]; then
+    echo "time_sql failed (HTTP ${http_code:-none}): $sql" >&2
+    return 1
+  fi
+  if ! jq -e '.success == true and (.execution_time != null)' "$outfile" > /dev/null 2>&1; then
+    echo "time_sql: HTTP 200 but response is not a valid success payload for: $sql" >&2
+    echo "resp: $(head -c 300 "$outfile" 2>/dev/null)" >&2
+    return 1
+  fi
+  printf '%s' "$time_total"
+}
+
+# Poll until the lake answers a health check, or LAKE_STARTUP seconds elapse.
+wait_for_health() {
+  local waited=0
+  while [ "$waited" -lt "$LAKE_STARTUP" ]; do
+    if curl -s -o /dev/null "$BASE_URL/healthz" 2>/dev/null \
+       || curl -s -o /dev/null "$BASE_URL/api/health" 2>/dev/null; then
+      return 0
+    fi
+    sleep 1
+    waited=$((waited + 1))
+  done
+  return 1
+}
+
+# Run docker the right way: directly if this user can reach the daemon, else via
+# sudo (we already require passwordless sudo). This makes every docker call work
+# whether or not the invoking user is in the 'docker' group — no group setup and
+# no re-login needed, which matters on a fresh VM (a `usermod -aG docker` would
+# not even take effect in the current session). The direct-vs-sudo decision is
+# made once and cached per process in _DKR.
+dkr() {
+  if [ -z "${_DKR:-}" ]; then
+    if docker info > /dev/null 2>&1; then
+      _DKR=direct
+    else
+      _DKR=sudo
+    fi
+  fi
+  if [ "$_DKR" = sudo ]; then
+    sudo docker "$@"
+  else
+    docker "$@"
+  fi
+}
+
+# Stop and remove the CtrlB container (idempotent; -f also kills a running one).
+stop_container() {
+  dkr rm -f "$CONTAINER_NAME" > /dev/null 2>&1 || true
+}
+
+# Run the CtrlB container detached: use host networking so the lake's HTTP API on
+# 5080 is reachable no matter which interface it binds inside the container, and
+# mount this system dir read-only so the downloaded hits.parquet is readable
+# inside at the same $PARQUET_PATH. The image has the benchmark env vars baked in.
+# --rm so each restart begins from clean state.
+start_container() {
+  dkr run -d --rm --name "$CONTAINER_NAME" \
+    --network host \
+    -v "$CTRLB_DIR":"$CTRLB_DIR":ro \
+    "$CTRLB_IMAGE" > /dev/null
+}
diff --git a/ctrlb/create.sql b/ctrlb/create.sql
new file mode 100644
index 0000000000..c42463ea8b
--- /dev/null
+++ b/ctrlb/create.sql
@@ -0,0 +1,2 @@
+CREATE EXTERNAL TABLE hits_raw STORED AS PARQUET LOCATION 'hits.parquet' OPTIONS ('binary_as_string' 'true');
+CREATE VIEW hits AS SELECT * EXCEPT("EventDate"), CAST(CAST("EventDate" AS INT) AS DATE) AS "EventDate" FROM hits_raw;
diff --git a/ctrlb/data-size b/ctrlb/data-size
new file mode 100755
index 0000000000..09de1f39eb
--- /dev/null
+++ b/ctrlb/data-size
@@ -0,0 +1,7 @@
+#!/bin/bash
+# Storage size in bytes: CtrlB queries the parquet in place, so its "size" is
+# the parquet file itself (same basis as the other in-place Parquet engines).
+set -e
+# shellcheck disable=SC1091
+source "$(dirname "$0")/config.sh"
+wc -c < "$PARQUET_PATH"
diff --git a/ctrlb/flush-caches b/ctrlb/flush-caches
new file mode 100755
index 0000000000..b5a92129a7
--- /dev/null
+++ b/ctrlb/flush-caches
@@ -0,0 +1,15 @@
+#!/bin/bash
+# Per-system cache hook, invoked by the harness's bench_flush_caches AFTER it has
+# already run `sync; sudo tee /proc/sys/vm/drop_caches` itself. So the OS page
+# cache is dropped either way (the harness requires passwordless sudo regardless).
+#
+# We just re-assert the page-cache drop for good measure. CtrlB runs as a
+# `docker run --rm` container that is torn down and recreated on every per-query
+# restart, so its entire on-disk state (metadata cache, sqlite, wal) lives in the
+# container's ephemeral filesystem and is wiped automatically each restart — there
+# is no persistent host directory for this hook to clear.
+set -u
+
+sync
+echo 3 | sudo -n tee /proc/sys/vm/drop_caches > /dev/null 2>&1 || true
+exit 0
diff --git a/ctrlb/install b/ctrlb/install
new file mode 100755
index 0000000000..3b8b1b3d55
--- /dev/null
+++ b/ctrlb/install
@@ -0,0 +1,46 @@
+#!/bin/bash
+# ClickBench install hook — run once, before the benchmark.
+#
+# REQUIRES passwordless sudo — to install Docker if absent and to drop the OS
+# page cache (`echo 3 > /proc/sys/vm/drop_caches`), which needs root. The
+# ClickBench driver already assumes passwordless sudo (its bench_flush_caches
+# runs `sudo tee /proc/sys/vm/drop_caches`), so this is consistent with every
+# other system. If sudo is missing we abort before doing anything.
+set -eu
+# shellcheck disable=SC1091
+source "$(dirname "$0")/config.sh"   # CTRLB_IMAGE is defined here (single source)
+
+# --- passwordless sudo (needed to install Docker if missing + drop the cache) -
+if ! sudo -n true 2>/dev/null; then
+  echo "ERROR: passwordless sudo is required (to install Docker if missing and to" >&2
+  echo "       drop the OS page cache). Configure sudo, or run as root." >&2
+  exit 1
+fi
+
+# --- Docker: install if missing on this fresh VM, then verify it is usable ----
+if ! command -v docker > /dev/null 2>&1; then
+  echo "Docker not found — installing via https://get.docker.com ..." >&2
+  curl -fsSL https://get.docker.com | sudo sh
+fi
+# Make sure the daemon is up (systemd or sysv), then confirm we can talk to it.
+# `dkr` (config.sh) uses the daemon directly if this user can reach it, else via
+# sudo — so being outside the 'docker' group is fine as long as sudo works.
+sudo systemctl enable --now docker > /dev/null 2>&1 \
+  || sudo service docker start > /dev/null 2>&1 || true
+if ! dkr info > /dev/null 2>&1; then
+  echo "ERROR: Docker is installed but the daemon is not reachable, even via sudo." >&2
+  echo "       Ensure the Docker service is running. Refusing to run." >&2
+  exit 1
+fi
+
+# 1) Pull the CtrlB image.
+dkr pull "$CTRLB_IMAGE"
+
+# 2) Right after the pull and before the container is spun up (in ./start):
+#    flush dirty pages to disk (sync), then drop the page cache. The pull dirties
+#    a large amount of memory; flushing here keeps ./load's own sync cheap so the
+#    load time stays honest instead of blowing up as writeback of the pull.
+sync
+echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null
+
+exit 0
diff --git a/ctrlb/load b/ctrlb/load
new file mode 100755
index 0000000000..35b36f8712
--- /dev/null
+++ b/ctrlb/load
@@ -0,0 +1,8 @@
+#!/bin/bash
+# CtrlB reads hits.parquet in place — there is no ingestion step. The `hits`
+# view is (re)created in ./start after each restart, not here. The harness wraps
+# this script in its load-time timer and appends its own `sync` afterward; that
+# sync (flushing the freshly-downloaded parquet to disk) is the reported
+# "Load time", exactly as for the other read-in-place parquet engines.
+set -e
+exit 0
diff --git a/ctrlb/make-result.py b/ctrlb/make-result.py
new file mode 100644
index 0000000000..46f95be768
--- /dev/null
+++ b/ctrlb/make-result.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Assemble a ClickBench results/<YYYYMMDD>/<machine>.json from a benchmark log.
+
+This is a HELPER, not a ClickBench hook — run it after `./benchmark.sh | tee LOG`
+to turn the raw run output into the JSON that gets committed in the PR.
+
+It reads the standard ClickBench log format emitted by ./benchmark.sh:
+  - one or more `Load time: <sec>` lines   (summed, then rounded to an int like
+    every peer result file)
+  - a `Data size: <bytes>` line            (falls back to the parquet-single
+    constant if absent)
+  - 43 lines of `[cold, hot1, hot2],`      (the per-query runtimes)
+plus template.json (system / proprietary / hardware / tuned / tags), and writes a
+VALID results JSON to results/<YYYYMMDD>/<machine>.json with the same field order
+and shape as the other systems' files.
+
+Usage:
+  ./make-result.py LOG
+  ./make-result.py LOG --machine c6a.4xlarge --date 2026-07-23
+  ./make-result.py LOG --template template.json --outdir results
+
+Exits non-zero (with a clear message) if the log is malformed, so a bad file is
+never written into results/.
+"""
+import argparse
+import datetime
+import json
+import os
+import re
+import sys
+
+# hits.parquet (single) is a fixed-size file; every peer reports this exact size.
+DEFAULT_DATA_SIZE = 14779976446
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("log", help="benchmark output captured via `| tee LOG`")
+    ap.add_argument("--machine", default="c6a.4xlarge",
+                    help="hardware label + result filename (default: c6a.4xlarge)")
+    ap.add_argument("--date", default=None,
+                    help="run date YYYY-MM-DD (default: today in UTC)")
+    ap.add_argument("--template", default=None,
+                    help="path to template.json (default: alongside this script)")
+    ap.add_argument("--outdir", default=None,
+                    help="results directory (default: <script dir>/results)")
+    ap.add_argument("--data-size", type=int, default=None,
+                    help="override data_size in bytes (default: read from log, "
+                         "else %d)" % DEFAULT_DATA_SIZE)
+    args = ap.parse_args()
+
+    here = os.path.dirname(os.path.abspath(__file__))
+    template_path = args.template or os.path.join(here, "template.json")
+    outdir = args.outdir or os.path.join(here, "results")
+
+    try:
+        text = open(args.log, encoding="utf-8", errors="replace").read()
+    except OSError as e:
+        sys.exit("cannot read log %s: %s" % (args.log, e))
+
+    # Load time: sum every "Load time:" line (ClickBench allows one or more),
+    # then round to an integer to match every committed peer result.
+    loads = re.findall(r'(?mi)^\s*Load\s*time:\s*([0-9]+(?:\.[0-9]+)?)', text)
+    if not loads:
+        sys.exit("no 'Load time:' line found in %s" % args.log)
+    load_time = round(sum(float(x) for x in loads))
+
+    # Data size: prefer the log, then --data-size, then the known constant.
+    m = re.search(r'(?mi)^\s*Data\s*size:\s*([0-9]+)', text)
+    if m:
+        data_size = int(m.group(1))
+    elif args.data_size is not None:
+        data_size = args.data_size
+    else:
+        data_size = DEFAULT_DATA_SIZE
+
+    # 43 result triples: "[c, h1, h2]" (trailing comma optional). The three-float
+    # bracket shape is specific enough that log noise won't match; we still assert
+    # the count so a short/long capture is rejected rather than silently written.
+    triples = [
+        [float(a), float(b), float(c)]
+        for a, b, c in re.findall(
+            r'\[\s*([0-9.eE+-]+)\s*,\s*([0-9.eE+-]+)\s*,\s*([0-9.eE+-]+)\s*\]', text)
+    ]
+    if len(triples) != 43:
+        sys.exit("expected 43 result rows, found %d in %s" % (len(triples), args.log))
+
+    try:
+        tpl = json.load(open(template_path))
+    except (OSError, ValueError) as e:
+        sys.exit("cannot read template %s: %s" % (template_path, e))
+    for key in ("system", "proprietary", "hardware", "tuned", "tags"):
+        if key not in tpl:
+            sys.exit("template %s is missing required key '%s'" % (template_path, key))
+
+    date = args.date or datetime.datetime.utcnow().strftime("%Y-%m-%d")
+    folder = date.replace("-", "")
+
+    # Same field order as the other systems' result files.
+    result = {
+        "system": tpl["system"],
+        "date": date,
+        "machine": args.machine,
+        "cluster_size": tpl.get("cluster_size", 1),
+        "proprietary": tpl["proprietary"],
+        "hardware": tpl["hardware"],
+        "tuned": tpl["tuned"],
+        "tags": tpl["tags"],
+        "load_time": load_time,
+        "data_size": data_size,
+        "concurrent_qps": None,
+        "concurrent_error_ratio": None,
+        "result": triples,
+    }
+
+    dest_dir = os.path.join(outdir, folder)
+    os.makedirs(dest_dir, exist_ok=True)
+    dest = os.path.join(dest_dir, "%s.json" % args.machine)
+    with open(dest, "w") as f:
+        f.write(format_result_json(result))
+
+    # Re-parse what we just wrote to guarantee valid JSON before we report success.
+    json.load(open(dest))
+    print("wrote %s" % dest)
+    print("  load_time = %d s   data_size = %d   queries = %d"
+          % (load_time, data_size, len(triples)))
+
+
+def format_result_json(result):
+    """Serialize like the other ClickBench result files: the object is
+    pretty-printed at 4 spaces, `tags` stays on one line, and each `result`
+    triple sits on its own single line (`[cold, hot1, hot2],`) instead of being
+    split one-number-per-line the way json.dump(indent=4) would."""
+    order = ["system", "date", "machine", "cluster_size", "proprietary",
+             "hardware", "tuned", "tags", "load_time", "data_size",
+             "concurrent_qps", "concurrent_error_ratio", "result"]
+    keys = order + [k for k in result if k not in order]
+    parts = []
+    for key in keys:
+        if key not in result:
+            continue
+        if key == "result":
+            rows = ",\n".join(
+                "        [%s]" % ", ".join(json.dumps(v) for v in row)
+                for row in result["result"]
+            )
+            parts.append('    "result": [\n%s\n    ]' % rows)
+        else:
+            parts.append("    %s: %s" % (json.dumps(key), json.dumps(result[key])))
+    return "{\n" + ",\n".join(parts) + "\n}\n"
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ctrlb/queries.sql b/ctrlb/queries.sql
new file mode 100644
index 0000000000..5be85b3f87
--- /dev/null
+++ b/ctrlb/queries.sql
@@ -0,0 +1,43 @@
+SELECT COUNT(*) FROM hits;
+SELECT COUNT(*) FROM hits WHERE "AdvEngineID" <> 0;
+SELECT SUM("AdvEngineID"), COUNT(*), AVG("ResolutionWidth") FROM hits;
+SELECT AVG("UserID") FROM hits;
+SELECT COUNT(DISTINCT "UserID") FROM hits;
+SELECT COUNT(DISTINCT "SearchPhrase") FROM hits;
+SELECT MIN("EventDate"), MAX("EventDate") FROM hits;
+SELECT "AdvEngineID", COUNT(*) FROM hits WHERE "AdvEngineID" <> 0 GROUP BY "AdvEngineID" ORDER BY COUNT(*) DESC;
+SELECT "RegionID", COUNT(DISTINCT "UserID") AS u FROM hits GROUP BY "RegionID" ORDER BY u DESC LIMIT 10;
+SELECT "RegionID", SUM("AdvEngineID"), COUNT(*) AS c, AVG("ResolutionWidth"), COUNT(DISTINCT "UserID") FROM hits GROUP BY "RegionID" ORDER BY c DESC LIMIT 10;
+SELECT "MobilePhoneModel", COUNT(DISTINCT "UserID") AS u FROM hits WHERE "MobilePhoneModel" <> '' GROUP BY "MobilePhoneModel" ORDER BY u DESC LIMIT 10;
+SELECT "MobilePhone", "MobilePhoneModel", COUNT(DISTINCT "UserID") AS u FROM hits WHERE "MobilePhoneModel" <> '' GROUP BY "MobilePhone", "MobilePhoneModel" ORDER BY u DESC LIMIT 10;
+SELECT "SearchPhrase", COUNT(*) AS c FROM hits WHERE "SearchPhrase" <> '' GROUP BY "SearchPhrase" ORDER BY c DESC LIMIT 10;
+SELECT "SearchPhrase", COUNT(DISTINCT "UserID") AS u FROM hits WHERE "SearchPhrase" <> '' GROUP BY "SearchPhrase" ORDER BY u DESC LIMIT 10;
+SELECT "SearchEngineID", "SearchPhrase", COUNT(*) AS c FROM hits WHERE "SearchPhrase" <> '' GROUP BY "SearchEngineID", "SearchPhrase" ORDER BY c DESC LIMIT 10;
+SELECT "UserID", COUNT(*) FROM hits GROUP BY "UserID" ORDER BY COUNT(*) DESC LIMIT 10;
+SELECT "UserID", "SearchPhrase", COUNT(*) FROM hits GROUP BY "UserID", "SearchPhrase" ORDER BY COUNT(*) DESC LIMIT 10;
+SELECT "UserID", "SearchPhrase", COUNT(*) FROM hits GROUP BY "UserID", "SearchPhrase" LIMIT 10;
+SELECT "UserID", extract(minute FROM to_timestamp_seconds("EventTime")) AS m, "SearchPhrase", COUNT(*) FROM hits GROUP BY "UserID", m, "SearchPhrase" ORDER BY COUNT(*) DESC LIMIT 10;
+SELECT "UserID" FROM hits WHERE "UserID" = 435090932899640449;
+SELECT COUNT(*) FROM hits WHERE "URL" LIKE '%google%';
+SELECT "SearchPhrase", MIN("URL"), COUNT(*) AS c FROM hits WHERE "URL" LIKE '%google%' AND "SearchPhrase" <> '' GROUP BY "SearchPhrase" ORDER BY c DESC LIMIT 10;
+SELECT "SearchPhrase", MIN("URL"), MIN("Title"), COUNT(*) AS c, COUNT(DISTINCT "UserID") FROM hits WHERE "Title" LIKE '%Google%' AND "URL" NOT LIKE '%.google.%' AND "SearchPhrase" <> '' GROUP BY "SearchPhrase" ORDER BY c DESC LIMIT 10;
+SELECT * FROM hits WHERE "URL" LIKE '%google%' ORDER BY "EventTime" LIMIT 10;
+SELECT "SearchPhrase" FROM hits WHERE "SearchPhrase" <> '' ORDER BY "EventTime" LIMIT 10;
+SELECT "SearchPhrase" FROM hits WHERE "SearchPhrase" <> '' ORDER BY "SearchPhrase" LIMIT 10;
+SELECT "SearchPhrase" FROM hits WHERE "SearchPhrase" <> '' ORDER BY "EventTime", "SearchPhrase" LIMIT 10;
+SELECT "CounterID", AVG(octet_length("URL")) AS l, COUNT(*) AS c FROM hits WHERE "URL" <> '' GROUP BY "CounterID" HAVING COUNT(*) > 100000 ORDER BY l DESC LIMIT 25;
+SELECT REGEXP_REPLACE("Referer", '^https?://(?:www\.)?([^/]+)/.*$', '\1') AS k, AVG(octet_length("Referer")) AS l, COUNT(*) AS c, MIN("Referer") FROM hits WHERE "Referer" <> '' GROUP BY k HAVING COUNT(*) > 100000 ORDER BY l DESC LIMIT 25;
+SELECT SUM("ResolutionWidth"), SUM("ResolutionWidth" + 1), SUM("ResolutionWidth" + 2), SUM("ResolutionWidth" + 3), SUM("ResolutionWidth" + 4), SUM("ResolutionWidth" + 5), SUM("ResolutionWidth" + 6), SUM("ResolutionWidth" + 7), SUM("ResolutionWidth" + 8), SUM("ResolutionWidth" + 9), SUM("ResolutionWidth" + 10), SUM("ResolutionWidth" + 11), SUM("ResolutionWidth" + 12), SUM("ResolutionWidth" + 13), SUM("ResolutionWidth" + 14), SUM("ResolutionWidth" + 15), SUM("ResolutionWidth" + 16), SUM("ResolutionWidth" + 17), SUM("ResolutionWidth" + 18), SUM("ResolutionWidth" + 19), SUM("ResolutionWidth" + 20), SUM("ResolutionWidth" + 21), SUM("ResolutionWidth" + 22), SUM("ResolutionWidth" + 23), SUM("ResolutionWidth" + 24), SUM("ResolutionWidth" + 25), SUM("ResolutionWidth" + 26), SUM("ResolutionWidth" + 27), SUM("ResolutionWidth" + 28), SUM("ResolutionWidth" + 29), SUM("ResolutionWidth" + 30), SUM("ResolutionWidth" + 31), SUM("ResolutionWidth" + 32), SUM("ResolutionWidth" + 33), SUM("ResolutionWidth" + 34), SUM("ResolutionWidth" + 35), SUM("ResolutionWidth" + 36), SUM("ResolutionWidth" + 37), SUM("ResolutionWidth" + 38), SUM("ResolutionWidth" + 39), SUM("ResolutionWidth" + 40), SUM("ResolutionWidth" + 41), SUM("ResolutionWidth" + 42), SUM("ResolutionWidth" + 43), SUM("ResolutionWidth" + 44), SUM("ResolutionWidth" + 45), SUM("ResolutionWidth" + 46), SUM("ResolutionWidth" + 47), SUM("ResolutionWidth" + 48), SUM("ResolutionWidth" + 49), SUM("ResolutionWidth" + 50), SUM("ResolutionWidth" + 51), SUM("ResolutionWidth" + 52), SUM("ResolutionWidth" + 53), SUM("ResolutionWidth" + 54), SUM("ResolutionWidth" + 55), SUM("ResolutionWidth" + 56), SUM("ResolutionWidth" + 57), SUM("ResolutionWidth" + 58), SUM("ResolutionWidth" + 59), SUM("ResolutionWidth" + 60), SUM("ResolutionWidth" + 61), SUM("ResolutionWidth" + 62), SUM("ResolutionWidth" + 63), SUM("ResolutionWidth" + 64), SUM("ResolutionWidth" + 65), SUM("ResolutionWidth" + 66), SUM("ResolutionWidth" + 67), SUM("ResolutionWidth" + 68), SUM("ResolutionWidth" + 69), SUM("ResolutionWidth" + 70), SUM("ResolutionWidth" + 71), SUM("ResolutionWidth" + 72), SUM("ResolutionWidth" + 73), SUM("ResolutionWidth" + 74), SUM("ResolutionWidth" + 75), SUM("ResolutionWidth" + 76), SUM("ResolutionWidth" + 77), SUM("ResolutionWidth" + 78), SUM("ResolutionWidth" + 79), SUM("ResolutionWidth" + 80), SUM("ResolutionWidth" + 81), SUM("ResolutionWidth" + 82), SUM("ResolutionWidth" + 83), SUM("ResolutionWidth" + 84), SUM("ResolutionWidth" + 85), SUM("ResolutionWidth" + 86), SUM("ResolutionWidth" + 87), SUM("ResolutionWidth" + 88), SUM("ResolutionWidth" + 89) FROM hits;
+SELECT "SearchEngineID", "ClientIP", COUNT(*) AS c, SUM("IsRefresh"), AVG("ResolutionWidth") FROM hits WHERE "SearchPhrase" <> '' GROUP BY "SearchEngineID", "ClientIP" ORDER BY c DESC LIMIT 10;
+SELECT "WatchID", "ClientIP", COUNT(*) AS c, SUM("IsRefresh"), AVG("ResolutionWidth") FROM hits WHERE "SearchPhrase" <> '' GROUP BY "WatchID", "ClientIP" ORDER BY c DESC LIMIT 10;
+SELECT "WatchID", "ClientIP", COUNT(*) AS c, SUM("IsRefresh"), AVG("ResolutionWidth") FROM hits GROUP BY "WatchID", "ClientIP" ORDER BY c DESC LIMIT 10;
+SELECT "URL", COUNT(*) AS c FROM hits GROUP BY "URL" ORDER BY c DESC LIMIT 10;
+SELECT 1, "URL", COUNT(*) AS c FROM hits GROUP BY 1, "URL" ORDER BY c DESC LIMIT 10;
+SELECT "ClientIP", "ClientIP" - 1, "ClientIP" - 2, "ClientIP" - 3, COUNT(*) AS c FROM hits GROUP BY "ClientIP", "ClientIP" - 1, "ClientIP" - 2, "ClientIP" - 3 ORDER BY c DESC LIMIT 10;
+SELECT "URL", COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-01' AND "EventDate" <= '2013-07-31' AND "DontCountHits" = 0 AND "IsRefresh" = 0 AND "URL" <> '' GROUP BY "URL" ORDER BY PageViews DESC LIMIT 10;
+SELECT "Title", COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-01' AND "EventDate" <= '2013-07-31' AND "DontCountHits" = 0 AND "IsRefresh" = 0 AND "Title" <> '' GROUP BY "Title" ORDER BY PageViews DESC LIMIT 10;
+SELECT "URL", COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-01' AND "EventDate" <= '2013-07-31' AND "IsRefresh" = 0 AND "IsLink" <> 0 AND "IsDownload" = 0 GROUP BY "URL" ORDER BY PageViews DESC LIMIT 10 OFFSET 1000;
+SELECT "TraficSourceID", "SearchEngineID", "AdvEngineID", CASE WHEN ("SearchEngineID" = 0 AND "AdvEngineID" = 0) THEN "Referer" ELSE '' END AS Src, "URL" AS Dst, COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-01' AND "EventDate" <= '2013-07-31' AND "IsRefresh" = 0 GROUP BY "TraficSourceID", "SearchEngineID", "AdvEngineID", Src, Dst ORDER BY PageViews DESC LIMIT 10 OFFSET 1000;
+SELECT "URLHash", "EventDate", COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-01' AND "EventDate" <= '2013-07-31' AND "IsRefresh" = 0 AND "TraficSourceID" IN (-1, 6) AND "RefererHash" = 3594120000172545465 GROUP BY "URLHash", "EventDate" ORDER BY PageViews DESC LIMIT 10 OFFSET 100;
+SELECT "WindowClientWidth", "WindowClientHeight", COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-01' AND "EventDate" <= '2013-07-31' AND "IsRefresh" = 0 AND "DontCountHits" = 0 AND "URLHash" = 2868770270353813622 GROUP BY "WindowClientWidth", "WindowClientHeight" ORDER BY PageViews DESC LIMIT 10 OFFSET 10000;
+SELECT DATE_TRUNC('minute', to_timestamp_seconds("EventTime")) AS M, COUNT(*) AS PageViews FROM hits WHERE "CounterID" = 62 AND "EventDate" >= '2013-07-14' AND "EventDate" <= '2013-07-15' AND "IsRefresh" = 0 AND "DontCountHits" = 0 GROUP BY DATE_TRUNC('minute', to_timestamp_seconds("EventTime")) ORDER BY DATE_TRUNC('minute', M) LIMIT 10 OFFSET 1000;
diff --git a/ctrlb/query b/ctrlb/query
new file mode 100755
index 0000000000..c238354718
--- /dev/null
+++ b/ctrlb/query
@@ -0,0 +1,26 @@
+#!/bin/bash
+# Harness query adapter.
+#   stdin        : one SQL query (references the `hits` view created by ./start)
+#   stdout       : the query result (the harness discards it)
+#   stderr (last): CLIENT-SIDE WALL time of the full request, in seconds
+#   exit         : non-zero on failure (harness records the try as null)
+#
+# Per ClickBench's end-to-end rule, the reported time is the wall-clock time of
+# the whole round-trip — sending the query, the server processing it, AND
+# receiving the entire result body back over HTTP — measured client-side by
+# time_sql (config.sh), NOT the server's own execution_time. time_sql writes the
+# full response to a temp file (no output suppression), validates it is a genuine
+# success payload, and returns curl's total transfer time; we then print the
+# result on stdout (harness convention) and the wall time on stderr.
+#
+set -u
+# shellcheck disable=SC1091
+source "$(dirname "$0")/config.sh"
+
+sql="$(cat)"
+resp="$(mktemp)"
+trap 'rm -f "$resp"' EXIT
+wall="$(time_sql "$sql" "$resp")" || exit 1   # diagnostics to stderr on failure
+cat "$resp"                                    # stdout: query result (harness discards it)
+printf '%s\n' "$wall" >&2                       # stderr (last line): wall-clock timing
+exit 0
diff --git a/ctrlb/results/20260725/c6a.4xlarge.json b/ctrlb/results/20260725/c6a.4xlarge.json
new file mode 100644
index 0000000000..1037f694fd
--- /dev/null
+++ b/ctrlb/results/20260725/c6a.4xlarge.json
@@ -0,0 +1,59 @@
+{
+    "system": "CtrlB (Parquet, single)",
+    "date": "2026-07-25",
+    "machine": "c6a.4xlarge",
+    "cluster_size": 1,
+    "proprietary": "yes",
+    "hardware": "cpu",
+    "tuned": "no",
+    "tags": ["Rust", "column-oriented", "stateless"],
+    "load_time": 1,
+    "data_size": 14779976446,
+    "concurrent_qps": null,
+    "concurrent_error_ratio": null,
+    "result": [
+        [0.057219, 0.006348, 0.006407],
+        [0.1142, 0.017951, 0.018006],
+        [0.151546, 0.051306, 0.051255],
+        [0.388383, 0.056765, 0.058351],
+        [0.792805, 0.672524, 0.680146],
+        [0.877893, 0.61779, 0.603849],
+        [0.1342, 0.029911, 0.03066],
+        [0.14036, 0.024943, 0.024732],
+        [1.00514, 0.837865, 0.84316],
+        [1.351156, 0.986313, 0.996949],
+        [0.479096, 0.261693, 0.258629],
+        [0.522458, 0.279282, 0.281104],
+        [0.957516, 0.771807, 0.767536],
+        [2.48341, 1.085498, 1.069834],
+        [0.978628, 0.811365, 0.798914],
+        [0.957896, 0.798397, 0.779223],
+        [2.53138, 1.401201, 1.425465],
+        [2.598286, 1.412792, 1.38067],
+        [4.827419, 2.848757, 2.892636],
+        [0.296928, 0.074382, 0.073786],
+        [9.575046, 0.899761, 0.920486],
+        [11.325031, 1.421843, 1.394637],
+        [19.969571, 2.064367, 2.020997],
+        [7.559155, 0.507291, 0.493999],
+        [0.640332, 0.11545, 0.114732],
+        [0.828446, 0.333984, 0.326986],
+        [0.871356, 0.127634, 0.109679],
+        [9.611864, 1.431164, 1.430749],
+        [9.080394, 4.299122, 4.311279],
+        [0.141247, 0.056367, 0.054103],
+        [2.19211, 0.615802, 0.60976],
+        [5.700242, 0.707985, 0.726673],
+        [4.190769, 2.719212, 2.715666],
+        [10.250022, 3.337697, 3.330951],
+        [10.252234, 3.354862, 3.357028],
+        [0.804687, 0.665063, 0.646746],
+        [0.423791, 0.184802, 0.188813],
+        [0.235386, 0.064889, 0.075321],
+        [0.31882, 0.086425, 0.083887],
+        [0.628013, 0.299021, 0.293771],
+        [0.197565, 0.032931, 0.034937],
+        [0.180183, 0.03233, 0.027772],
+        [0.167916, 0.023444, 0.023671]
+    ]
+}
diff --git a/ctrlb/results/20260728/c6a.2xlarge.json b/ctrlb/results/20260728/c6a.2xlarge.json
new file mode 100644
index 0000000000..c20cd3694f
--- /dev/null
+++ b/ctrlb/results/20260728/c6a.2xlarge.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-28",
+      "machine": "c6a.2xlarge",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 1,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.064, 0.008, 0.008],
+        [0.13, 0.027, 0.025],
+        [0.261, 0.096, 0.09],
+        [0.491, 0.094, 0.092],
+        [1.43, 1.135, 1.224],
+        [1.35, 1.034, 1.024],
+        [0.145, 0.044, 0.043],
+        [0.162, 0.038, 0.037],
+        [1.76, 1.464, 1.464],
+        [2.215, 1.776, 1.716],
+        [0.745, 0.325, 0.321],
+        [0.913, 0.349, 0.347],
+        [1.321, 1.093, 1.064],
+        [2.921, 1.642, 1.681],
+        [1.46, 1.037, 1.034],
+        [1.68, 1.332, 1.338],
+        [3.022, 2.366, 2.363],
+        [2.974, 2.385, 2.333],
+        [5.467, 4.418, 4.432],
+        [0.46, 0.085, 0.08],
+        [9.567, 1.403, 1.396],
+        [11.304, 1.845, 1.789],
+        [20.008, 2.977, 2.991],
+        [3.837, 0.321, 0.311],
+        [0.919, 0.142, 0.137],
+        [0.845, 0.427, 0.421],
+        [1.204, 0.144, 0.136],
+        [9.622, 1.628, 1.611],
+        [9.311, 7.79, 7.727],
+        [0.207, 0.085, 0.088],
+        [2.304, 0.942, 0.929],
+        [5.724, 0.964, 0.942],
+        [4.42, 4.006, 4.04],
+        [10.77, 5.025, 5.043],
+        [10.845, 5.033, 5.012],
+        [1.383, 1.139, 1.112],
+        [0.396, 0.162, 0.179],
+        [0.228, 0.074, 0.06],
+        [0.294, 0.077, 0.085],
+        [0.606, 0.288, 0.28],
+        [0.182, 0.035, 0.031],
+        [0.177, 0.031, 0.028],
+        [0.161, 0.024, 0.022]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/results/20260728/c6a.4xlarge.json b/ctrlb/results/20260728/c6a.4xlarge.json
new file mode 100644
index 0000000000..fc0611a981
--- /dev/null
+++ b/ctrlb/results/20260728/c6a.4xlarge.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-28",
+      "machine": "c6a.4xlarge",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 0,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.059, 0.007, 0.007],
+        [0.114, 0.019, 0.017],
+        [0.151, 0.053, 0.052],
+        [0.386, 0.059, 0.055],
+        [0.808, 0.675, 0.683],
+        [0.891, 0.624, 0.612],
+        [0.114, 0.032, 0.031],
+        [0.142, 0.025, 0.024],
+        [1.02, 0.846, 0.838],
+        [1.32, 0.998, 1.001],
+        [0.5, 0.264, 0.269],
+        [0.496, 0.288, 0.279],
+        [0.991, 0.781, 0.788],
+        [2.485, 1.08, 1.08],
+        [1.018, 0.823, 0.824],
+        [0.966, 0.808, 0.797],
+        [2.536, 1.431, 1.43],
+        [2.509, 1.447, 1.415],
+        [4.862, 2.881, 2.894],
+        [0.203, 0.078, 0.079],
+        [9.61, 0.97, 0.94],
+        [11.304, 1.436, 1.437],
+        [19.952, 2.091, 2.017],
+        [7.7, 0.52, 0.492],
+        [0.647, 0.123, 0.123],
+        [0.831, 0.328, 0.333],
+        [0.784, 0.125, 0.125],
+        [9.625, 1.274, 1.271],
+        [9.089, 4.288, 4.16],
+        [0.133, 0.055, 0.053],
+        [2.214, 0.626, 0.632],
+        [5.69, 0.783, 0.757],
+        [4.186, 2.771, 2.765],
+        [10.303, 3.382, 3.398],
+        [10.272, 3.429, 3.415],
+        [0.783, 0.659, 0.66],
+        [0.424, 0.184, 0.182],
+        [0.236, 0.075, 0.079],
+        [0.321, 0.088, 0.085],
+        [0.633, 0.308, 0.298],
+        [0.199, 0.033, 0.035],
+        [0.181, 0.031, 0.029],
+        [0.163, 0.023, 0.023]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/results/20260728/c6a.large.json b/ctrlb/results/20260728/c6a.large.json
new file mode 100644
index 0000000000..afb935b44f
--- /dev/null
+++ b/ctrlb/results/20260728/c6a.large.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-28",
+      "machine": "c6a.large",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 0,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.073, 0.022, 0.022],
+        [0.207, 0.064, 0.063],
+        [0.546, 0.287, 0.291],
+        [0.86, 0.269, 0.264],
+        [5.077, 4.509, 4.766],
+        [4.622, 3.943, 3.991],
+        [0.267, 0.116, 0.116],
+        [0.258, 0.094, 0.091],
+        [6.232, 5.538, 5.651],
+        [6.145, 5.38, 5.399],
+        [1.658, 0.977, 0.967],
+        [1.814, 1.077, 1.089],
+        [4.645, 3.907, 3.902],
+        [7.213, 5.989, 6.002],
+        [4.62, 3.821, 3.709],
+        [5.75, 5.185, 5.196],
+        [13.347, 15.88, 13.696],
+        [13.808, 13.127, 12.761],
+        [200.772, 261.178, 178.067],
+        [0.802, 0.223, 0.22],
+        [9.789, 5.527, 5.032],
+        [11.442, 7.989, 7.66],
+        [20.071, 14.88, 13.988],
+        [10.847, 0.743, 0.736],
+        [3.649, 0.378, 0.386],
+        [2.172, 1.388, 1.375],
+        [4.08, 0.347, 0.342],
+        [9.846, 6.098, 5.443],
+        [31.072, 28.962, 29.086],
+        [0.445, 0.235, 0.237],
+        [4.798, 3.509, 3.497],
+        [6.676, 3.395, 3.405],
+        [306.804, 381.672, 371.049],
+        [357.113, 361.249, 383.275],
+        [355.667, 410.076, 392.812],
+        [4.215, 3.857, 3.774],
+        [0.427, 0.187, 0.183],
+        [0.231, 0.068, 0.076],
+        [0.313, 0.078, 0.079],
+        [0.649, 0.312, 0.317],
+        [0.189, 0.034, 0.033],
+        [0.178, 0.03, 0.03],
+        [0.16, 0.023, 0.022]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/results/20260728/c6a.metal.json b/ctrlb/results/20260728/c6a.metal.json
new file mode 100644
index 0000000000..956442556d
--- /dev/null
+++ b/ctrlb/results/20260728/c6a.metal.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-28",
+      "machine": "c6a.metal",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 0,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.071, 0.035, 0.037],
+        [0.105, 0.054, 0.055],
+        [0.11, 0.056, 0.058],
+        [0.246, 0.051, 0.05],
+        [0.338, 0.182, 0.179],
+        [0.736, 0.192, 0.186],
+        [0.107, 0.049, 0.06],
+        [0.125, 0.07, 0.07],
+        [0.588, 0.242, 0.242],
+        [1.061, 0.357, 0.405],
+        [0.419, 0.129, 0.131],
+        [0.396, 0.144, 0.14],
+        [0.762, 0.245, 0.25],
+        [2.089, 0.462, 0.459],
+        [0.822, 0.282, 0.282],
+        [0.492, 0.209, 0.212],
+        [1.988, 0.436, 0.417],
+        [1.958, 0.43, 0.423],
+        [3.781, 0.88, 0.865],
+        [0.254, 0.061, 0.064],
+        [9.455, 0.235, 0.23],
+        [11.111, 0.403, 0.41],
+        [19.487, 0.454, 0.465],
+        [35.451, 0.675, 0.691],
+        [1.808, 0.108, 0.111],
+        [0.695, 0.134, 0.132],
+        [1.827, 0.12, 0.143],
+        [9.53, 0.345, 0.362],
+        [8.201, 1.284, 1.346],
+        [0.153, 0.058, 0.063],
+        [1.964, 0.222, 0.217],
+        [5.344, 0.315, 0.315],
+        [3.929, 1.241, 1.3],
+        [9.745, 0.835, 0.869],
+        [9.743, 0.887, 0.927],
+        [0.378, 0.198, 0.194],
+        [0.314, 0.171, 0.16],
+        [0.236, 0.1, 0.104],
+        [0.266, 0.093, 0.1],
+        [0.504, 0.263, 0.269],
+        [0.189, 0.068, 0.07],
+        [0.175, 0.064, 0.066],
+        [0.163, 0.066, 0.062]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/results/20260728/c6a.xlarge.json b/ctrlb/results/20260728/c6a.xlarge.json
new file mode 100644
index 0000000000..8f0bef07f9
--- /dev/null
+++ b/ctrlb/results/20260728/c6a.xlarge.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-28",
+      "machine": "c6a.xlarge",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 1,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.062, 0.013, 0.012],
+        [0.156, 0.041, 0.039],
+        [0.315, 0.159, 0.158],
+        [0.446, 0.153, 0.155],
+        [2.493, 2.168, 2.192],
+        [2.305, 1.936, 1.941],
+        [0.192, 0.07, 0.069],
+        [0.199, 0.061, 0.059],
+        [3.05, 2.674, 2.686],
+        [3.439, 2.932, 2.973],
+        [0.951, 0.513, 0.513],
+        [1.037, 0.559, 0.553],
+        [2.418, 1.964, 1.989],
+        [3.548, 2.949, 2.99],
+        [2.377, 1.865, 1.9],
+        [2.825, 2.504, 2.506],
+        [5.106, 4.523, 4.528],
+        [5.105, 4.455, 4.455],
+        [9.534, 9.332, 9.286],
+        [0.441, 0.129, 0.125],
+        [9.58, 2.575, 2.585],
+        [11.355, 3.281, 3.234],
+        [20.009, 5.119, 5.167],
+        [5.537, 0.438, 0.429],
+        [1.739, 0.226, 0.23],
+        [1.168, 0.749, 0.745],
+        [2.078, 0.19, 0.19],
+        [9.671, 2.867, 2.845],
+        [16.097, 14.383, 14.369],
+        [0.292, 0.134, 0.139],
+        [2.49, 1.745, 1.768],
+        [5.738, 1.758, 1.745],
+        [7.761, 7.659, 7.725],
+        [15.637, 36.103, 19.294],
+        [15.543, 32.178, 18.582],
+        [2.206, 1.943, 1.955],
+        [0.414, 0.165, 0.175],
+        [0.225, 0.077, 0.074],
+        [0.31, 0.078, 0.082],
+        [0.61, 0.288, 0.274],
+        [0.185, 0.033, 0.03],
+        [0.176, 0.033, 0.027],
+        [0.156, 0.023, 0.022]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/results/20260728/c7a.metal-48xl.json b/ctrlb/results/20260728/c7a.metal-48xl.json
new file mode 100644
index 0000000000..e5689590ff
--- /dev/null
+++ b/ctrlb/results/20260728/c7a.metal-48xl.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-28",
+      "machine": "c7a.metal-48xl",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 0,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.078, 0.037, 0.037],
+        [0.117, 0.061, 0.061],
+        [0.114, 0.067, 0.064],
+        [0.247, 0.056, 0.056],
+        [0.47, 0.216, 0.216],
+        [0.726, 0.168, 0.157],
+        [0.117, 0.054, 0.053],
+        [0.133, 0.077, 0.075],
+        [0.643, 0.3, 0.298],
+        [1.008, 0.374, 0.326],
+        [0.376, 0.136, 0.137],
+        [0.398, 0.149, 0.151],
+        [0.77, 0.192, 0.181],
+        [2.047, 0.339, 0.344],
+        [0.861, 0.203, 0.219],
+        [0.431, 0.25, 0.253],
+        [1.974, 0.387, 0.388],
+        [1.983, 0.406, 0.39],
+        [3.802, 0.913, 0.918],
+        [0.172, 0.067, 0.068],
+        [9.479, 0.213, 0.202],
+        [11.111, 0.381, 0.337],
+        [19.492, 0.417, 0.378],
+        [35.866, 0.663, 0.649],
+        [1.824, 0.099, 0.102],
+        [0.712, 0.117, 0.112],
+        [1.84, 0.118, 0.118],
+        [9.526, 0.334, 0.308],
+        [8.194, 1.348, 1.203],
+        [0.119, 0.066, 0.066],
+        [1.963, 0.241, 0.245],
+        [5.345, 0.317, 0.316],
+        [4.259, 1.702, 1.708],
+        [9.734, 0.603, 0.538],
+        [9.779, 0.576, 0.539],
+        [0.37, 0.237, 0.243],
+        [0.332, 0.159, 0.16],
+        [0.224, 0.093, 0.096],
+        [0.259, 0.1, 0.097],
+        [0.517, 0.248, 0.249],
+        [0.197, 0.076, 0.076],
+        [0.177, 0.072, 0.071],
+        [0.162, 0.069, 0.071]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/results/20260729/t3a.small.json b/ctrlb/results/20260729/t3a.small.json
new file mode 100644
index 0000000000..9e94b34b01
--- /dev/null
+++ b/ctrlb/results/20260729/t3a.small.json
@@ -0,0 +1,60 @@
+{
+      "system": "CtrlB (Parquet, single)",
+      "date": "2026-07-29",
+      "machine": "t3a.small",
+      "cluster_size": 1,
+      "proprietary": "yes",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["Rust","column-oriented","stateless"],
+      "load_time": 0,
+      "data_size": 14779976446,
+      "concurrent_qps": null,
+      "concurrent_error_ratio": null,
+      "result": [
+        [0.1, 0.046, 0.049],
+        [0.309, 0.134, 0.139],
+        [0.881, 0.573, 0.593],
+        [1.134, 0.493, 0.505],
+        [9.582, 9.825, 8.322],
+        [7.623, 7.722, 7.387],
+        [0.435, 0.275, 0.268],
+        [0.388, 0.188, 0.193],
+        [11.454, 13.831, 11.206],
+        [10.757, 9.996, 9.838],
+        [2.56, 1.765, 1.788],
+        [2.827, 2.269, 1.971],
+        [7.664, 7.303, 7.408],
+        [16.884, 16.4, 15.753],
+        [7.768, 7.483, 8],
+        [10.269, 11.14, 12.909],
+        [191.014, 186.999, 215.285],
+        [183.092, 196.608, 197.024],
+        [981.658, 932.159, 1121.537],
+        [1.134, 0.436, 0.445],
+        [12.662, 12.659, 12.568],
+        [15.546, 15.434, 15.045],
+        [25.263, 24.529, 24.448],
+        [16.212, 1.405, 1.435],
+        [5.486, 0.693, 0.708],
+        [3.369, 2.511, 2.477],
+        [6.305, 0.628, 0.629],
+        [13.979, 13.466, 13.448],
+        [70.964, 66.49, 72.413],
+        [0.744, 0.455, 0.463],
+        [8.006, 6.459, 6.501],
+        [8.72, 9.256, 8.877],
+        [1814.473, 3082.498, 1717.641],
+        [1660.825, 1911.906, 1786.068],
+        [1788.459, 1740.814, 1757.354],
+        [7.052, 6.865, 6.617],
+        [0.593, 0.375, 0.317],
+        [0.321, 0.15, 0.141],
+        [0.387, 0.144, 0.148],
+        [0.957, 0.605, 0.59],
+        [0.235, 0.064, 0.067],
+        [0.227, 0.062, 0.066],
+        [0.201, 0.05, 0.053]
+]
+  } 
+  
\ No newline at end of file
diff --git a/ctrlb/start b/ctrlb/start
new file mode 100755
index 0000000000..2d863ac0ad
--- /dev/null
+++ b/ctrlb/start
@@ -0,0 +1,46 @@
+#!/bin/bash
+#
+# Bring CtrlB up ready to query. Called by the harness once initially (before the
+# parquet is downloaded) and again at the top of every query (RESTARTABLE=yes).
+#
+# The DDL lives in ./create.sql (like the other Parquet engines). Running it here
+# infers the schema from the parquet footer. Because ./start is UNtimed, that
+# schema/footer parse is excluded from the cold-query number, which therefore
+# measures the data scan only — the same treatment the other in-place Parquet
+# engines get.
+set -u
+# shellcheck disable=SC1091
+source "$(dirname "$0")/config.sh"
+
+# Clean slate: remove any leftover container so we get a fresh session.
+stop_container
+
+# Run the CtrlB container (publishes 5080, mounts this dir so hits.parquet is
+# readable inside at the same path); discard its output.
+start_container
+
+if ! wait_for_health; then
+  # Don't hard-fail: bench_check_loop (./check) is the authoritative readiness
+  # signal and will keep polling.
+  echo "WARN: lake not healthy within ${LAKE_STARTUP}s" >&2
+fi
+
+# Session setup — the DDL comes from ./create.sql (single source of truth, same
+# as the other Parquet engines). Runs only once the parquet exists
+# (skipped on the initial pre-download start). hits.parquet is mounted into the
+# container at $PARQUET_PATH, so we rewrite create.sql's relative LOCATION to that
+# absolute path, strip comments, then POST each ';'-separated statement.
+if [ -f "$PARQUET_PATH" ]; then
+  ddl="$(sed 's/--.*$//' "$(dirname "$0")/create.sql" \
+         | sed "s#'hits.parquet'#'$PARQUET_PATH'#g" \
+         | tr '\n' ' ')"
+  while IFS= read -r -d ';' stmt; do
+    stmt="$(printf '%s' "$stmt" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')"
+    [ -z "$stmt" ] && continue
+    if ! post_sql "$stmt" > /dev/null; then
+      echo "ERROR: setup statement failed: $stmt" >&2
+      exit 1
+    fi
+  done <<< "$ddl"
+fi
+exit 0
diff --git a/ctrlb/stop b/ctrlb/stop
new file mode 100755
index 0000000000..865c3131f4
--- /dev/null
+++ b/ctrlb/stop
@@ -0,0 +1,7 @@
+#!/bin/bash
+# Stop and remove the CtrlB container.
+set -u
+# shellcheck disable=SC1091
+source "$(dirname "$0")/config.sh"
+stop_container
+exit 0
diff --git a/ctrlb/template.json b/ctrlb/template.json
new file mode 100644
index 0000000000..640b47b7be
--- /dev/null
+++ b/ctrlb/template.json
@@ -0,0 +1,7 @@
+{
+  "system": "CtrlB (Parquet, single)",
+  "proprietary": "yes",
+  "hardware": "cpu",
+  "tuned": "no",
+  "tags": ["Rust", "column-oriented", "stateless"]
+}