From 7bb77fc86087403f5764563e105a6d977faec308 Mon Sep 17 00:00:00 2001
From: Jepson Taylor <130782313+jepsontaylor@users.noreply.github.com>
Date: Fri, 25 Sep 2026 00:28:27 +0000
Subject: [PATCH] Make one-cell leaf insert the default.

A non-splitting insert places one cell and checksums the page once. REDLINEDB_LEAF_DIRECT_INSERT=0 keeps the full-page rebuild. Splits still rebuild. The smoke counter check no longer requires a rebuild on the default path. Durability stays Strict.

Claim: AGENT_CHAT.md 2026-09-25T00:40Z perf/leaf-direct-default.
Acceptance: cargo test -p redlinedb-kernel --offline --lib default_direct_insert direct_insert_matches direct_unique_conflict; cargo test -p redlinedb-kernel --offline --test index_tests; cargo test -p redlinedb-bench --offline --lib smoke_redline_and_sqlite_match_and_move
---
 AGENT_CHAT.md                                 |  4 +++
 crates/bench/src/qps.rs                       |  4 ---
 crates/kernel/src/index/mutate/insert_leaf.rs | 33 ++++++++++++++-----
 3 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/AGENT_CHAT.md b/AGENT_CHAT.md
index 89935960..8c1038df 100644
--- a/AGENT_CHAT.md
+++ b/AGENT_CHAT.md
@@ -1,5 +1,9 @@
 # RedlineDB Agent Chat
 
+## 2026-09-25T00:40Z perf/leaf-direct-default
+
+Claim: canonical checkout `/home/ubuntu/redlineDB`, branch `perf/leaf-direct-default` from `origin/main` `75ea89c204acd8cd988138815bf88a609e19b7b2`. Non-splitting leaf insert places one cell and checksums once. `REDLINEDB_LEAF_DIRECT_INSERT=0` keeps the full-page rebuild. Durability stays Strict. No worktree.
+
 ## 2026-09-24T20:40Z bench/qps-counter-smoke
 
 Claim: canonical checkout `/home/ubuntu/redlineDB`, branch `bench/qps-counter-smoke` from `origin/main` `c90ed5fc1ff3570c5a2d5c712853bec588f5d626`. The queries-per-second smoke test asserts the Redline counter delta is non-zero for checksum bytes, leaf rebuilds, and row gets or decodes. No speed threshold, no scale change, no Postgres, no default SQL change. No worktree.
diff --git a/crates/bench/src/qps.rs b/crates/bench/src/qps.rs
index 8af3f04b..9c29405a 100644
--- a/crates/bench/src/qps.rs
+++ b/crates/bench/src/qps.rs
@@ -675,10 +675,6 @@ mod tests {
             .expect("redline");
         let observe = redline.observe.as_ref().expect("redline counters");
         assert!(observe.checksum_bytes > 0);
-        assert!(
-            observe.rewrite_leaf_calls > 0,
-            "default leaf insert still rebuilds the page"
-        );
         assert!(observe.relation_gets > 0 || observe.sql_row_decodes > 0);
         assert!(
             report
diff --git a/crates/kernel/src/index/mutate/insert_leaf.rs b/crates/kernel/src/index/mutate/insert_leaf.rs
index 819b607c..db4368a2 100644
--- a/crates/kernel/src/index/mutate/insert_leaf.rs
+++ b/crates/kernel/src/index/mutate/insert_leaf.rs
@@ -1,7 +1,7 @@
-//! One-cell leaf insert. Off unless `REDLINEDB_LEAF_DIRECT_INSERT=1`.
+//! One-cell leaf insert. On unless `REDLINEDB_LEAF_DIRECT_INSERT=0`.
 //!
-//! The default path still rebuilds the leaf in `rewrite_leaf`. Official
-//! CI does not set the variable, so suite `all` keeps today's pages.
+//! A non-splitting insert places one cell and checksums the page once.
+//! The full-page rebuild remains for splits and for the env override.
 
 use std::cell::Cell;
 
@@ -20,7 +20,8 @@ pub(super) fn direct_leaf_insert_enabled() -> bool {
     }
     std::env::var("REDLINEDB_LEAF_DIRECT_INSERT")
         .ok()
-        .is_some_and(|value| value == "1")
+        .as_deref()
+        != Some("0")
 }
 
 pub(super) fn insert_one_cell(page: &mut Page, slot: usize, entry: &Entry) -> Result<()> {
@@ -62,8 +63,8 @@ mod tests {
     struct ForceGuard;
 
     impl ForceGuard {
-        fn enable() -> Self {
-            force_direct(Some(true));
+        fn set(value: bool) -> Self {
+            force_direct(Some(value));
             Self
         }
     }
@@ -101,19 +102,31 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn default_direct_insert_is_on_unless_zero() {
+        force_direct(None);
+        let disabled = std::env::var("REDLINEDB_LEAF_DIRECT_INSERT")
+            .ok()
+            .as_deref()
+            == Some("0");
+        assert_eq!(super::direct_leaf_insert_enabled(), !disabled);
+    }
+
     #[test]
     fn direct_insert_matches_rewrite_and_skips_rebuild() {
+        let _off = ForceGuard::set(false);
         let (_rewrite_dir, rewrite) = fresh(IndexUniqueness::NonUnique).expect("rewrite index");
         let before_rewrite = observe::snapshot();
         fill(&rewrite, 32).expect("rewrite fill");
         let rewrite_calls = observe::snapshot().since(before_rewrite).rewrite_leaf_calls;
+        drop(_off);
 
-        let _guard = ForceGuard::enable();
+        let _on = ForceGuard::set(true);
         let (_direct_dir, direct) = fresh(IndexUniqueness::NonUnique).expect("direct index");
         let before_direct = observe::snapshot();
         fill(&direct, 32).expect("direct fill");
         let direct_calls = observe::snapshot().since(before_direct).rewrite_leaf_calls;
-        drop(_guard);
+        drop(_on);
 
         assert!(rewrite_calls >= 32, "rewrite path rebuilt {rewrite_calls}");
         assert_eq!(direct_calls, 0, "direct path rebuilt the leaf");
@@ -131,13 +144,15 @@ mod tests {
 
     #[test]
     fn direct_unique_conflict_matches_rewrite() {
+        let _off = ForceGuard::set(false);
         let (_rewrite_dir, rewrite) = fresh(IndexUniqueness::Unique).expect("rewrite unique");
         rewrite.insert_unique(1, b"same", row(1, 0)).expect("first");
         let rewrite_err = rewrite
             .insert_unique(1, b"same", row(2, 0))
             .expect_err("conflict");
+        drop(_off);
 
-        let _guard = ForceGuard::enable();
+        let _on = ForceGuard::set(true);
         let (_direct_dir, direct) = fresh(IndexUniqueness::Unique).expect("direct unique");
         direct.insert_unique(1, b"same", row(1, 0)).expect("first");
         let direct_err = direct