diff --git a/scripts/mem-repro/.gitignore b/scripts/mem-repro/.gitignore
new file mode 100644
index 00000000..fbca2253
--- /dev/null
+++ b/scripts/mem-repro/.gitignore
@@ -0,0 +1 @@
+results/
diff --git a/scripts/mem-repro/README.md b/scripts/mem-repro/README.md
new file mode 100644
index 00000000..707cae1d
--- /dev/null
+++ b/scripts/mem-repro/README.md
@@ -0,0 +1,77 @@
+# Passthrough memory reproduction harness
+
+Tooling used to reproduce and root-cause the passthrough memory leak (BUG-300):
+Proxy leaks ~1 KB per statement when running in **passthrough with an empty
+encrypt config** (no encryption configured), until the pod is OOM-killed.
+
+See [`summary.md`](summary.md) for the write-up, root cause, and fix.
+
+## Layout
+
+| Path | What |
+| --- | --- |
+| `soak.sh` | Sustained load + RSS sampling — the script that surfaces the leak |
+| `run-docker.sh` | One load run + cgroup sampling against the `proxy` container |
+| `run.sh` | Same, but for a proxy running as a host process |
+| `sample-rss.sh` | Standalone RSS sampler (host process) |
+| `schema.sql` | Plaintext `credit_data_order_v2` table (all traffic is passthrough) |
+| `loadgen/` | Go load generator (parameterised INSERTs via pgx) |
+| `prepleak/` | Go probe for the named-prepared-statement retention path |
+| `go.mod` | Go module covering `loadgen/` and `prepleak/` |
+
+Raw run outputs land in `results/` (git-ignored).
+
+## Prerequisites
+
+- Postgres + a built proxy container (`mise run postgres:up`, `mise run proxy:up`).
+- Apply the plaintext schema once: `mise run postgres:psql < scripts/mem-repro/schema.sql`.
+- **No local Go needed** — `run-docker.sh` / `soak.sh` run the generator in a
+  `golang` container. (`run.sh` is the host-process variant and does need Go.)
+
+## Reproducing the leak
+
+The trigger is an **empty encrypt config**. Make the config empty, then soak:
+
+```bash
+# 1. Empty the encrypt config (unconfigured passthrough)
+mise run postgres:psql -c "UPDATE eql_v2_configuration SET state='inactive' WHERE state='active';"
+# 2. (re)start the proxy so it loads the empty config, then drive sustained load
+scripts/mem-repro/soak.sh empty-config 6 50000 16
+```
+
+`soak.sh <label> [rounds] [count] [workers]` runs N rounds of inserts and samples
+the proxy container's cgroup `memory.current` throughout (plus a cooldown to see
+whether RSS is released). On an affected build RSS climbs monotonically and does
+not drop; on a fixed build it plateaus.
+
+## Variants
+
+Compare by restarting the proxy with different env / config, then re-running the soak:
+
+| Variant | How |
+| --- | --- |
+| baseline (glibc) | empty config, default settings |
+| `MALLOC_ARENA_MAX=2` | set the env on the proxy — tests glibc arena bloat (ruled out) |
+| `DISABLE_MAPPING` | `CS_DEVELOPMENT__DISABLE_MAPPING=true` — confirmed leak-free (the workaround) |
+| config present (control) | restore an `active` row in `eql_v2_configuration` — no leak |
+
+> An allocator comparison (jemalloc) was also run during the investigation and
+> showed no difference (the leak is logical retention, not fragmentation). The
+> jemalloc global-allocator feature is **not** included here — it is tracked as a
+> separate decision.
+
+## Named-statement probe
+
+```bash
+# inside the golang container, or locally from this dir:
+go run ./prepleak -count 100000 -dsn '<dsn>'
+```
+Exercises the separate (bounded, freed-on-disconnect) named-prepared-statement
+retention noted in `analysis.md`.
+
+## Notes
+
+- Run on Linux for production-faithful numbers (glibc arena behaviour, cgroup
+  memory). macOS is directional only.
+- Default proxy log level is `debug`, which is allocation-heavy; set
+  `CS_LOG__LEVEL=warn` for clean memory measurements.
diff --git a/scripts/mem-repro/go.mod b/scripts/mem-repro/go.mod
new file mode 100644
index 00000000..dd343c1b
--- /dev/null
+++ b/scripts/mem-repro/go.mod
@@ -0,0 +1,19 @@
+// Go module for the memory-reproduction load generators (loadgen/, prepleak/).
+// Not part of the Rust build; used only by scripts/mem-repro.
+module cipherstash-proxy-mem-repro
+
+go 1.22
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/jackc/pgx/v5 v5.7.2
+)
+
+require (
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	golang.org/x/crypto v0.31.0 // indirect
+	golang.org/x/sync v0.10.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
+)
diff --git a/scripts/mem-repro/go.sum b/scripts/mem-repro/go.sum
new file mode 100644
index 00000000..491a74e3
--- /dev/null
+++ b/scripts/mem-repro/go.sum
@@ -0,0 +1,30 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
+github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/scripts/mem-repro/loadgen/main.go b/scripts/mem-repro/loadgen/main.go
new file mode 100644
index 00000000..d6eb61b4
--- /dev/null
+++ b/scripts/mem-repro/loadgen/main.go
@@ -0,0 +1,209 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func main() {
+	var (
+		dsn     = flag.String("dsn", "postgres://bloomuser:password@127.0.0.1:6432/pdts_db?sslmode=disable", "Database connection string (DSN)")
+		count   = flag.Int("count", 10000, "Number of inserts to perform")
+		workers = flag.Int("workers", 10, "Number of concurrent workers")
+	)
+	flag.Parse()
+
+	if *dsn == "" {
+		log.Fatal("DSN is required. Use -dsn flag to provide database connection string")
+	}
+
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, *dsn)
+	if err != nil {
+		log.Fatal("Failed to create pgx pool:", err)
+	}
+	defer pool.Close()
+
+	if err := pool.Ping(ctx); err != nil {
+		log.Fatal("Failed to ping database:", err)
+	}
+
+	log.Printf("Connected to database, inserting %d records with %d workers...", *count, *workers)
+
+	orgID := "539008ae-e1ff-42ed-8a58-e3588befea9d"
+	testJSON := []byte(`{
+		"reportId": "RPT-2024-001234567890",
+		"generatedAt": "2024-01-15T14:30:00Z",
+		"consumer": {
+			"firstName": "John",
+			"lastName": "Doe",
+			"dateOfBirth": "1985-06-15",
+			"ssn": "XXX-XX-1234",
+			"addresses": [
+				{
+					"type": "current",
+					"street": "123 Main Street",
+					"city": "Springfield",
+					"state": "IL",
+					"zipCode": "62701",
+					"since": "2020-03-01"
+				},
+				{
+					"type": "previous",
+					"street": "456 Oak Avenue",
+					"city": "Chicago",
+					"state": "IL",
+					"zipCode": "60601",
+					"since": "2015-08-15"
+				}
+			],
+			"employment": {
+				"employer": "Acme Corporation",
+				"position": "Software Engineer",
+				"income": 95000,
+				"since": "2019-01-15"
+			}
+		},
+		"creditScore": {
+			"value": 742,
+			"model": "FICO8",
+			"range": {"min": 300, "max": 850},
+			"factors": [
+				{"code": "01", "description": "Length of time accounts have been established"},
+				{"code": "14", "description": "Number of accounts with delinquency"},
+				{"code": "07", "description": "Too many inquiries last 12 months"}
+			]
+		},
+		"accounts": [
+			{
+				"accountNumber": "XXXX-XXXX-XXXX-4567",
+				"creditor": "First National Bank",
+				"type": "creditCard",
+				"status": "open",
+				"openDate": "2018-05-20",
+				"creditLimit": 15000,
+				"balance": 3250,
+				"monthlyPayment": 150,
+				"paymentHistory": ["OK","OK","OK","OK","OK","OK","OK","OK","OK","OK","OK","OK"]
+			},
+			{
+				"accountNumber": "LOAN-789012",
+				"creditor": "Auto Finance LLC",
+				"type": "autoLoan",
+				"status": "open",
+				"openDate": "2022-02-10",
+				"originalAmount": 28000,
+				"balance": 18500,
+				"monthlyPayment": 485,
+				"paymentHistory": ["OK","OK","OK","OK","OK","OK","OK","OK","OK","OK","OK","OK"]
+			},
+			{
+				"accountNumber": "MTG-555666777",
+				"creditor": "Home Mortgage Corp",
+				"type": "mortgage",
+				"status": "open",
+				"openDate": "2020-03-15",
+				"originalAmount": 320000,
+				"balance": 295000,
+				"monthlyPayment": 1850,
+				"paymentHistory": ["OK","OK","OK","OK","OK","OK","OK","OK","OK","OK","OK","OK"]
+			}
+		],
+		"inquiries": [
+			{"date": "2024-01-10", "creditor": "Capital One", "type": "hard"},
+			{"date": "2023-11-05", "creditor": "Chase Bank", "type": "hard"},
+			{"date": "2023-09-20", "creditor": "American Express", "type": "soft"}
+		],
+		"publicRecords": [],
+		"collections": [],
+		"metadata": {
+			"version": "2.1.0",
+			"provider": "TestProvider",
+			"requestId": "REQ-2024-ABCDEF123456",
+			"processingTimeMs": 245
+		}
+	}`)
+
+	query := `
+		INSERT INTO credit_data_order_v2 (id, organization_id, order_id, account_review, full_report, raw_report, created_at, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+	`
+
+	var completed int64
+	var wg sync.WaitGroup
+	jobs := make(chan int, *count)
+
+	// Start workers
+	for w := 0; w < *workers; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for range jobs {
+				id := uuid.New().String()
+				orderID := uuid.New().String()
+				now := time.Now()
+
+				tx, err := pool.Begin(ctx)
+				if err != nil {
+					log.Printf("Insert failed to begin tx: %v", err)
+					atomic.AddInt64(&completed, 1)
+					continue
+				}
+
+				// NOTE: The original repro issued `SET CIPHERSTASH.KEYSET_NAME`
+				// here to mirror repo.setKeysetNameOnTx. For the passthrough
+				// (no-encryption) memory test that SET is omitted: this proxy has
+				// a default keyset configured, which rejects the SET, and it is
+				// irrelevant to the per-statement type-check churn we measure.
+
+				_, err = tx.Exec(ctx, query,
+					id,
+					orgID,
+					orderID,
+					false,
+					testJSON,
+					testJSON,
+					now,
+					now,
+				)
+				if err != nil {
+					tx.Rollback(ctx)
+					log.Printf("Insert failed: %v", err)
+					atomic.AddInt64(&completed, 1)
+					continue
+				}
+
+				if err := tx.Commit(ctx); err != nil {
+					log.Printf("Insert failed to commit: %v", err)
+					atomic.AddInt64(&completed, 1)
+					continue
+				}
+
+				c := atomic.AddInt64(&completed, 1)
+				if c%100 == 0 || c == int64(*count) {
+					log.Printf("Inserted %d/%d records", c, *count)
+				}
+			}
+		}()
+	}
+
+	// Send jobs
+	for i := 0; i < *count; i++ {
+		jobs <- i
+	}
+	close(jobs)
+
+	// Wait for all workers to finish
+	wg.Wait()
+
+	fmt.Println("Done!")
+}
diff --git a/scripts/mem-repro/prepleak/main.go b/scripts/mem-repro/prepleak/main.go
new file mode 100644
index 00000000..9f2f1e65
--- /dev/null
+++ b/scripts/mem-repro/prepleak/main.go
@@ -0,0 +1,43 @@
+// Tests the one unbounded code path identified in the proxy: named prepared
+// statements are only removed from the per-connection statements map on an
+// explicit Close/Deallocate. A client that prepares many uniquely-named
+// statements on a single long-lived connection (and never deallocates) makes
+// that map grow without bound.
+//
+// This uses a SINGLE connection and prepares -count uniquely-named statements.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+
+	"github.com/jackc/pgx/v5"
+)
+
+func main() {
+	dsn := flag.String("dsn", "postgres://cipherstash:password@proxy:6432/cipherstash?sslmode=disable", "DSN")
+	count := flag.Int("count", 100000, "number of uniquely-named prepared statements")
+	flag.Parse()
+
+	ctx := context.Background()
+	conn, err := pgx.Connect(ctx, *dsn)
+	if err != nil {
+		log.Fatal("connect:", err)
+	}
+	defer conn.Close(ctx)
+
+	for i := 0; i < *count; i++ {
+		name := fmt.Sprintf("stmt_%d", i)
+		// Unique name, same SQL. Never deallocated -> proxy retains one entry per name.
+		_, err := conn.Prepare(ctx, name, "SELECT id, full_report FROM credit_data_order_v2 WHERE id = $1")
+		if err != nil {
+			log.Fatalf("prepare %d: %v", i, err)
+		}
+		if (i+1)%10000 == 0 {
+			log.Printf("prepared %d/%d", i+1, *count)
+		}
+	}
+	log.Printf("Done: %d uniquely-named prepared statements on one connection", *count)
+}
diff --git a/scripts/mem-repro/run-docker.sh b/scripts/mem-repro/run-docker.sh
new file mode 100755
index 00000000..2cb14bb1
--- /dev/null
+++ b/scripts/mem-repro/run-docker.sh
@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+#
+# Containerised variant of run.sh: drives the Go load generator from a `golang`
+# container against the proxy running in the `proxy` container, while sampling
+# the proxy container's cgroup memory (the k8s-relevant number).
+#
+# Prereqs:
+#   - `proxy` and `postgres` containers running (mise run proxy:up).
+#   - schema.sql applied to postgres.
+#
+# Usage:
+#   ./run-docker.sh <label> [count] [workers]
+#
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${HERE}/../.." && pwd)"
+
+LABEL="${1:?usage: run-docker.sh <label> [count] [workers]}"
+COUNT="${2:-20000}"
+WORKERS="${3:-16}"
+
+# DB creds for the proxy connection (proxy listens on 6432 inside its network).
+PGUSER="${CS_DATABASE__USERNAME:-cipherstash}"
+PGPASS="${CS_DATABASE__PASSWORD_ESCAPED_FOR_TESTS:-p%40ssword}"
+PGDB="${CS_DATABASE__NAME:-cipherstash}"
+DSN="postgres://${PGUSER}:${PGPASS}@proxy:6432/${PGDB}?sslmode=disable"
+
+# Resolve the docker network the proxy is attached to.
+NET="$(docker inspect proxy --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}}{{end}}' | head -n1)"
+OUT="${HERE}/results/${LABEL}.csv"
+mkdir -p "${HERE}/results"
+echo "epoch_s,elapsed_s,mem_bytes" > "${OUT}"
+
+echo "== Run '${LABEL}': ${COUNT} inserts, ${WORKERS} workers (network: ${NET}) =="
+
+# Background cgroup sampler: memory.current is what kubelet watches for OOM.
+( START=$(date +%s)
+  while docker inspect -f '{{.State.Running}}' proxy 2>/dev/null | grep -q true; do
+    now=$(date +%s)
+    mem=$(docker exec proxy cat /sys/fs/cgroup/memory.current 2>/dev/null || echo 0)
+    echo "${now},$(( now - START )),${mem}" >> "${OUT}"
+    sleep 1
+  done ) &
+SAMPLER_PID=$!
+trap 'kill "${SAMPLER_PID}" 2>/dev/null || true' EXIT
+
+sleep 3  # baseline
+
+# Run the load generator in a golang container on the proxy's network.
+docker run --rm --network "${NET}" \
+  -v "${HERE}:/src" -w /src \
+  -e GOFLAGS=-mod=mod \
+  golang:1.22-bookworm \
+  bash -c "go mod tidy >/dev/null 2>&1; go run ./loadgen -count ${COUNT} -workers ${WORKERS} -dsn '${DSN}'"
+
+echo "Load complete. Cooldown 60s to observe memory release..."
+sleep 60
+
+kill "${SAMPLER_PID}" 2>/dev/null || true
+trap - EXIT
+
+PEAK=$(tail -n +2 "${OUT}" | awk -F, 'BEGIN{m=0}{if($3>m)m=$3}END{print m}')
+LAST=$(tail -n1 "${OUT}" | awk -F, '{print $3}')
+awk -v p="$PEAK" -v l="$LAST" 'BEGIN{printf "Peak: %.1f MiB | Post-cooldown: %.1f MiB\n", p/1048576, l/1048576}'
+echo "Timeseries: ${OUT}"
diff --git a/scripts/mem-repro/run.sh b/scripts/mem-repro/run.sh
new file mode 100755
index 00000000..5da0e9f7
--- /dev/null
+++ b/scripts/mem-repro/run.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+#
+# Drive one memory-reproduction run against an already-running proxy and record
+# its RSS for the duration of the load.
+#
+# Prereqs (do these once, per the README):
+#   - Proxy is already running (built in the variant you want to measure).
+#   - Postgres is up and `schema.sql` has been applied.
+#   - Go is installed (for the load generator at the repo root).
+#
+# Usage:
+#   ./run.sh <label> [count] [workers] [dsn]
+#
+# Example:
+#   ./run.sh glibc-baseline 20000 16 "postgres://user:pass@127.0.0.1:6432/db?sslmode=disable"
+#
+# Output:
+#   results/<label>.csv  -- RSS timeseries (see sample-rss.sh)
+#
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${HERE}/../.." && pwd)"
+
+LABEL="${1:?usage: run.sh <label> [count] [workers] [dsn]}"
+COUNT="${2:-20000}"
+WORKERS="${3:-16}"
+DSN="${4:-postgres://bloomuser:password@127.0.0.1:6432/pdts_db?sslmode=disable}"
+
+PROXY_PATTERN="cipherstash-proxy"
+OUT="${HERE}/results/${LABEL}.csv"
+
+if ! pgrep -f "${PROXY_PATTERN}" >/dev/null; then
+  echo "Proxy ('${PROXY_PATTERN}') is not running. Start it first (see README)." >&2
+  exit 1
+fi
+
+echo "== Run '${LABEL}': ${COUNT} inserts, ${WORKERS} workers =="
+
+# Start the RSS sampler in the background.
+"${HERE}/sample-rss.sh" "${PROXY_PATTERN}" "${OUT}" 1 &
+SAMPLER_PID=$!
+# Always stop the sampler, even on error/interrupt.
+trap 'kill "${SAMPLER_PID}" 2>/dev/null || true' EXIT
+
+# Give the sampler a moment to capture a pre-load baseline.
+sleep 3
+
+# Run the load generator (Go module + loadgen package live alongside this script).
+( cd "${HERE}" && go run ./loadgen -count "${COUNT}" -workers "${WORKERS}" -dsn "${DSN}" )
+
+# Capture a short cooldown tail so we can see whether RSS is released after the
+# load stops (the key signal: glibc tends to hold it; jemalloc releases it).
+echo "Load complete. Sampling cooldown for 60s to observe memory release..."
+sleep 60
+
+kill "${SAMPLER_PID}" 2>/dev/null || true
+trap - EXIT
+
+PEAK_KB="$(tail -n +2 "${OUT}" | awk -F, 'BEGIN{m=0} {if($4>m)m=$4} END{print m}')"
+LAST_KB="$(tail -n1 "${OUT}" | awk -F, '{print $4}')"
+echo "Done. Peak RSS: $(( PEAK_KB / 1024 )) MiB | Post-cooldown RSS: $(( LAST_KB / 1024 )) MiB"
+echo "Timeseries: ${OUT}"
diff --git a/scripts/mem-repro/sample-rss.sh b/scripts/mem-repro/sample-rss.sh
new file mode 100755
index 00000000..c64be8de
--- /dev/null
+++ b/scripts/mem-repro/sample-rss.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+#
+# Sample the resident set size (RSS) of a running process over time and append
+# it to a CSV. Works on Linux and macOS (`ps` reports RSS/VSZ in KiB on both).
+#
+# Usage:
+#   ./sample-rss.sh <process-name-pattern> <output.csv> [interval_seconds]
+#
+# Example:
+#   ./sample-rss.sh cipherstash-proxy results/glibc-baseline.csv 1
+#
+# Stop with Ctrl-C (or send SIGTERM). The CSV columns are:
+#   epoch_s,elapsed_s,pid,rss_kb,vsz_kb
+#
+set -euo pipefail
+
+PATTERN="${1:?usage: sample-rss.sh <process-pattern> <output.csv> [interval]}"
+OUT="${2:?usage: sample-rss.sh <process-pattern> <output.csv> [interval]}"
+INTERVAL="${3:-1}"
+
+mkdir -p "$(dirname "$OUT")"
+echo "epoch_s,elapsed_s,pid,rss_kb,vsz_kb" > "$OUT"
+
+# Resolve the PID once so we follow a single process for the whole run.
+PID="$(pgrep -f "$PATTERN" | head -n1 || true)"
+if [[ -z "${PID}" ]]; then
+  echo "No process matching '${PATTERN}' is running. Start the proxy first." >&2
+  exit 1
+fi
+
+echo "Sampling RSS of pid ${PID} (pattern '${PATTERN}') every ${INTERVAL}s -> ${OUT}" >&2
+START="$(date +%s)"
+
+peak=0
+while kill -0 "$PID" 2>/dev/null; do
+  now="$(date +%s)"
+  elapsed=$(( now - START ))
+  # rss= and vsz= suppress headers; values are in KiB.
+  read -r rss vsz < <(ps -o rss=,vsz= -p "$PID" 2>/dev/null || echo "0 0")
+  rss="${rss:-0}"; vsz="${vsz:-0}"
+  echo "${now},${elapsed},${PID},${rss},${vsz}" >> "$OUT"
+  if (( rss > peak )); then peak=$rss; fi
+  sleep "$INTERVAL"
+done
+
+echo "Process ${PID} exited. Peak RSS: $(( peak / 1024 )) MiB. Samples in ${OUT}" >&2
diff --git a/scripts/mem-repro/schema.sql b/scripts/mem-repro/schema.sql
new file mode 100644
index 00000000..225fc515
--- /dev/null
+++ b/scripts/mem-repro/schema.sql
@@ -0,0 +1,19 @@
+-- Schema for the passthrough memory reproduction.
+--
+-- This deliberately uses PLAINTEXT columns only (jsonb, not eql_v2_encrypted)
+-- so the proxy runs in the customer's reported configuration: passthrough,
+-- no encrypted columns. Note that unless CS_DEVELOPMENT__DISABLE_MAPPING=true,
+-- the proxy still fully parses and type-checks every statement against this
+-- schema before discarding the result -- which is the allocation churn we are
+-- measuring.
+
+CREATE TABLE IF NOT EXISTS credit_data_order_v2 (
+    id              uuid PRIMARY KEY,
+    organization_id uuid NOT NULL,
+    order_id        uuid NOT NULL,
+    account_review  boolean NOT NULL DEFAULT false,
+    full_report     jsonb NOT NULL,
+    raw_report      jsonb NOT NULL,
+    created_at      timestamptz NOT NULL DEFAULT now(),
+    updated_at      timestamptz NOT NULL DEFAULT now()
+);
diff --git a/scripts/mem-repro/soak.sh b/scripts/mem-repro/soak.sh
new file mode 100755
index 00000000..08cad691
--- /dev/null
+++ b/scripts/mem-repro/soak.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+#
+# Soak test: drive sustained passthrough load against the running `proxy`
+# container while sampling its cgroup memory, to reveal slow/monotonic growth.
+# Runs several back-to-back rounds of simple-protocol inserts (max per-statement
+# churn) and keeps sampling through a cooldown to see whether RSS is released.
+#
+# Usage: ./soak.sh <label> [rounds] [count_per_round] [workers]
+#
+set -euo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${HERE}/../.." && pwd)"
+LABEL="${1:?usage: soak.sh <label> [rounds] [count] [workers]}"
+ROUNDS="${2:-6}"
+COUNT="${3:-50000}"
+WORKERS="${4:-16}"
+NET="$(docker inspect proxy --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}}{{end}}' | head -n1)"
+# Cached extended protocol (pgx default) — reliable for the jsonb payload.
+DSN="postgres://cipherstash:password@proxy:6432/cipherstash?sslmode=disable"
+OUT="${HERE}/results/${LABEL}.csv"; mkdir -p "${HERE}/results"; echo "epoch_s,elapsed_s,mem_bytes" > "${OUT}"
+
+# background sampler
+( S=$(date +%s); while docker inspect -f '{{.State.Running}}' proxy 2>/dev/null | grep -q true; do
+    m=$(docker exec proxy cat /sys/fs/cgroup/memory.current 2>/dev/null || echo 0)
+    echo "$(date +%s),$(( $(date +%s)-S )),${m}" >> "${OUT}"; sleep 2; done ) &
+SP=$!; trap 'kill "${SP}" 2>/dev/null || true' EXIT
+sleep 3
+echo "[$LABEL] baseline RSS: $(docker exec proxy cat /sys/fs/cgroup/memory.current|awk '{printf "%.1f",$1/1048576}') MiB"
+for r in $(seq 1 "${ROUNDS}"); do
+  docker run --rm --network "${NET}" -v "${HERE}:/src" -w /src -e GOFLAGS=-mod=mod golang:1.22-bookworm \
+    bash -c "go mod tidy >/dev/null 2>&1; go run ./loadgen -count ${COUNT} -workers ${WORKERS} -dsn '${DSN}'" >/dev/null 2>&1 || true
+  echo "[$LABEL] round ${r}/${ROUNDS} done; RSS=$(docker exec proxy cat /sys/fs/cgroup/memory.current|awk '{printf "%.1f",$1/1048576}') MiB"
+done
+echo "[$LABEL] cooldown 45s..."; sleep 45
+kill "${SP}" 2>/dev/null || true; trap - EXIT
+awk -F, 'NR>1{if($3>mx)mx=$3; if(mn==0||$3<mn)mn=$3; l=$3; if(NR==2)f=$3} END{printf "[%s] baseline=%.1f  peak=%.1f  final=%.1f  (min=%.1f) MiB\n","'"$LABEL"'",f/1048576,mx/1048576,l/1048576,mn/1048576}' "${OUT}"
\ No newline at end of file
diff --git a/scripts/mem-repro/summary.md b/scripts/mem-repro/summary.md
new file mode 100644
index 00000000..576a1e16
--- /dev/null
+++ b/scripts/mem-repro/summary.md
@@ -0,0 +1,79 @@
+# Passthrough memory leak — summary
+
+Proxy leaks memory per statement when running in **passthrough with no encrypt
+config** (unconfigured deployment). Slow RSS climb → OOM. Reproduced locally;
+root-caused. Configured deployments are unaffected.
+
+## Immediate fix for the customer (no upgrade required)
+
+Set on the affected (unconfigured/passthrough) proxy:
+
+```
+CS_DEVELOPMENT__DISABLE_MAPPING=true
+```
+
+Confirmed leak-free in testing. It's the correct setting for a deployment that
+does no encryption: the proxy forwards traffic untouched and never builds the
+per-statement state that leaks. Works on their current **2.1.23** — no upgrade,
+no dependency on the auth issue.
+
+Other options (only if relevant): configure at least one encrypted column (also
+suppresses the leak, but only if encryption is actually wanted); raising the
+memory limit / periodic restarts are stopgaps, not fixes.
+
+## Does upgrading fix it? No.
+
+The leak is in **both 2.1.23 and 2.2.1** — and **2.2.1 is worse**. `v2.2.1` is
+the latest release and is the same commit as current `main`; the faulty code is
+present there. So:
+
+- Resolving the ZeroKMS auth regression only **unblocks** an upgrade to 2.2.1.
+- That upgrade does **not** fix the leak — it would make it worse.
+- A code fix (below) must be written and released. Until then, use the
+  `DISABLE_MAPPING` workaround.
+
+(The auth 401 some deployments hit on 2.2.1 is unrelated to the leak: 2.2.x
+derives the CTS/ZeroKMS endpoint from the region in `CS_WORKSPACE_CRN` as part of
+the per-region CTS migration. A workspace that hasn't migrated needs its
+CRN/endpoint updated — tracked separately.)
+
+## Root cause
+
+In passthrough, the backend short-circuits before per-statement cleanup:
+
+- `postgresql/backend.rs:175` — `if self.context.is_passthrough() { write; return }`
+  returns **before** `complete_execution()` + `finish_session()`
+  (`backend.rs:211-212` / `227-228`), the only drains for the per-connection
+  `execute` and `session_metrics` queues.
+- The frontend still enqueues for **every** statement: `start_session()`
+  (`frontend.rs:380` / `722`) and `set_execute*()` (`context/mod.rs:300-302`).
+- Result: each passthrough statement adds queue entries that are never popped →
+  unbounded growth (~1 KB/statement measured).
+
+Why only empty config: `is_passthrough() = encrypt_config.is_empty() ||
+mapping_disabled()` (`context/mod.rs:780`). With a config present, even
+plaintext statements are `is_passthrough()=false` → cleanup runs → no leak.
+
+Why `DISABLE_MAPPING` avoids it: that path makes the **frontend** early-return at
+`frontend.rs:172`, *before* `start_session()`, so the queues are never populated.
+
+## Reproduction (Linux/glibc container, 6×50k = 300k cached extended inserts)
+
+| Version / config | baseline | after 6 rounds | post-cooldown |
+| --- | --- | --- | --- |
+| 2.2.1, empty config | 36 MiB | 315 MiB | **317 MiB — no release** |
+| 2.1.23, empty config | 28 MiB | 84 MiB | **83 MiB — no release** |
+| 2.2.1, config present | 24 MiB | 37 MiB | 37 MiB (flat) |
+| 2.2.1, empty config + `DISABLE_MAPPING=true` | 31 MiB | 34 MiB | 22 MiB (flat) |
+
+Harness: `scripts/mem-repro/` (`soak.sh`). Allocator is irrelevant (glibc ==
+jemalloc); the leak is logical retention, not fragmentation.
+
+## The fix
+
+Landed in **PR #395** (BUG-300): the `backend.rs` passthrough branch now calls
+`complete_execution()` + `finish_session()` on execute-terminating messages, so
+the `execute` / `session_metrics` queues are drained in passthrough too. Includes
+a regression test (`statement_lifecycle_does_not_grow_queues`) asserting the
+queues stay bounded. Verified with this harness: the empty-config soak that
+climbed to 317 MiB now plateaus at ~49 MiB.