diff --git a/.gitignore b/.gitignore
index 7ccf2c44..4e8bc9ae 100644
--- a/.gitignore
+++ b/.gitignore
@@ -127,3 +127,4 @@ link/sdks/typescript/client/.npmrc
 /link/kalam-client/sdks/typescript/client/.wasm-target-size-current
 /link/kalam-client/sdks/typescript/client/.wasm-target-size-current2
 /benchv2/logs
+/backend/kalamdb-nightly
diff --git a/Cargo.lock b/Cargo.lock
index 5fc6191b..d174b294 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2849,6 +2849,17 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
+[[package]]
+name = "filetime"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "libredox",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -4362,6 +4373,7 @@ dependencies = [
  "async-trait",
  "chrono",
  "datafusion",
+ "flate2",
  "kalamdb-commons",
  "kalamdb-core",
  "kalamdb-observability",
@@ -4374,6 +4386,7 @@ dependencies = [
  "parking_lot",
  "serde",
  "serde_json",
+ "tar",
  "tempfile",
  "tokio",
  "tracing",
@@ -4904,7 +4917,10 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1744e39d1d6a9948f4f388969627434e31128196de472883b39f148769bfe30a"
 dependencies = [
+ "bitflags 2.11.0",
  "libc",
+ "plain",
+ "redox_syscall 0.7.5",
 ]
 
 [[package]]
@@ -5627,7 +5643,7 @@ checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.5.18",
  "smallvec",
  "windows-link",
 ]
@@ -5908,6 +5924,12 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
 [[package]]
 name = "plotters"
 version = "0.3.7"
@@ -6442,6 +6464,15 @@ dependencies = [
  "bitflags 2.11.0",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4666a1a60d8412eab19d94f6d13dcc9cea0a5ef4fdf6a5db306537413c661b1b"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.5.2"
@@ -7418,6 +7449,17 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
+[[package]]
+name = "tar"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
 [[package]]
 name = "target-lexicon"
 version = "0.13.5"
@@ -9004,6 +9046,16 @@ dependencies = [
  "time",
 ]
 
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix",
+]
+
 [[package]]
 name = "yasna"
 version = "0.5.2"
diff --git a/backend/crates/kalamdb-api/src/http/sql/models/sql_request.rs b/backend/crates/kalamdb-api/src/http/sql/models/sql_request.rs
index a23fb402..08a307f5 100644
--- a/backend/crates/kalamdb-api/src/http/sql/models/sql_request.rs
+++ b/backend/crates/kalamdb-api/src/http/sql/models/sql_request.rs
@@ -42,8 +42,10 @@ pub struct QueryRequest {
     pub params: Option<Vec<JsonValue>>,
 
     /// Optional namespace ID for unqualified table names.
-    /// When set, queries like `SELECT * FROM users` resolve to `namespace_id.users`.
-    /// Set via `USE namespace` command in CLI clients.
+    /// When set, this request resolves queries like `SELECT * FROM users` to
+    /// `namespace_id.users`.
+    /// Interactive clients can populate this after a successful `USE namespace`
+    /// command; the value is request-scoped on the backend.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub namespace_id: Option<NamespaceId>,
 }
diff --git a/backend/crates/kalamdb-api/src/http/sql/statements.rs b/backend/crates/kalamdb-api/src/http/sql/statements.rs
index a78453c4..4ab9945d 100644
--- a/backend/crates/kalamdb-api/src/http/sql/statements.rs
+++ b/backend/crates/kalamdb-api/src/http/sql/statements.rs
@@ -272,6 +272,26 @@ mod tests {
         assert_eq!(parsed.sql, "INSERT INTO default.t VALUES (1)");
     }
 
+    #[test]
+    fn parse_execute_as_short_alias_quoted_username() {
+        let parsed = parse_execute_statement(
+            "EXECUTE AS 'alice' (SELECT * FROM default.todos WHERE id = 1);",
+        )
+        .expect("short alias with quoted username should parse");
+
+        assert_eq!(parsed.execute_as_username, Some("alice".to_string()));
+        assert_eq!(parsed.sql, "SELECT * FROM default.todos WHERE id = 1");
+    }
+
+    #[test]
+    fn parse_execute_as_short_alias_bare_username() {
+        let parsed = parse_execute_statement("execute as bob (INSERT INTO default.t VALUES (1))")
+            .expect("short alias with bare username should parse");
+
+        assert_eq!(parsed.execute_as_username, Some("bob".to_string()));
+        assert_eq!(parsed.sql, "INSERT INTO default.t VALUES (1)");
+    }
+
     #[test]
     fn parse_execute_as_user_bare_no_space_before_paren() {
         let parsed = parse_execute_statement("EXECUTE AS USER alice(SELECT 1)")
diff --git a/backend/crates/kalamdb-core/src/sql/context/execution_context.rs b/backend/crates/kalamdb-core/src/sql/context/execution_context.rs
index 3da2391f..ed238635 100644
--- a/backend/crates/kalamdb-core/src/sql/context/execution_context.rs
+++ b/backend/crates/kalamdb-core/src/sql/context/execution_context.rs
@@ -263,8 +263,10 @@ impl ExecutionContext {
 
     /// Get the current default namespace (schema) from DataFusion session config
     ///
-    /// This reads `datafusion.catalog.default_schema` from the session configuration.
-    /// The default schema is set to "default" initially and can be changed using:
+    /// This reads `datafusion.catalog.default_schema` from the request-scoped
+    /// session configuration.
+    /// The default schema is set to "default" initially and can be changed within
+    /// the current request or multi-statement batch using:
     /// - `USE namespace`
     /// - `USE NAMESPACE namespace`
     /// - `SET NAMESPACE namespace`
diff --git a/backend/crates/kalamdb-dialect/src/batch_execution.rs b/backend/crates/kalamdb-dialect/src/batch_execution.rs
index cafb2ab2..968994d1 100644
--- a/backend/crates/kalamdb-dialect/src/batch_execution.rs
+++ b/backend/crates/kalamdb-dialect/src/batch_execution.rs
@@ -518,6 +518,15 @@ mod tests {
         assert_eq!(statements[1], "SELECT 2");
     }
 
+    #[test]
+    fn parse_batch_statements_falls_back_for_short_execute_as() {
+        let sql = "EXECUTE AS alice (SELECT 1); SELECT 2;";
+        let statements = parse_batch_statements(sql).unwrap();
+        assert_eq!(statements.len(), 2);
+        assert_eq!(statements[0], "EXECUTE AS alice (SELECT 1)");
+        assert_eq!(statements[1], "SELECT 2");
+    }
+
     #[test]
     fn parse_batch_statements_preserves_file_placeholder_statement() {
         let sql = "INSERT INTO uploads SELECT * FROM FILE('orders.csv');";
@@ -553,12 +562,12 @@ mod tests {
 
     #[test]
     fn parse_execution_batch_reports_statement_index() {
-        let err = parse_execution_batch("SELECT 1; EXECUTE AS USER '' (SELECT 2)").unwrap_err();
+        let err = parse_execution_batch("SELECT 1; EXECUTE AS '' (SELECT 2)").unwrap_err();
         assert_eq!(
             err,
             ExecutionBatchParseError::Statement {
                 statement_index: 2,
-                message: "EXECUTE AS USER username cannot be empty".to_string(),
+                message: "EXECUTE AS username cannot be empty".to_string(),
             }
         );
     }
@@ -566,7 +575,7 @@ mod tests {
     #[test]
     fn prepare_execution_batch_preserves_execute_as_username() {
         let prepared =
-            prepare_execution_batch("SELECT 1; EXECUTE AS USER alice (SELECT 2)", |statement| {
+            prepare_execution_batch("SELECT 1; EXECUTE AS alice (SELECT 2)", |statement| {
                 Ok::<_, String>(statement.sql.clone())
             })
             .unwrap();
diff --git a/backend/crates/kalamdb-dialect/src/ddl/backup_namespace.rs b/backend/crates/kalamdb-dialect/src/ddl/backup_namespace.rs
index 4963deaf..fcd7aa42 100644
--- a/backend/crates/kalamdb-dialect/src/ddl/backup_namespace.rs
+++ b/backend/crates/kalamdb-dialect/src/ddl/backup_namespace.rs
@@ -3,21 +3,26 @@
 //! Parses SQL statements like:
 //! - BACKUP DATABASE TO '/backups/kalamdb_backup.tar.gz'
 //!
-//! Backs up the entire database (data directory + server.toml).
+//! Backs up the entire database to either a server-side directory or a
+//! `.tar.gz` / `.tgz` archive.
 
 use crate::ddl::DdlResult;
 
 /// BACKUP DATABASE statement
 ///
-/// Backs up the entire database to a compressed archive.
+/// Backs up the entire database.
 /// The backup includes:
 /// - RocksDB data directory
 /// - Parquet storage files
 /// - Raft snapshots
 /// - server.toml configuration
+///
+/// If the target path ends with `.tar.gz` or `.tgz`, the backup is written as a
+/// single archive file. Otherwise KalamDB writes the backup layout into the
+/// target directory.
 #[derive(Debug, Clone, PartialEq)]
 pub struct BackupDatabaseStatement {
-    /// Backup destination path (should end in .tar.gz)
+    /// Backup destination path on the server filesystem.
     pub backup_path: String,
 }
 
@@ -125,6 +130,14 @@ mod tests {
         assert_eq!(stmt.backup_path, "/backups/kalamdb.tar.gz");
     }
 
+    #[test]
+    fn test_parse_backup_database_directory_path() {
+        let stmt =
+            BackupDatabaseStatement::parse("BACKUP DATABASE TO '/backups/kalamdb-nightly'")
+                .unwrap();
+        assert_eq!(stmt.backup_path, "/backups/kalamdb-nightly");
+    }
+
     #[test]
     fn test_parse_backup_database_missing_to() {
         let result = BackupDatabaseStatement::parse("BACKUP DATABASE");
diff --git a/backend/crates/kalamdb-dialect/src/ddl/restore_namespace.rs b/backend/crates/kalamdb-dialect/src/ddl/restore_namespace.rs
index 5531c62b..b95be6c8 100644
--- a/backend/crates/kalamdb-dialect/src/ddl/restore_namespace.rs
+++ b/backend/crates/kalamdb-dialect/src/ddl/restore_namespace.rs
@@ -3,13 +3,14 @@
 //! Parses SQL statements like:
 //! - RESTORE DATABASE FROM '/backups/kalamdb_backup.tar.gz'
 //!
-//! Restores the entire database from a compressed archive.
+//! Restores the entire database from either a backup directory or a `.tar.gz`
+//! / `.tgz` archive.
 
 use crate::ddl::DdlResult;
 
 /// RESTORE DATABASE statement
 ///
-/// Restores the entire database from a compressed archive backup.
+/// Restores the entire database from a backup path on the server filesystem.
 /// The restore replaces:
 /// - RocksDB data directory
 /// - Parquet storage files
@@ -17,7 +18,7 @@ use crate::ddl::DdlResult;
 /// - server.toml configuration
 #[derive(Debug, Clone, PartialEq)]
 pub struct RestoreDatabaseStatement {
-    /// Backup source path (should be a .tar.gz file)
+    /// Backup source path on the server filesystem.
     pub backup_path: String,
 }
 
@@ -107,6 +108,14 @@ mod tests {
         assert_eq!(stmt.backup_path, "/backups/kalamdb.tar.gz");
     }
 
+    #[test]
+    fn test_parse_restore_database_directory_path() {
+        let stmt =
+            RestoreDatabaseStatement::parse("RESTORE DATABASE FROM '/backups/kalamdb-nightly'")
+                .unwrap();
+        assert_eq!(stmt.backup_path, "/backups/kalamdb-nightly");
+    }
+
     #[test]
     fn test_parse_restore_database_missing_from() {
         let result = RestoreDatabaseStatement::parse("RESTORE DATABASE");
diff --git a/backend/crates/kalamdb-dialect/src/ddl/user_commands.rs b/backend/crates/kalamdb-dialect/src/ddl/user_commands.rs
index 1013ae3d..ab035f7c 100644
--- a/backend/crates/kalamdb-dialect/src/ddl/user_commands.rs
+++ b/backend/crates/kalamdb-dialect/src/ddl/user_commands.rs
@@ -7,7 +7,8 @@
 //!
 //! Uses sqlparser-rs tokenizer for consistent identifier and string handling.
 
-use kalamdb_commons::{AuthType, Role};
+use kalamdb_commons::{AuthType, Role, StorageId};
+use kalamdb_system::providers::storages::models::StorageMode;
 use serde::{Deserialize, Serialize};
 use sqlparser::{
     dialect::GenericDialect,
@@ -54,6 +55,13 @@ fn parse_role(role_str: &str) -> Result<Role, UserCommandError> {
     }
 }
 
+fn parse_storage_mode(storage_mode_str: &str) -> Result<StorageMode, UserCommandError> {
+    StorageMode::from_str_opt(storage_mode_str).ok_or_else(|| UserCommandError {
+        message: format!("Invalid storage mode '{}'", storage_mode_str),
+        hint: Some("Valid storage modes: table, region".to_string()),
+    })
+}
+
 /// Extract identifier or string value from a token
 fn extract_identifier(token: &Token) -> Option<String> {
     match token {
@@ -94,6 +102,7 @@ fn filter_tokens(tokens: Vec<Token>) -> Vec<Token> {
 /// CREATE USER username WITH PASSWORD 'password' ROLE role_name [EMAIL 'email'];
 /// CREATE USER username WITH OAUTH ROLE role_name [EMAIL 'email'];
 /// CREATE USER username WITH INTERNAL ROLE role_name;
+/// CREATE USER username WITH PASSWORD 'password' ROLE role_name [EMAIL 'email'] [STORAGE_MODE table|region] [STORAGE_ID 'storage'];
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct CreateUserStatement {
@@ -102,6 +111,8 @@ pub struct CreateUserStatement {
     pub role: Role,
     pub email: Option<String>,
     pub password: Option<String>,
+    pub storage_mode: StorageMode,
+    pub storage_id: Option<StorageId>,
 }
 
 impl CreateUserStatement {
@@ -197,18 +208,54 @@ impl CreateUserStatement {
         })?;
         let role = parse_role(&role_str)?;
 
-        // Optional EMAIL
-        let email = if is_keyword(iter.peek().unwrap_or(&&Token::EOF), "EMAIL") {
-            iter.next(); // consume EMAIL
-            Some(extract_identifier(iter.next().unwrap_or(&Token::EOF)).ok_or_else(|| {
-                UserCommandError {
-                    message: "Expected email address after EMAIL".to_string(),
-                    hint: Some("Email must be quoted: EMAIL 'user@example.com'".to_string()),
+        let mut email = None;
+        let mut storage_mode = StorageMode::Table;
+        let mut storage_id = None;
+
+        while let Some(token) = iter.peek() {
+            if is_keyword(token, "EMAIL") {
+                if email.is_some() {
+                    return Err(UserCommandError {
+                        message: "EMAIL specified more than once".to_string(),
+                        hint: Some("Use a single EMAIL clause".to_string()),
+                    });
                 }
-            })?)
-        } else {
-            None
-        };
+                iter.next();
+                email = Some(extract_identifier(iter.next().unwrap_or(&Token::EOF)).ok_or_else(
+                    || UserCommandError {
+                        message: "Expected email address after EMAIL".to_string(),
+                        hint: Some("Email must be quoted: EMAIL 'user@example.com'".to_string()),
+                    },
+                )?);
+                continue;
+            }
+
+            if is_keyword(token, "STORAGE_MODE") {
+                iter.next();
+                let value = extract_identifier(iter.next().unwrap_or(&Token::EOF)).ok_or_else(|| {
+                    UserCommandError {
+                        message: "Expected storage mode after STORAGE_MODE".to_string(),
+                        hint: Some("Valid storage modes: table, region".to_string()),
+                    }
+                })?;
+                storage_mode = parse_storage_mode(&value)?;
+                continue;
+            }
+
+            if is_keyword(token, "STORAGE_ID") {
+                iter.next();
+                let value = extract_identifier(iter.next().unwrap_or(&Token::EOF)).ok_or_else(|| {
+                    UserCommandError {
+                        message: "Expected storage ID after STORAGE_ID".to_string(),
+                        hint: Some("Storage ID can be quoted: STORAGE_ID 'local'".to_string()),
+                    }
+                })?;
+                storage_id = Some(StorageId::from(value));
+                continue;
+            }
+
+            break;
+        }
 
         Ok(CreateUserStatement {
             username,
@@ -216,6 +263,8 @@ impl CreateUserStatement {
             role,
             email,
             password,
+            storage_mode,
+            storage_id,
         })
     }
 }
@@ -231,6 +280,9 @@ impl CreateUserStatement {
 /// ALTER USER username SET PASSWORD 'new_password';
 /// ALTER USER username SET ROLE new_role;
 /// ALTER USER username SET EMAIL 'new_email@example.com';
+/// ALTER USER username SET STORAGE_MODE table|region;
+/// ALTER USER username SET STORAGE_ID 'storage_id';
+/// ALTER USER username SET STORAGE_ID NULL;
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct AlterUserStatement {
@@ -244,6 +296,8 @@ pub enum UserModification {
     SetPassword(String),
     SetRole(Role),
     SetEmail(String),
+    SetStorageMode(StorageMode),
+    SetStorageId(Option<StorageId>),
 }
 
 impl UserModification {
@@ -254,6 +308,13 @@ impl UserModification {
             UserModification::SetPassword(_) => "SetPassword([REDACTED])".to_string(),
             UserModification::SetRole(role) => format!("SetRole({:?})", role),
             UserModification::SetEmail(email) => format!("SetEmail({})", email),
+            UserModification::SetStorageMode(storage_mode) => {
+                format!("SetStorageMode({})", storage_mode)
+            },
+            UserModification::SetStorageId(Some(storage_id)) => {
+                format!("SetStorageId({})", storage_id)
+            },
+            UserModification::SetStorageId(None) => "SetStorageId(NULL)".to_string(),
         }
     }
 }
@@ -271,13 +332,19 @@ impl AlterUserStatement {
         if !is_keyword(iter.next().unwrap_or(&Token::EOF), "ALTER") {
             return Err(UserCommandError {
                 message: "Expected ALTER".to_string(),
-                hint: Some("Syntax: ALTER USER username SET PASSWORD|ROLE|EMAIL ...".to_string()),
+                hint: Some(
+                    "Syntax: ALTER USER username SET PASSWORD|ROLE|EMAIL|STORAGE_MODE|STORAGE_ID ..."
+                        .to_string(),
+                ),
             });
         }
         if !is_keyword(iter.next().unwrap_or(&Token::EOF), "USER") {
             return Err(UserCommandError {
                 message: "Expected USER after ALTER".to_string(),
-                hint: Some("Syntax: ALTER USER username SET PASSWORD|ROLE|EMAIL ...".to_string()),
+                hint: Some(
+                    "Syntax: ALTER USER username SET PASSWORD|ROLE|EMAIL|STORAGE_MODE|STORAGE_ID ..."
+                        .to_string(),
+                ),
             });
         }
 
@@ -293,11 +360,14 @@ impl AlterUserStatement {
         if !is_keyword(iter.next().unwrap_or(&Token::EOF), "SET") {
             return Err(UserCommandError {
                 message: "Expected SET after username".to_string(),
-                hint: Some("Syntax: ALTER USER username SET PASSWORD|ROLE|EMAIL ...".to_string()),
+                hint: Some(
+                    "Syntax: ALTER USER username SET PASSWORD|ROLE|EMAIL|STORAGE_MODE|STORAGE_ID ..."
+                        .to_string(),
+                ),
             });
         }
 
-        // Modification type: PASSWORD, ROLE, or EMAIL
+        // Modification type: PASSWORD, ROLE, EMAIL, STORAGE_MODE, or STORAGE_ID
         let mod_token = iter.next().unwrap_or(&Token::EOF);
         let modification = if is_keyword(mod_token, "PASSWORD") {
             let pwd = extract_identifier(iter.next().unwrap_or(&Token::EOF)).ok_or_else(|| {
@@ -330,11 +400,34 @@ impl AlterUserStatement {
                     }
                 })?;
             UserModification::SetEmail(email)
+        } else if is_keyword(mod_token, "STORAGE_MODE") {
+            let storage_mode =
+                extract_identifier(iter.next().unwrap_or(&Token::EOF)).ok_or_else(|| {
+                    UserCommandError {
+                        message: "Expected storage mode after SET STORAGE_MODE".to_string(),
+                        hint: Some("Valid storage modes: table, region".to_string()),
+                    }
+                })?;
+            UserModification::SetStorageMode(parse_storage_mode(&storage_mode)?)
+        } else if is_keyword(mod_token, "STORAGE_ID") {
+            let token = iter.next().unwrap_or(&Token::EOF);
+            if is_keyword(token, "NULL") {
+                UserModification::SetStorageId(None)
+            } else {
+                let storage_id = extract_identifier(token).ok_or_else(|| UserCommandError {
+                    message: "Expected storage ID or NULL after SET STORAGE_ID".to_string(),
+                    hint: Some(
+                        "Use SET STORAGE_ID 'local' or SET STORAGE_ID NULL".to_string(),
+                    ),
+                })?;
+                UserModification::SetStorageId(Some(StorageId::from(storage_id)))
+            }
         } else {
             return Err(UserCommandError {
-                message: "Expected PASSWORD, ROLE, or EMAIL after SET".to_string(),
+                message: "Expected PASSWORD, ROLE, EMAIL, STORAGE_MODE, or STORAGE_ID after SET"
+                    .to_string(),
                 hint: Some(
-                    "Valid modifications: SET PASSWORD 'pass', SET ROLE admin, SET EMAIL 'x@y.com'"
+                    "Valid modifications: SET PASSWORD 'pass', SET ROLE admin, SET EMAIL 'x@y.com', SET STORAGE_MODE region, SET STORAGE_ID 'local'"
                         .to_string(),
                 ),
             });
@@ -435,6 +528,16 @@ mod tests {
         assert_eq!(stmt.password, Some("secure123".to_string()));
         assert_eq!(stmt.role, Role::Service);
         assert_eq!(stmt.email, Some("alice@example.com".to_string()));
+        assert_eq!(stmt.storage_mode, StorageMode::Table);
+        assert_eq!(stmt.storage_id, None);
+    }
+
+    #[test]
+    fn test_create_user_with_storage_options() {
+        let sql = "CREATE USER 'alice' WITH PASSWORD 'secure123' ROLE user STORAGE_MODE region STORAGE_ID 's3_eu'";
+        let stmt = CreateUserStatement::parse(sql).unwrap();
+        assert_eq!(stmt.storage_mode, StorageMode::Region);
+        assert_eq!(stmt.storage_id, Some(StorageId::from("s3_eu")));
     }
 
     #[test]
@@ -542,12 +645,50 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_alter_user_set_storage_mode() {
+        let sql = "ALTER USER bob SET STORAGE_MODE region";
+        let stmt = AlterUserStatement::parse(sql).unwrap();
+        assert_eq!(stmt.username, "bob");
+        if let UserModification::SetStorageMode(storage_mode) = stmt.modification {
+            assert_eq!(storage_mode, StorageMode::Region);
+        } else {
+            panic!("Expected SetStorageMode");
+        }
+    }
+
+    #[test]
+    fn test_alter_user_set_storage_id() {
+        let sql = "ALTER USER bob SET STORAGE_ID 's3_eu'";
+        let stmt = AlterUserStatement::parse(sql).unwrap();
+        assert_eq!(stmt.username, "bob");
+        if let UserModification::SetStorageId(storage_id) = stmt.modification {
+            assert_eq!(storage_id, Some(StorageId::from("s3_eu")));
+        } else {
+            panic!("Expected SetStorageId");
+        }
+    }
+
+    #[test]
+    fn test_alter_user_set_storage_id_null() {
+        let sql = "ALTER USER bob SET STORAGE_ID NULL";
+        let stmt = AlterUserStatement::parse(sql).unwrap();
+        assert_eq!(stmt.username, "bob");
+        if let UserModification::SetStorageId(storage_id) = stmt.modification {
+            assert_eq!(storage_id, None);
+        } else {
+            panic!("Expected SetStorageId");
+        }
+    }
+
     #[test]
     fn test_alter_user_invalid_modification() {
         let sql = "ALTER USER alice SET UNKNOWN 'value'";
         let result = AlterUserStatement::parse(sql);
         assert!(result.is_err());
-        assert!(result.unwrap_err().contains("PASSWORD, ROLE, or EMAIL"));
+        assert!(result
+            .unwrap_err()
+            .contains("PASSWORD, ROLE, EMAIL, STORAGE_MODE, or STORAGE_ID"));
     }
 
     // DROP USER tests
@@ -622,4 +763,20 @@ mod tests {
 
         assert_eq!(display, "SetEmail(alice@example.com)");
     }
+
+    #[test]
+    fn test_user_modification_display_for_audit_storage_mode() {
+        let modification = UserModification::SetStorageMode(StorageMode::Region);
+        let display = modification.display_for_audit();
+
+        assert_eq!(display, "SetStorageMode(region)");
+    }
+
+    #[test]
+    fn test_user_modification_display_for_audit_storage_id() {
+        let modification = UserModification::SetStorageId(Some(StorageId::from("s3_eu")));
+        let display = modification.display_for_audit();
+
+        assert_eq!(display, "SetStorageId(s3_eu)");
+    }
 }
diff --git a/backend/crates/kalamdb-dialect/src/execute_as.rs b/backend/crates/kalamdb-dialect/src/execute_as.rs
index abf411f2..ef092185 100644
--- a/backend/crates/kalamdb-dialect/src/execute_as.rs
+++ b/backend/crates/kalamdb-dialect/src/execute_as.rs
@@ -1,57 +1,60 @@
-//! EXECUTE AS USER parsing utilities
+//! EXECUTE AS parsing utilities
 //!
-//! Provides a single shared implementation for parsing `EXECUTE AS USER` SQL
-//! wrappers.  Both the API execution handler and the cluster forwarding logic
-//! delegate to these functions so there is **one** canonical parser.
+//! Provides a single shared implementation for parsing `EXECUTE AS` SQL
+//! wrappers. Both the API execution handler and the cluster forwarding logic
+//! delegate to these functions so there is one canonical parser.
 //!
 //! Grammar:
 //! ```text
-//! EXECUTE AS USER <username> ( <inner_sql> )
+//! EXECUTE AS <user_id> ( <inner_sql> )
+//! EXECUTE AS USER <user_id> ( <inner_sql> )  // legacy compatibility
 //! ```
-//! `<username>` may be single-quoted (`'alice'`) or bare (`alice`).
+//! `<user_id>` may be single-quoted (`'alice'`) or bare (`alice`).
 //! The inner SQL must be exactly one statement.
 
 use crate::split_statements;
 
-/// Prefix used for case-insensitive matching.
-const EXECUTE_AS_PREFIX: &str = "EXECUTE AS USER";
-/// Byte length of the prefix — used for fast slice comparisons.
-const EXECUTE_AS_PREFIX_LEN: usize = EXECUTE_AS_PREFIX.len(); // 15
+/// Prefixes used for case-insensitive matching.
+const EXECUTE_AS_PREFIXES: [&str; 2] = ["EXECUTE AS USER", "EXECUTE AS"];
 
-/// Result of parsing an `EXECUTE AS USER` envelope.
+/// Result of parsing an `EXECUTE AS` envelope.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ExecuteAsEnvelope {
-    /// The user identifier that follows `EXECUTE AS USER`.
+    /// The user identifier that follows `EXECUTE AS` or legacy `EXECUTE AS USER`.
     pub username: String,
     /// The inner SQL statement (parentheses stripped).
     pub inner_sql: String,
 }
 
-/// Check whether `sql` starts with `EXECUTE AS USER` (case-insensitive).
+#[inline]
+fn match_execute_as_prefix(sql: &str) -> Option<usize> {
+    let trimmed = sql.trim();
+    EXECUTE_AS_PREFIXES.iter().find_map(|prefix| {
+        let prefix_len = prefix.len();
+        (trimmed.len() >= prefix_len
+            && trimmed.as_bytes()[..prefix_len].eq_ignore_ascii_case(prefix.as_bytes()))
+        .then_some(prefix_len)
+    })
+}
+
+/// Check whether `sql` starts with canonical `EXECUTE AS` or legacy `EXECUTE AS USER`
+/// (case-insensitive).
 ///
 /// This is a very cheap check that avoids any allocation.
 #[inline]
 pub fn is_execute_as(sql: &str) -> bool {
-    let trimmed = sql.trim();
-    trimmed.len() >= EXECUTE_AS_PREFIX_LEN
-        && trimmed.as_bytes()[..EXECUTE_AS_PREFIX_LEN]
-            .eq_ignore_ascii_case(EXECUTE_AS_PREFIX.as_bytes())
+    match_execute_as_prefix(sql).is_some()
 }
 
-/// Extract just the inner SQL from an `EXECUTE AS USER '...' (...)` wrapper.
+/// Extract just the inner SQL from an `EXECUTE AS '...' (...)` wrapper.
 ///
-/// Returns `Some(inner_sql)` if the SQL matches the EXECUTE AS USER pattern,
+/// Returns `Some(inner_sql)` if the SQL matches an EXECUTE AS pattern,
 /// `None` otherwise.  This is intentionally lightweight — it only needs to
 /// strip the wrapper so callers (e.g. statement classifier) can inspect the
 /// actual SQL statement without allocating a full parsed result.
 pub fn extract_inner_sql(sql: &str) -> Option<String> {
     let trimmed = sql.trim();
-    if trimmed.len() < EXECUTE_AS_PREFIX_LEN
-        || !trimmed.as_bytes()[..EXECUTE_AS_PREFIX_LEN]
-            .eq_ignore_ascii_case(EXECUTE_AS_PREFIX.as_bytes())
-    {
-        return None;
-    }
+    match_execute_as_prefix(trimmed)?;
 
     let open_paren = trimmed.find('(')?;
     let close_paren = find_matching_close_paren(trimmed, open_paren)?;
@@ -92,7 +95,7 @@ fn parse_single_quoted(input: &str) -> Result<(String, &str), String> {
         return Ok((value, &input[idx + 1..]));
     }
 
-    Err("EXECUTE AS USER username quote was not closed".to_string())
+    Err("EXECUTE AS username quote was not closed".to_string())
 }
 
 fn find_matching_close_paren(input: &str, open_idx: usize) -> Option<usize> {
@@ -148,14 +151,16 @@ fn find_matching_close_paren(input: &str, open_idx: usize) -> Option<usize> {
     None
 }
 
-/// Fully parse an `EXECUTE AS USER` envelope, extracting the username and the
+/// Fully parse an `EXECUTE AS` envelope, extracting the username and the
 /// parenthesised inner SQL.
 ///
-/// The username may be quoted (`'alice'`) or bare (`alice`).
+/// Supports both canonical `EXECUTE AS <user_id> (...)` and
+/// legacy `EXECUTE AS USER <user_id> (...)`.
+/// The user id may be quoted (`'alice'`) or bare (`alice`).
 /// Bare usernames extend up to the first whitespace or `(` character.
 ///
 /// Returns:
-/// - `Ok(Some(envelope))` when the statement is an EXECUTE AS USER wrapper
+/// - `Ok(Some(envelope))` when the statement is an EXECUTE AS wrapper
 /// - `Ok(None)` when the statement is a normal SQL statement (no wrapper)
 /// - `Err(msg)` on syntax errors inside the wrapper
 pub fn parse_execute_as(statement: &str) -> Result<Option<ExecuteAsEnvelope>, String> {
@@ -164,58 +169,54 @@ pub fn parse_execute_as(statement: &str) -> Result<Option<ExecuteAsEnvelope>, St
         return Err("Empty SQL statement".to_string());
     }
 
-    // Fast prefix check without allocating an uppercased copy.
-    if trimmed.len() < EXECUTE_AS_PREFIX_LEN
-        || !trimmed.as_bytes()[..EXECUTE_AS_PREFIX_LEN]
-            .eq_ignore_ascii_case(EXECUTE_AS_PREFIX.as_bytes())
-    {
+    let Some(prefix_len) = match_execute_as_prefix(trimmed) else {
         return Ok(None);
-    }
+    };
 
-    let after_prefix = trimmed[EXECUTE_AS_PREFIX_LEN..].trim_start();
+    let after_prefix = trimmed[prefix_len..].trim_start();
 
     // --- Username extraction (quoted or bare) ---
     let (username, rest): (String, &str) = if after_prefix.starts_with('\'') {
         let (parsed_username, rest) = parse_single_quoted(after_prefix)?;
         let uname = parsed_username.trim();
         if uname.is_empty() {
-            return Err("EXECUTE AS USER username cannot be empty".to_string());
+            return Err("EXECUTE AS username cannot be empty".to_string());
         }
         (uname.to_string(), rest.trim_start())
     } else {
-        // Bare: EXECUTE AS USER alice (...)
+        // Bare: EXECUTE AS alice (...) or EXECUTE AS USER alice (...)
         // Username extends until whitespace or '('.
         let end = after_prefix
             .find(|c: char| c.is_whitespace() || c == '(')
             .unwrap_or(after_prefix.len());
         let uname = after_prefix[..end].trim();
         if uname.is_empty() {
-            return Err("EXECUTE AS USER username cannot be empty".to_string());
+            return Err("EXECUTE AS username cannot be empty".to_string());
         }
         (uname.to_string(), after_prefix[end..].trim_start())
     };
 
     // --- Parenthesised SQL body ---
     if !rest.starts_with('(') {
-        return Err("EXECUTE AS USER must wrap SQL in parentheses".to_string());
+        return Err("EXECUTE AS must wrap SQL in parentheses".to_string());
     }
 
     let close_idx = find_matching_close_paren(rest, 0)
-        .ok_or_else(|| "EXECUTE AS USER missing closing ')'".to_string())?;
+        .ok_or_else(|| "EXECUTE AS missing closing ')'".to_string())?;
     let inner_sql = rest[1..close_idx].trim();
     if inner_sql.is_empty() {
-        return Err("EXECUTE AS USER requires a non-empty inner SQL statement".to_string());
+        return Err("EXECUTE AS requires a non-empty inner SQL statement".to_string());
     }
 
     let trailing = rest[close_idx + 1..].trim();
     if !trailing.is_empty() {
-        return Err("EXECUTE AS USER must contain exactly one wrapped SQL statement".to_string());
+        return Err("EXECUTE AS must contain exactly one wrapped SQL statement".to_string());
     }
 
     let inner_statements = split_statements(inner_sql)
-        .map_err(|e| format!("Failed to parse inner SQL for EXECUTE AS USER: {}", e))?;
+        .map_err(|e| format!("Failed to parse inner SQL for EXECUTE AS: {}", e))?;
     if inner_statements.len() != 1 {
-        return Err("EXECUTE AS USER can only wrap a single SQL statement".to_string());
+        return Err("EXECUTE AS can only wrap a single SQL statement".to_string());
     }
 
     Ok(Some(ExecuteAsEnvelope {
@@ -235,7 +236,9 @@ mod tests {
     #[test]
     fn is_execute_as_positive() {
         assert!(is_execute_as("EXECUTE AS USER 'alice' (SELECT 1)"));
+        assert!(is_execute_as("EXECUTE AS 'alice' (SELECT 1)"));
         assert!(is_execute_as("execute as user bob (SELECT 1)"));
+        assert!(is_execute_as("execute as bob (SELECT 1)"));
         assert!(is_execute_as("  EXECUTE AS USER 'x' (SELECT 1)  "));
     }
 
@@ -256,6 +259,12 @@ mod tests {
         assert_eq!(inner.as_deref(), Some("SELECT * FROM t"));
     }
 
+    #[test]
+    fn extract_inner_sql_short_alias() {
+        let inner = extract_inner_sql("EXECUTE AS 'alice' (SELECT * FROM t)");
+        assert_eq!(inner.as_deref(), Some("SELECT * FROM t"));
+    }
+
     #[test]
     fn extract_inner_sql_bare_username() {
         let inner = extract_inner_sql("EXECUTE AS USER bob (INSERT INTO t VALUES (1, 'x'))");
@@ -320,6 +329,27 @@ mod tests {
         assert_eq!(result.inner_sql, "INSERT INTO default.t VALUES (1)");
     }
 
+    #[test]
+    fn parse_short_alias_quoted_username() {
+        let result =
+            parse_execute_as("EXECUTE AS 'alice' (SELECT * FROM default.todos WHERE id = 1);")
+                .expect("should parse")
+                .expect("should be an envelope");
+
+        assert_eq!(result.username, "alice");
+        assert_eq!(result.inner_sql, "SELECT * FROM default.todos WHERE id = 1");
+    }
+
+    #[test]
+    fn parse_short_alias_bare_username() {
+        let result = parse_execute_as("execute as bob (INSERT INTO default.t VALUES (1))")
+            .expect("should parse")
+            .expect("should be an envelope");
+
+        assert_eq!(result.username, "bob");
+        assert_eq!(result.inner_sql, "INSERT INTO default.t VALUES (1)");
+    }
+
     #[test]
     fn parse_escaped_quote_in_username() {
         let result =
diff --git a/backend/crates/kalamdb-handlers/crates/admin/src/backup/restore_database.rs b/backend/crates/kalamdb-handlers/crates/admin/src/backup/restore_database.rs
index 7ec9dd58..b75389c4 100644
--- a/backend/crates/kalamdb-handlers/crates/admin/src/backup/restore_database.rs
+++ b/backend/crates/kalamdb-handlers/crates/admin/src/backup/restore_database.rs
@@ -24,6 +24,15 @@ impl RestoreDatabaseHandler {
     pub fn new(app_context: Arc<AppContext>) -> Self {
         Self { app_context }
     }
+
+    fn is_archive_path(path: &std::path::Path) -> bool {
+        let value = path
+            .to_string_lossy()
+            .trim()
+            .trim_end_matches(['/', '\\'])
+            .to_ascii_lowercase();
+        value.ends_with(".tar.gz") || value.ends_with(".tgz")
+    }
 }
 
 impl TypedStatementHandler<RestoreDatabaseStatement> for RestoreDatabaseHandler {
@@ -33,17 +42,19 @@ impl TypedStatementHandler<RestoreDatabaseStatement> for RestoreDatabaseHandler
         _params: Vec<ScalarValue>,
         _context: &ExecutionContext,
     ) -> Result<ExecutionResult, KalamDbError> {
-        // Verify backup directory exists before creating job
+        // Verify backup source exists before creating job
         let backup_path = std::path::Path::new(&statement.backup_path);
         if !backup_path.exists() {
             return Err(KalamDbError::NotFound(format!(
-                "Backup directory '{}' not found",
+                "Backup path '{}' not found",
                 statement.backup_path
             )));
         }
-        if !backup_path.is_dir() {
+        if !backup_path.is_dir()
+            && !(backup_path.is_file() && Self::is_archive_path(backup_path))
+        {
             return Err(KalamDbError::InvalidOperation(format!(
-                "'{}' is not a directory. RESTORE DATABASE expects a backup directory, not a file.",
+                "'{}' must be a backup directory or a .tar.gz/.tgz backup archive.",
                 statement.backup_path
             )));
         }
diff --git a/backend/crates/kalamdb-handlers/crates/admin/src/export/show_export.rs b/backend/crates/kalamdb-handlers/crates/admin/src/export/show_export.rs
index d0b51baf..5a47c281 100644
--- a/backend/crates/kalamdb-handlers/crates/admin/src/export/show_export.rs
+++ b/backend/crates/kalamdb-handlers/crates/admin/src/export/show_export.rs
@@ -47,12 +47,9 @@ impl ShowExportHandler {
         created_at_millis.saturating_mul(1_000)
     }
 
-    /// Build a download URL for a completed export
-    fn build_download_url(&self, user_id: &str, export_id: &str) -> String {
-        let config = self.app_context.config();
-        let host = &config.server.host;
-        let port = config.server.port;
-        format!("http://{}:{}/v1/exports/{}/{}", host, port, user_id, export_id)
+    /// Build a download URI for a completed export.
+    fn build_download_url(user_id: &str, export_id: &str) -> String {
+        format!("/v1/exports/{}/{}", user_id, export_id)
     }
 
     /// Extract export_id from job parameters JSON
@@ -124,7 +121,7 @@ impl TypedStatementHandler<ShowExportStatement> for ShowExportHandler {
             // Build download URL only for completed jobs
             let url = if job.status == kalamdb_system::JobStatus::Completed {
                 Self::extract_export_id(job)
-                    .map(|eid| self.build_download_url(&user_id, &eid))
+                    .map(|eid| Self::build_download_url(&user_id, &eid))
                     .unwrap_or_default()
             } else {
                 String::new()
@@ -181,4 +178,11 @@ mod tests {
     fn show_export_created_at_converts_millis_to_micros() {
         assert_eq!(ShowExportHandler::created_at_micros(1_741_900_245_123), 1_741_900_245_123_000);
     }
+
+    #[test]
+    fn show_export_download_url_is_relative_uri() {
+        let url = ShowExportHandler::build_download_url("alice", "export-123");
+
+        assert_eq!(url, "/v1/exports/alice/export-123");
+    }
 }
diff --git a/backend/crates/kalamdb-handlers/crates/ddl/src/namespace/use_namespace.rs b/backend/crates/kalamdb-handlers/crates/ddl/src/namespace/use_namespace.rs
index ec4ea98b..b4453268 100644
--- a/backend/crates/kalamdb-handlers/crates/ddl/src/namespace/use_namespace.rs
+++ b/backend/crates/kalamdb-handlers/crates/ddl/src/namespace/use_namespace.rs
@@ -1,10 +1,13 @@
 //! USE NAMESPACE handler
 //!
-//! This handler sets the default schema for unqualified table names using
-//! DataFusion's native configuration system.
+//! This handler sets the default schema for unqualified table names for the
+//! current request or multi-statement batch using DataFusion's native
+//! configuration system.
 //!
 //! After executing `USE namespace1`, queries like `SELECT * FROM users`
 //! will resolve to `kalam.namespace1.users`.
+//! Interactive clients such as the CLI persist the chosen namespace on the
+//! client and send it back on later requests via `namespace_id`.
 
 use std::sync::Arc;
 
@@ -21,7 +24,8 @@ use kalamdb_sql::ddl::UseNamespaceStatement;
 /// Handler for USE NAMESPACE / USE / SET NAMESPACE statements
 ///
 /// Uses DataFusion's native `datafusion.catalog.default_schema` configuration
-/// to change the default schema for the current session.
+/// to change the default schema for the current request or multi-statement
+/// batch. This is not a long-lived backend connection session.
 pub struct UseNamespaceHandler {
     app_context: Arc<AppContext>,
 }
diff --git a/backend/crates/kalamdb-handlers/crates/user/src/lib.rs b/backend/crates/kalamdb-handlers/crates/user/src/lib.rs
index c4679806..06dc9ec0 100644
--- a/backend/crates/kalamdb-handlers/crates/user/src/lib.rs
+++ b/backend/crates/kalamdb-handlers/crates/user/src/lib.rs
@@ -24,6 +24,8 @@ pub fn register_user_handlers(
             role: kalamdb_commons::Role::User,
             email: None,
             password: None,
+            storage_mode: kalamdb_system::providers::storages::models::StorageMode::Table,
+            storage_id: None,
         }),
         user::CreateUserHandler::new(app_context.clone(), enforce_password_complexity),
         SqlStatementKind::CreateUser,
diff --git a/backend/crates/kalamdb-handlers/crates/user/src/user/alter.rs b/backend/crates/kalamdb-handlers/crates/user/src/user/alter.rs
index 23e65cfc..e35d2ed1 100644
--- a/backend/crates/kalamdb-handlers/crates/user/src/user/alter.rs
+++ b/backend/crates/kalamdb-handlers/crates/user/src/user/alter.rs
@@ -98,6 +98,32 @@ impl TypedStatementHandler<AlterUserStatement> for AlterUserHandler {
                 }
                 updated.email = Some(new_email.clone());
             },
+            UserModification::SetStorageMode(new_storage_mode) => {
+                updated.storage_mode = new_storage_mode;
+            },
+            UserModification::SetStorageId(ref new_storage_id) => {
+                if let Some(storage_id) = new_storage_id {
+                    let app_ctx = self.app_context.clone();
+                    let storage_lookup_id = storage_id.clone();
+                    let storage = tokio::task::spawn_blocking(move || {
+                        app_ctx
+                            .system_tables()
+                            .storages()
+                            .get_storage_by_id(&storage_lookup_id)
+                    })
+                    .await
+                    .map_err(|e| KalamDbError::ExecutionError(format!("Task join error: {}", e)))??;
+
+                    if storage.is_none() {
+                        return Err(KalamDbError::InvalidOperation(format!(
+                            "Storage '{}' does not exist",
+                            storage_id.as_str()
+                        )));
+                    }
+                }
+
+                updated.storage_id = new_storage_id.clone();
+            },
         }
 
         updated.updated_at = chrono::Utc::now().timestamp_millis();
diff --git a/backend/crates/kalamdb-handlers/crates/user/src/user/create.rs b/backend/crates/kalamdb-handlers/crates/user/src/user/create.rs
index 0208fdb0..e959b049 100644
--- a/backend/crates/kalamdb-handlers/crates/user/src/user/create.rs
+++ b/backend/crates/kalamdb-handlers/crates/user/src/user/create.rs
@@ -56,6 +56,27 @@ impl TypedStatementHandler<CreateUserStatement> for CreateUserHandler {
             )));
         }
 
+        let storage_id = if let Some(storage_id) = statement.storage_id.clone() {
+            let app_ctx = self.app_context.clone();
+            let storage_lookup_id = storage_id.clone();
+            let storage = tokio::task::spawn_blocking(move || {
+                app_ctx.system_tables().storages().get_storage_by_id(&storage_lookup_id)
+            })
+            .await
+            .map_err(|e| KalamDbError::ExecutionError(format!("Task join error: {}", e)))??;
+
+            if storage.is_none() {
+                return Err(KalamDbError::InvalidOperation(format!(
+                    "Storage '{}' does not exist",
+                    storage_id.as_str()
+                )));
+            }
+
+            Some(storage_id)
+        } else {
+            None
+        };
+
         // Hash password if auth_type = Password, or extract auth_data for OAuth
         let (password_hash, auth_data) = match statement.auth_type {
             AuthType::Password => {
@@ -123,8 +144,8 @@ impl TypedStatementHandler<CreateUserStatement> for CreateUserHandler {
             email: statement.email.clone(),
             auth_type: statement.auth_type,
             auth_data,
-            storage_mode: kalamdb_system::providers::storages::models::StorageMode::Table,
-            storage_id: None,
+            storage_mode: statement.storage_mode,
+            storage_id,
             failed_login_attempts: 0,
             locked_until: None,
             last_login_at: None,
@@ -148,7 +169,16 @@ impl TypedStatementHandler<CreateUserStatement> for CreateUserHandler {
             "CREATE",
             "USER",
             &statement.username,
-            Some(format!("Role: {:?}", statement.role)),
+            Some(format!(
+                "Role: {:?}, storage_mode: {}, storage_id: {}",
+                statement.role,
+                statement.storage_mode,
+                statement
+                    .storage_id
+                    .as_ref()
+                    .map(|storage_id| storage_id.as_str())
+                    .unwrap_or("NULL")
+            )),
             None,
         );
         audit::persist_audit_entry(&self.app_context, &audit_entry).await?;
diff --git a/backend/crates/kalamdb-jobs/Cargo.toml b/backend/crates/kalamdb-jobs/Cargo.toml
index 4e9f88c0..43d6aea2 100644
--- a/backend/crates/kalamdb-jobs/Cargo.toml
+++ b/backend/crates/kalamdb-jobs/Cargo.toml
@@ -41,6 +41,8 @@ uuid = { workspace = true }
 
 # ZIP archive creation
 zip = { workspace = true }
+flate2 = { workspace = true }
+tar = { workspace = true }
 
 # Concurrent
 parking_lot = { workspace = true }
diff --git a/backend/crates/kalamdb-jobs/src/executors/backup.rs b/backend/crates/kalamdb-jobs/src/executors/backup.rs
index c9dacaaa..ccdcbb0f 100644
--- a/backend/crates/kalamdb-jobs/src/executors/backup.rs
+++ b/backend/crates/kalamdb-jobs/src/executors/backup.rs
@@ -4,7 +4,11 @@
 //! for the key-value store, plus a recursive directory copy for Parquet storage,
 //! snapshots, streams, and the server.toml configuration file.
 //!
-//! ## Backup Directory Layout
+//! When the target path ends with `.tar.gz` or `.tgz`, the executor writes a
+//! single archive file containing the following layout. Otherwise the same
+//! layout is written directly into the target directory.
+//!
+//! ## Backup Layout
 //! ```text
 //! <backup_path>/
 //!   rocksdb/      ← RocksDB BackupEngine output (hot, consistent, deduplicated)
@@ -21,20 +25,29 @@
 //! }
 //! ```
 
-use std::{fs, path::Path};
+use std::{
+    fs::{self, File},
+    path::{Path, PathBuf},
+};
 
 use async_trait::async_trait;
+use flate2::{write::GzEncoder, Compression};
 use kalamdb_core::error::KalamDbError;
 use kalamdb_system::JobType;
 use serde::{Deserialize, Serialize};
+use tar::Builder;
+use uuid::Uuid;
 
 use crate::executors::{JobContext, JobDecision, JobExecutor, JobParams};
 
 /// Typed parameters for full database backup operations
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BackupParams {
-    /// Destination directory for the backup (created if it does not exist).
-    /// RocksDB native BackupEngine output goes into `<backup_path>/rocksdb/`.
+    /// Destination backup path on the server filesystem.
+    ///
+    /// If the path ends with `.tar.gz` or `.tgz`, KalamDB writes a single
+    /// archive file. Otherwise a backup directory is created and the layout is
+    /// written under `<backup_path>/rocksdb`, `<backup_path>/storage`, and so on.
     pub backup_path: String,
 }
 
@@ -58,6 +71,145 @@ impl BackupExecutor {
         Self
     }
 
+    fn is_archive_path(path: &Path) -> bool {
+        let value = path
+            .to_string_lossy()
+            .trim()
+            .trim_end_matches(['/', '\\'])
+            .to_ascii_lowercase();
+        value.ends_with(".tar.gz") || value.ends_with(".tgz")
+    }
+
+    fn create_archive_staging_dir(archive_path: &Path) -> Result<PathBuf, KalamDbError> {
+        let parent = archive_path.parent().unwrap_or_else(|| Path::new("."));
+        fs::create_dir_all(parent).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to create archive parent directory '{}': {}",
+                parent.display(),
+                e
+            ))
+        })?;
+
+        let file_name = archive_path
+            .file_name()
+            .and_then(|value| value.to_str())
+            .unwrap_or("kalamdb-backup");
+        let staging_dir = parent.join(format!(".{}.staging-{}", file_name, Uuid::new_v4()));
+
+        fs::create_dir_all(&staging_dir).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to create backup staging directory '{}': {}",
+                staging_dir.display(),
+                e
+            ))
+        })?;
+
+        Ok(staging_dir)
+    }
+
+    fn create_tar_gz_archive(src_dir: &Path, archive_path: &Path) -> Result<(), KalamDbError> {
+        if let Some(parent) = archive_path.parent() {
+            fs::create_dir_all(parent).map_err(|e| {
+                KalamDbError::InvalidOperation(format!(
+                    "Failed to create archive output directory '{}': {}",
+                    parent.display(),
+                    e
+                ))
+            })?;
+        }
+
+        if archive_path.exists() {
+            if archive_path.is_dir() {
+                return Err(KalamDbError::InvalidOperation(format!(
+                    "Archive output path '{}' is a directory",
+                    archive_path.display()
+                )));
+            }
+
+            fs::remove_file(archive_path).map_err(|e| {
+                KalamDbError::InvalidOperation(format!(
+                    "Failed to replace existing archive '{}': {}",
+                    archive_path.display(),
+                    e
+                ))
+            })?;
+        }
+
+        let archive_file = File::create(archive_path).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to create archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })?;
+        let encoder = GzEncoder::new(archive_file, Compression::default());
+        let mut builder = Builder::new(encoder);
+
+        for entry in fs::read_dir(src_dir).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to read archive staging directory '{}': {}",
+                src_dir.display(),
+                e
+            ))
+        })? {
+            let entry = entry.map_err(|e| {
+                KalamDbError::InvalidOperation(format!("Directory entry error: {}", e))
+            })?;
+            let src_path = entry.path();
+            let name = entry.file_name();
+            let archive_name = Path::new(name.as_os_str());
+
+            if src_path.is_dir() {
+                builder.append_dir_all(archive_name, &src_path).map_err(|e| {
+                    KalamDbError::InvalidOperation(format!(
+                        "Failed to archive directory '{}': {}",
+                        src_path.display(),
+                        e
+                    ))
+                })?;
+            } else {
+                let mut file = File::open(&src_path).map_err(|e| {
+                    KalamDbError::InvalidOperation(format!(
+                        "Failed to open archive input '{}': {}",
+                        src_path.display(),
+                        e
+                    ))
+                })?;
+                builder.append_file(archive_name, &mut file).map_err(|e| {
+                    KalamDbError::InvalidOperation(format!(
+                        "Failed to archive file '{}': {}",
+                        src_path.display(),
+                        e
+                    ))
+                })?;
+            }
+        }
+
+        builder.finish().map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to finish archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })?;
+        let encoder = builder.into_inner().map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to finalize archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })?;
+        encoder.finish().map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to flush archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })?;
+
+        Ok(())
+    }
+
     /// Recursively copy `src` into `dst`, creating `dst` if necessary.
     fn copy_dir(src: &Path, dst: &Path) -> Result<u64, KalamDbError> {
         if !src.exists() {
@@ -115,46 +267,73 @@ impl JobExecutor for BackupExecutor {
 
     async fn execute(&self, ctx: &JobContext<Self::Params>) -> Result<JobDecision, KalamDbError> {
         let params = ctx.params();
-        let backup_dir = std::path::PathBuf::from(&params.backup_path);
+        let backup_target = std::path::PathBuf::from(&params.backup_path);
 
         let config = ctx.app_ctx.config();
         let storage = &config.storage;
 
-        ctx.log_info(&format!("Starting full database backup to '{}'", backup_dir.display()));
+        ctx.log_info(&format!("Starting full database backup to '{}'", backup_target.display()));
 
         let storage_backend = ctx.app_ctx.storage_backend();
-        let rocksdb_backup_dir = backup_dir.join("rocksdb");
         let src_storage = storage.storage_dir();
         let src_snapshots = storage.resolved_snapshots_dir();
         let src_streams = storage.streams_dir();
 
         let result = tokio::task::spawn_blocking(move || -> Result<u64, KalamDbError> {
+            let archive_output = Self::is_archive_path(&backup_target);
+            let backup_root = if archive_output {
+                Self::create_archive_staging_dir(&backup_target)?
+            } else {
+                backup_target.clone()
+            };
+
+            fs::create_dir_all(&backup_root).map_err(|e| {
+                KalamDbError::InvalidOperation(format!(
+                    "Failed to create backup root '{}': {}",
+                    backup_root.display(),
+                    e
+                ))
+            })?;
+
             // 1. RocksDB native backup (hot, consistent, with flush)
-            storage_backend.backup_to(&rocksdb_backup_dir).map_err(|e| {
+            storage_backend.backup_to(&backup_root.join("rocksdb")).map_err(|e| {
                 KalamDbError::InvalidOperation(format!("RocksDB backup failed: {}", e))
             })?;
 
             let mut total_bytes: u64 = 0;
 
             // 2. Parquet storage files
-            total_bytes += Self::copy_dir(&src_storage, &backup_dir.join("storage"))?;
+            total_bytes += Self::copy_dir(&src_storage, &backup_root.join("storage"))?;
 
             // 3. Snapshot files
-            total_bytes += Self::copy_dir(&src_snapshots, &backup_dir.join("snapshots"))?;
+            total_bytes += Self::copy_dir(&src_snapshots, &backup_root.join("snapshots"))?;
 
             // 4. Stream commit log files
-            total_bytes += Self::copy_dir(&src_streams, &backup_dir.join("streams"))?;
+            total_bytes += Self::copy_dir(&src_streams, &backup_root.join("streams"))?;
 
             // 5. server.toml (look next to the binary / CWD)
             let server_toml = Path::new("server.toml");
             if server_toml.exists() {
-                fs::copy(server_toml, backup_dir.join("server.toml")).map_err(|e| {
+                fs::copy(server_toml, backup_root.join("server.toml")).map_err(|e| {
                     KalamDbError::InvalidOperation(format!("Failed to copy server.toml: {}", e))
                 })?;
                 total_bytes += server_toml.metadata().map(|m| m.len()).unwrap_or(0);
             }
 
-            Ok(total_bytes)
+            if archive_output {
+                Self::create_tar_gz_archive(&backup_root, &backup_target)?;
+                let archive_size = backup_target.metadata().map(|m| m.len()).map_err(|e| {
+                    KalamDbError::InvalidOperation(format!(
+                        "Failed to inspect archive '{}': {}",
+                        backup_target.display(),
+                        e
+                    ))
+                })?;
+                let _ = fs::remove_dir_all(&backup_root);
+                Ok(archive_size)
+            } else {
+                Ok(total_bytes)
+            }
         })
         .await
         .map_err(|e| KalamDbError::InvalidOperation(format!("Backup task panicked: {}", e)))?;
@@ -199,7 +378,13 @@ impl Default for BackupExecutor {
 
 #[cfg(test)]
 mod tests {
+    use flate2::read::GzDecoder;
+    use kalamdb_core::test_helpers::test_app_context_simple;
+    use tar::Archive;
+    use tempfile::tempdir;
+
     use super::*;
+    use crate::executors::{JobContext, JobDecision};
 
     #[test]
     fn test_executor_properties() {
@@ -207,4 +392,65 @@ mod tests {
         assert_eq!(executor.job_type(), JobType::Backup);
         assert_eq!(executor.name(), "BackupExecutor");
     }
+
+    #[test]
+    fn test_create_tar_gz_archive_preserves_backup_layout() {
+        let temp_dir = tempdir().expect("temp dir");
+        let source_root = temp_dir.path().join("backup-root");
+        fs::create_dir_all(source_root.join("rocksdb")).expect("rocksdb dir");
+        fs::create_dir_all(source_root.join("storage/app/messages")).expect("storage dir");
+        fs::write(source_root.join("rocksdb/CURRENT"), "manifest").expect("rocksdb file");
+        fs::write(
+            source_root.join("storage/app/messages/part-1.parquet"),
+            "parquet",
+        )
+        .expect("storage file");
+        fs::write(source_root.join("server.toml"), "port = 8080\n").expect("config file");
+
+        let archive_path = temp_dir.path().join("backup.tar.gz");
+        BackupExecutor::create_tar_gz_archive(&source_root, &archive_path)
+            .expect("archive creation");
+
+        let extract_root = temp_dir.path().join("extract");
+        fs::create_dir_all(&extract_root).expect("extract root");
+        let archive_file = File::open(&archive_path).expect("open archive");
+        let decoder = GzDecoder::new(archive_file);
+        let mut archive = Archive::new(decoder);
+        archive.unpack(&extract_root).expect("unpack archive");
+
+        assert_eq!(
+            fs::read_to_string(extract_root.join("rocksdb/CURRENT")).expect("read rocksdb file"),
+            "manifest"
+        );
+        assert_eq!(
+            fs::read_to_string(extract_root.join("storage/app/messages/part-1.parquet"))
+                .expect("read storage file"),
+            "parquet"
+        );
+        assert_eq!(
+            fs::read_to_string(extract_root.join("server.toml")).expect("read config file"),
+            "port = 8080\n"
+        );
+    }
+
+    #[test]
+    fn test_is_archive_path_accepts_trailing_separator() {
+        assert!(BackupExecutor::is_archive_path(Path::new("/tmp/kalamdb.tar.gz/")));
+        assert!(BackupExecutor::is_archive_path(Path::new("/tmp/kalamdb.tgz/")));
+    }
+
+    #[tokio::test]
+    async fn test_execute_writes_archive_for_archive_path() {
+        let app_ctx = test_app_context_simple();
+        let temp_dir = tempdir().expect("temp dir");
+        let archive_path = temp_dir.path().join("kalamdb-backup.tar.gz");
+        let params = BackupParams {
+            backup_path: archive_path.to_string_lossy().to_string(),
+        };
+        let ctx = JobContext::new(app_ctx, "BK-test-archive".to_string(), params);
+
+        let decision = BackupExecutor::new().execute(&ctx).await.expect("backup execute");
+        assert!(matches!(decision, JobDecision::Completed { .. }));
+        assert!(archive_path.is_file(), "expected archive file at {}", archive_path.display());
+    }
 }
diff --git a/backend/crates/kalamdb-jobs/src/executors/registry.rs b/backend/crates/kalamdb-jobs/src/executors/registry.rs
index f4065a05..1724983f 100644
--- a/backend/crates/kalamdb-jobs/src/executors/registry.rs
+++ b/backend/crates/kalamdb-jobs/src/executors/registry.rs
@@ -471,8 +471,10 @@ mod tests {
     use kalamdb_core::test_helpers::test_app_context_simple;
     use kalamdb_system::JobStatus;
     use serde::{Deserialize, Serialize};
+    use tempfile::tempdir;
 
     use super::*;
+    use crate::executors::backup::BackupExecutor;
     use crate::executors::JobParams;
 
     #[derive(Clone, Serialize, Deserialize)]
@@ -597,6 +599,23 @@ mod tests {
         }
     }
 
+    #[tokio::test]
+    async fn test_registry_execute_backup_archive_path() {
+        let app_ctx = test_app_context_simple();
+        let temp_dir = tempdir().expect("temp dir");
+        let archive_path = temp_dir.path().join("registry-backup.tar.gz");
+
+        let registry = JobRegistry::new();
+        registry.register(Arc::new(BackupExecutor::new()));
+
+        let params = format!(r#"{{"backup_path":"{}"}}"#, archive_path.display());
+        let job = make_test_job(JobType::Backup, &params);
+        let result = registry.execute(app_ctx, &job).await.expect("registry execute backup");
+
+        assert!(matches!(result, JobDecision::Completed { .. }));
+        assert!(archive_path.is_file(), "expected archive file at {}", archive_path.display());
+    }
+
     #[tokio::test]
     async fn test_registry_execute_not_found() {
         let app_ctx = test_app_context_simple();
diff --git a/backend/crates/kalamdb-jobs/src/executors/restore.rs b/backend/crates/kalamdb-jobs/src/executors/restore.rs
index 0877f05e..2096cb3d 100644
--- a/backend/crates/kalamdb-jobs/src/executors/restore.rs
+++ b/backend/crates/kalamdb-jobs/src/executors/restore.rs
@@ -1,10 +1,11 @@
 //! Restore Job Executor
 //!
-//! Restores the entire KalamDB database from a backup directory created by the
-//! backup job. Uses RocksDB's native `BackupEngine` for the key-value store and
-//! a recursive directory copy for Parquet and stream files.
+//! Restores the entire KalamDB database from a backup directory or `.tar.gz`
+//! / `.tgz` archive created by the backup job. Uses RocksDB's native
+//! `BackupEngine` for the key-value store and a recursive directory copy for
+//! Parquet and stream files.
 //!
-//! ## Backup Directory Layout Expected
+//! ## Backup Layout Expected
 //! ```text
 //! <backup_path>/
 //!   rocksdb/      ← RocksDB BackupEngine output
@@ -24,19 +25,28 @@
 //! ## IMPORTANT
 //! Restore requires a server restart after completion to reload the restored data.
 
-use std::{fs, path::Path};
+use std::{
+    fs::{self, File},
+    path::{Component, Path, PathBuf},
+};
 
 use async_trait::async_trait;
+use flate2::read::GzDecoder;
 use kalamdb_core::error::KalamDbError;
 use kalamdb_system::JobType;
 use serde::{Deserialize, Serialize};
+use tar::Archive;
+use uuid::Uuid;
 
 use crate::executors::{JobContext, JobDecision, JobExecutor, JobParams};
 
 /// Typed parameters for full database restore operations
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RestoreParams {
-    /// Source backup directory (created by BACKUP DATABASE TO '<path>')
+    /// Source backup path on the server filesystem.
+    ///
+    /// The path may be a backup directory or a `.tar.gz` / `.tgz` archive
+    /// created by `BACKUP DATABASE TO '<path>'`.
     pub backup_path: String,
 }
 
@@ -60,6 +70,114 @@ impl RestoreExecutor {
         Self
     }
 
+    fn is_archive_path(path: &Path) -> bool {
+        let value = path
+            .to_string_lossy()
+            .trim()
+            .trim_end_matches(['/', '\\'])
+            .to_ascii_lowercase();
+        value.ends_with(".tar.gz") || value.ends_with(".tgz")
+    }
+
+    fn create_archive_staging_dir(archive_path: &Path) -> Result<PathBuf, KalamDbError> {
+        let parent = archive_path.parent().unwrap_or_else(|| Path::new("."));
+        fs::create_dir_all(parent).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to create restore staging parent '{}': {}",
+                parent.display(),
+                e
+            ))
+        })?;
+
+        let file_name = archive_path
+            .file_name()
+            .and_then(|value| value.to_str())
+            .unwrap_or("kalamdb-restore");
+        let staging_dir = parent.join(format!(".{}.restore-{}", file_name, Uuid::new_v4()));
+        fs::create_dir_all(&staging_dir).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to create restore staging directory '{}': {}",
+                staging_dir.display(),
+                e
+            ))
+        })?;
+
+        Ok(staging_dir)
+    }
+
+    fn extract_tar_gz_archive(archive_path: &Path, output_dir: &Path) -> Result<(), KalamDbError> {
+        fs::create_dir_all(output_dir).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to create restore extraction directory '{}': {}",
+                output_dir.display(),
+                e
+            ))
+        })?;
+
+        let archive_file = File::open(archive_path).map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to open backup archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })?;
+        let decoder = GzDecoder::new(archive_file);
+        let mut archive = Archive::new(decoder);
+
+        for entry in archive.entries().map_err(|e| {
+            KalamDbError::InvalidOperation(format!(
+                "Failed to enumerate backup archive '{}': {}",
+                archive_path.display(),
+                e
+            ))
+        })? {
+            let mut entry = entry.map_err(|e| {
+                KalamDbError::InvalidOperation(format!("Archive entry error: {}", e))
+            })?;
+
+            let entry_type = entry.header().entry_type();
+            if entry_type.is_symlink() || entry_type.is_hard_link() {
+                return Err(KalamDbError::InvalidOperation(
+                    "Backup archive cannot contain symlinks".to_string(),
+                ));
+            }
+
+            let relative_path = entry.path().map_err(|e| {
+                KalamDbError::InvalidOperation(format!("Invalid archive path: {}", e))
+            })?;
+            let relative_path = relative_path.into_owned();
+
+            if relative_path.components().any(|component| {
+                matches!(component, Component::ParentDir | Component::RootDir | Component::Prefix(_))
+            }) {
+                return Err(KalamDbError::InvalidOperation(
+                    "Backup archive contains an unsafe path".to_string(),
+                ));
+            }
+
+            let output_path = output_dir.join(&relative_path);
+            if let Some(parent) = output_path.parent() {
+                fs::create_dir_all(parent).map_err(|e| {
+                    KalamDbError::InvalidOperation(format!(
+                        "Failed to create restore path '{}': {}",
+                        parent.display(),
+                        e
+                    ))
+                })?;
+            }
+
+            entry.unpack(&output_path).map_err(|e| {
+                KalamDbError::InvalidOperation(format!(
+                    "Failed to extract '{}' from backup archive: {}",
+                    relative_path.display(),
+                    e
+                ))
+            })?;
+        }
+
+        Ok(())
+    }
+
     /// Recursively copy `src` into `dst`, creating `dst` if needed.
     /// Overwrites existing files. Skips if `src` doesn't exist.
     fn copy_dir(src: &Path, dst: &Path) -> Result<(), KalamDbError> {
@@ -116,21 +234,31 @@ impl JobExecutor for RestoreExecutor {
 
     async fn execute(&self, ctx: &JobContext<Self::Params>) -> Result<JobDecision, KalamDbError> {
         let params = ctx.params();
-        let backup_dir = std::path::PathBuf::from(&params.backup_path);
+        let backup_source = std::path::PathBuf::from(&params.backup_path);
 
         let config = ctx.app_ctx.config();
         let storage = &config.storage;
 
-        ctx.log_info(&format!("Starting full database restore from '{}'", backup_dir.display()));
+        ctx.log_info(&format!("Starting full database restore from '{}'", backup_source.display()));
 
         let storage_backend = ctx.app_ctx.storage_backend();
-        let rocksdb_backup_dir = backup_dir.join("rocksdb");
 
         let dst_storage = storage.storage_dir();
         let dst_snapshots = storage.resolved_snapshots_dir();
         let dst_streams = storage.streams_dir();
 
         let result = tokio::task::spawn_blocking(move || -> Result<(), KalamDbError> {
+            let archive_input = Self::is_archive_path(&backup_source);
+            let restore_root = if archive_input {
+                let staging_dir = Self::create_archive_staging_dir(&backup_source)?;
+                Self::extract_tar_gz_archive(&backup_source, &staging_dir)?;
+                staging_dir
+            } else {
+                backup_source.clone()
+            };
+
+            let rocksdb_backup_dir = restore_root.join("rocksdb");
+
             // 1. RocksDB native restore (overwrites current data)
             if rocksdb_backup_dir.exists() {
                 storage_backend.restore_from(&rocksdb_backup_dir).map_err(|e| {
@@ -139,22 +267,26 @@ impl JobExecutor for RestoreExecutor {
             }
 
             // 2. Parquet storage files
-            Self::copy_dir(&backup_dir.join("storage"), &dst_storage)?;
+            Self::copy_dir(&restore_root.join("storage"), &dst_storage)?;
 
             // 3. Snapshot files
-            Self::copy_dir(&backup_dir.join("snapshots"), &dst_snapshots)?;
+            Self::copy_dir(&restore_root.join("snapshots"), &dst_snapshots)?;
 
             // 4. Stream commit log files
-            Self::copy_dir(&backup_dir.join("streams"), &dst_streams)?;
+            Self::copy_dir(&restore_root.join("streams"), &dst_streams)?;
 
             // 5. server.toml (optional)
-            let backup_toml = backup_dir.join("server.toml");
+            let backup_toml = restore_root.join("server.toml");
             if backup_toml.exists() {
                 fs::copy(&backup_toml, Path::new("server.toml")).map_err(|e| {
                     KalamDbError::InvalidOperation(format!("Failed to restore server.toml: {}", e))
                 })?;
             }
 
+            if archive_input {
+                let _ = fs::remove_dir_all(&restore_root);
+            }
+
             Ok(())
         })
         .await
@@ -199,6 +331,10 @@ impl Default for RestoreExecutor {
 
 #[cfg(test)]
 mod tests {
+    use flate2::{write::GzEncoder, Compression};
+    use tar::Builder;
+    use tempfile::tempdir;
+
     use super::*;
 
     #[test]
@@ -207,4 +343,52 @@ mod tests {
         assert_eq!(executor.job_type(), JobType::Restore);
         assert_eq!(executor.name(), "RestoreExecutor");
     }
+
+    #[test]
+    fn test_extract_tar_gz_archive_restores_backup_layout() {
+        let temp_dir = tempdir().expect("temp dir");
+        let source_root = temp_dir.path().join("source-root");
+        fs::create_dir_all(source_root.join("rocksdb")).expect("rocksdb dir");
+        fs::create_dir_all(source_root.join("storage/app/messages")).expect("storage dir");
+        fs::write(source_root.join("rocksdb/CURRENT"), "manifest").expect("rocksdb file");
+        fs::write(
+            source_root.join("storage/app/messages/part-1.parquet"),
+            "parquet",
+        )
+        .expect("storage file");
+
+        let archive_path = temp_dir.path().join("restore.tar.gz");
+        let archive_file = File::create(&archive_path).expect("archive file");
+        let encoder = GzEncoder::new(archive_file, Compression::default());
+        let mut builder = Builder::new(encoder);
+        builder
+            .append_dir_all("rocksdb", source_root.join("rocksdb"))
+            .expect("archive rocksdb");
+        builder
+            .append_dir_all("storage", source_root.join("storage"))
+            .expect("archive storage");
+        builder.finish().expect("finish archive");
+        let encoder = builder.into_inner().expect("archive encoder");
+        encoder.finish().expect("flush archive");
+
+        let restore_root = temp_dir.path().join("restore-root");
+        RestoreExecutor::extract_tar_gz_archive(&archive_path, &restore_root)
+            .expect("extract archive");
+
+        assert_eq!(
+            fs::read_to_string(restore_root.join("rocksdb/CURRENT")).expect("read rocksdb file"),
+            "manifest"
+        );
+        assert_eq!(
+            fs::read_to_string(restore_root.join("storage/app/messages/part-1.parquet"))
+                .expect("read storage file"),
+            "parquet"
+        );
+    }
+
+    #[test]
+    fn test_is_archive_path_accepts_trailing_separator() {
+        assert!(RestoreExecutor::is_archive_path(Path::new("/tmp/kalamdb.tar.gz/")));
+        assert!(RestoreExecutor::is_archive_path(Path::new("/tmp/kalamdb.tgz/")));
+    }
 }
diff --git a/backend/crates/kalamdb-live/src/notification.rs b/backend/crates/kalamdb-live/src/notification.rs
index d854de76..909ddaae 100644
--- a/backend/crates/kalamdb-live/src/notification.rs
+++ b/backend/crates/kalamdb-live/src/notification.rs
@@ -111,6 +111,16 @@ fn extract_commit_seq(change_notification: &ChangeNotification) -> Option<u64> {
         })
 }
 
+fn projection_includes_column(projections: &Option<Arc<Vec<String>>>, column: &str) -> bool {
+    match projections {
+        None => true,
+        Some(proj) => {
+            column == SystemColumnNames::SEQ
+                || proj.iter().any(|candidate| candidate.eq_ignore_ascii_case(column))
+        },
+    }
+}
+
 /// Convert a Row to a projected RowData map (`HashMap<String, KalamCellValue>`).
 /// Includes `_seq` always. When `projections` is `None`, includes all columns.
 fn project_row(row: &Row, projections: &Option<Arc<Vec<String>>>) -> Result<RowData, LiveError> {
@@ -119,11 +129,7 @@ fn project_row(row: &Row, projections: &Option<Arc<Vec<String>>>) -> Result<RowD
         if col == SystemColumnNames::COMMIT_SEQ {
             continue;
         }
-        let include = match projections {
-            None => true,
-            Some(proj) => col == SystemColumnNames::SEQ || proj.iter().any(|p| p == col),
-        };
-        if include {
+        if projection_includes_column(projections, col) {
             let cell = scalar_value_to_json(sv)
                 .map_err(|e| LiveError::SerializationError(e.to_string()))?;
             map.insert(col.clone(), cell);
@@ -163,14 +169,13 @@ fn project_update_delta(
         }
     }
 
-    let owned_keys;
-    let col_names: Box<dyn Iterator<Item = &str>> = match projections {
-        None => {
-            owned_keys = new_row.values.keys().collect::<Vec<_>>();
-            Box::new(owned_keys.iter().map(|s| s.as_str()))
-        },
-        Some(cols) => Box::new(cols.iter().map(String::as_str)),
-    };
+    let owned_keys = new_row
+        .values
+        .keys()
+        .filter(|column| projection_includes_column(projections, column))
+        .cloned()
+        .collect::<Vec<_>>();
+    let col_names = owned_keys.iter().map(String::as_str);
 
     for col in col_names {
         if col.starts_with('_') || pk_columns.iter().any(|pk| pk == col) {
@@ -968,6 +973,50 @@ mod tests {
         assert!(rows[0].get(SystemColumnNames::SEQ).is_some());
     }
 
+    #[tokio::test]
+    async fn test_notify_async_projection_matches_case_insensitively() {
+        let registry = ConnectionsManager::new(
+            NodeId::new(1),
+            Duration::from_secs(30),
+            Duration::from_secs(10),
+            Duration::from_secs(5),
+        );
+        let service = NotificationService::new(Arc::clone(&registry));
+
+        let user_id = UserId::new("user-proj-upper");
+        let table_id = make_table_id("default", "events");
+        let conn_id = ConnectionId::new("c-user-upper");
+        let live_id =
+            LiveQueryId::new(user_id.clone(), conn_id.clone(), "sub_upper".to_string());
+
+        let (tx, mut rx) = mpsc::channel(8);
+        let flow = Arc::new(SubscriptionFlowControl::new());
+        flow.mark_initial_complete();
+
+        registry.index_subscription(
+            &user_id,
+            &conn_id,
+            live_id,
+            table_id.clone(),
+            make_shared_handle("sub_upper", tx, flow, None, Some(vec!["ID"])),
+        );
+
+        let change = ChangeNotification::insert(table_id.clone(), make_row(42, "hello", 42));
+        service.notify_async(Some(user_id), table_id, change);
+
+        let delivered = tokio::time::timeout(Duration::from_secs(1), rx.recv())
+            .await
+            .expect("projected subscriber gets message within timeout")
+            .expect("projected subscriber gets message");
+        let json: serde_json::Value = serde_json::from_slice(&delivered.to_json()).unwrap();
+        let rows = json["rows"].as_array().expect("rows array");
+
+        assert_eq!(rows.len(), 1);
+        assert!(rows[0].get("id").is_some());
+        assert!(rows[0].get("body").is_none());
+        assert!(rows[0].get(SystemColumnNames::SEQ).is_some());
+    }
+
     #[tokio::test]
     async fn test_notify_async_shared_buffers_when_initial_load_incomplete() {
         let registry = ConnectionsManager::new(
diff --git a/backend/tests/integration_tests/topic_pubsub.rs b/backend/tests/integration_tests/topic_pubsub.rs
index afe02372..fa643aeb 100644
--- a/backend/tests/integration_tests/topic_pubsub.rs
+++ b/backend/tests/integration_tests/topic_pubsub.rs
@@ -279,6 +279,28 @@ fn row_offsets(response: &QueryResponse) -> Vec<i64> {
         .collect()
 }
 
+fn last_row_offset(response: &QueryResponse) -> u64 {
+    row_offsets(response)
+        .into_iter()
+        .max()
+        .expect("Expected consume response to contain at least one offset row") as u64
+}
+
+async fn ack_topic_offset(server: &TestServer, topic: &str, group: &str, upto_offset: u64) {
+    let response = server
+        .execute_sql(&format!("ACK {} GROUP '{}' UPTO OFFSET {}", topic, group, upto_offset))
+        .await;
+    assert_eq!(
+        response.status,
+        ResponseStatus::Success,
+        "ACK should succeed for topic='{}' group='{}' upto_offset={}: {:?}",
+        topic,
+        group,
+        upto_offset,
+        response.error
+    );
+}
+
 async fn assert_topic_offset_state(
     server: &TestServer,
     topic: &str,
@@ -866,9 +888,13 @@ async fn test_sql_group_consume_resumes_from_committed_offsets_after_cache_clear
         1,
         "Initial consume should return the first message"
     );
+    assert_topic_offset_state(&server, &topic, &group, None).await;
+
+    ack_topic_offset(&server, &topic, &group, last_row_offset(&first_consume)).await;
+
     let first_updated_at = assert_topic_offset_state(&server, &topic, &group, Some(0))
         .await
-        .expect("Expected first grouped consume to auto-ack offset 0");
+        .expect("Expected explicit ACK to persist offset 0");
 
     server.app_context.topic_publisher().clear_cache();
 
@@ -881,11 +907,19 @@ async fn test_sql_group_consume_resumes_from_committed_offsets_after_cache_clear
         1,
         "After clearing in-memory claims, SQL consume should resume from the committed offset"
     );
+    let second_last_offset = last_row_offset(&second_consume);
+    assert_eq!(second_last_offset, 1);
+    let before_second_ack = assert_topic_offset_state(&server, &topic, &group, Some(0))
+        .await
+        .expect("Expected committed offset to remain unchanged before explicit ACK");
+
+    ack_topic_offset(&server, &topic, &group, second_last_offset).await;
+
     let second_updated_at = assert_topic_offset_state(&server, &topic, &group, Some(1))
         .await
-        .expect("Expected second grouped consume to advance auto-ack to offset 1");
+        .expect("Expected explicit ACK to advance committed offset to 1");
     assert!(
-        second_updated_at >= first_updated_at,
+        second_updated_at >= before_second_ack && second_updated_at >= first_updated_at,
         "Offset update timestamp should move forward or stay equal across rapid commits"
     );
 
@@ -968,6 +1002,9 @@ async fn test_sql_group_offsets_are_isolated_per_group() {
             "New group '{}' should start from the beginning when consuming FROM EARLIEST",
             group
         );
+
+        assert_topic_offset_state(&server, &topic, group, None).await;
+        ack_topic_offset(&server, &topic, group, last_row_offset(&response)).await;
         assert_topic_offset_state(&server, &topic, group, Some(*expected_last_acked)).await;
     }
 
@@ -1008,6 +1045,9 @@ async fn test_sql_group_offsets_are_isolated_per_group() {
             "Group '{}' should resume from its own committed cursor after cache clear",
             group
         );
+
+        assert_topic_offset_state(&server, &topic, group, Some(*expected_last_acked)).await;
+        ack_topic_offset(&server, &topic, group, last_row_offset(&resumed)).await;
         assert_topic_offset_state(&server, &topic, group, Some(*expected_last_acked + 1)).await;
     }
 
@@ -1083,6 +1123,9 @@ async fn test_sql_group_from_latest_tails_new_messages_and_then_persists_offset(
     )
     .await;
     assert_eq!(row_offsets(&tail_consume), vec![5, 6]);
+
+    assert_topic_offset_state(&server, &topic, &group, None).await;
+    ack_topic_offset(&server, &topic, &group, last_row_offset(&tail_consume)).await;
     assert_topic_offset_state(&server, &topic, &group, Some(6)).await;
 
     server.app_context.topic_publisher().clear_cache();
@@ -1132,6 +1175,9 @@ async fn test_sql_group_from_offset_starts_at_requested_offset_and_persists_resu
     )
     .await;
     assert_eq!(row_offsets(&offset_consume), vec![3, 4]);
+
+    assert_topic_offset_state(&server, &topic, &group, None).await;
+    ack_topic_offset(&server, &topic, &group, last_row_offset(&offset_consume)).await;
     assert_topic_offset_state(&server, &topic, &group, Some(4)).await;
 
     server.app_context.topic_publisher().clear_cache();
@@ -1143,6 +1189,9 @@ async fn test_sql_group_from_offset_starts_at_requested_offset_and_persists_resu
     )
     .await;
     assert_eq!(row_offsets(&resumed), vec![5]);
+
+    assert_topic_offset_state(&server, &topic, &group, Some(4)).await;
+    ack_topic_offset(&server, &topic, &group, last_row_offset(&resumed)).await;
     assert_topic_offset_state(&server, &topic, &group, Some(5)).await;
 }
 
diff --git a/backend/tests/testserver/sql/test_user_sql_commands_http.rs b/backend/tests/testserver/sql/test_user_sql_commands_http.rs
index 10b54085..df2d5e24 100644
--- a/backend/tests/testserver/sql/test_user_sql_commands_http.rs
+++ b/backend/tests/testserver/sql/test_user_sql_commands_http.rs
@@ -19,7 +19,7 @@ async fn test_user_sql_commands_over_http() {
                 let admin_auth = server.bearer_auth_header("root")?;
 
                 // CREATE USER with password
-                let sql = "CREATE USER 'alice' WITH PASSWORD 'SecurePass123!' ROLE developer EMAIL 'alice@example.com'";
+                let sql = "CREATE USER 'alice' WITH PASSWORD 'SecurePass123!' ROLE developer EMAIL 'alice@example.com' STORAGE_MODE region STORAGE_ID 'local'";
                 let result = server.execute_sql_with_auth(sql, &admin_auth).await?;
                 assert_eq!(
                     result.status,
@@ -42,6 +42,8 @@ async fn test_user_sql_commands_over_http() {
                     row.get("email").unwrap().as_str().unwrap(),
                     "alice@example.com"
                 );
+                assert_eq!(row.get("storage_mode").unwrap().as_str().unwrap(), "region");
+                assert_eq!(row.get("storage_id").unwrap().as_str().unwrap(), "local");
 
                 // CREATE USER with OAuth
                 let sql = r#"CREATE USER 'bob' WITH OAUTH '{"provider": "google", "subject": "12345"}' ROLE viewer EMAIL 'bob@example.com'"#;
@@ -114,6 +116,33 @@ async fn test_user_sql_commands_over_http() {
                 let role = rows[0].get("role").unwrap().as_str().unwrap();
                 assert_eq!(role, "dba");
 
+                // ALTER USER SET STORAGE_MODE / STORAGE_ID
+                let create_sql = "CREATE USER 'storage_test' WITH PASSWORD 'Password123!S' ROLE user STORAGE_MODE table";
+                server.execute_sql_with_auth(create_sql, &admin_auth).await?;
+
+                let alter_sql = "ALTER USER 'storage_test' SET STORAGE_MODE region";
+                let result = server.execute_sql_with_auth(alter_sql, &admin_auth).await?;
+                assert_eq!(result.status, ResponseStatus::Success);
+
+                let alter_sql = "ALTER USER 'storage_test' SET STORAGE_ID 'local'";
+                let result = server.execute_sql_with_auth(alter_sql, &admin_auth).await?;
+                assert_eq!(result.status, ResponseStatus::Success);
+
+                let query = "SELECT storage_mode, storage_id FROM system.users WHERE user_id = 'storage_test'";
+                let result = server.execute_sql_with_auth(query, &admin_auth).await?;
+                let rows = result.rows_as_maps();
+                let row = &rows[0];
+                assert_eq!(row.get("storage_mode").unwrap().as_str().unwrap(), "region");
+                assert_eq!(row.get("storage_id").unwrap().as_str().unwrap(), "local");
+
+                let alter_sql = "ALTER USER 'storage_test' SET STORAGE_ID NULL";
+                let result = server.execute_sql_with_auth(alter_sql, &admin_auth).await?;
+                assert_eq!(result.status, ResponseStatus::Success);
+
+                let result = server.execute_sql_with_auth(query, &admin_auth).await?;
+                let rows = result.rows_as_maps();
+                assert!(rows[0].get("storage_id").unwrap().is_null());
+
                 // DROP USER soft delete
                 let create_sql = "CREATE USER 'frank' WITH PASSWORD 'Password123!F' ROLE user";
                 server.execute_sql_with_auth(create_sql, &admin_auth).await?;
@@ -159,6 +188,13 @@ async fn test_user_sql_commands_over_http() {
                 let result = server.execute_sql_with_auth(alter_sql, &admin_auth).await?;
                 assert_eq!(result.status, ResponseStatus::Error);
 
+                // Invalid storage reference
+                let invalid_storage_sql = "CREATE USER 'bad_storage' WITH PASSWORD 'Password123!H' ROLE user STORAGE_ID 'missing_storage'";
+                let result = server
+                    .execute_sql_with_auth(invalid_storage_sql, &admin_auth)
+                    .await?;
+                assert_eq!(result.status, ResponseStatus::Error);
+
                 // DROP USER IF EXISTS
                 let drop_sql = "DROP USER IF EXISTS 'user_that_never_existed'";
                 let result = server.execute_sql_with_auth(drop_sql, &admin_auth).await?;
diff --git a/benchv2/results/bench-2026-05-05-145041-0-4-3-rc-4.html b/benchv2/results/bench-2026-05-05-145041-0-4-3-rc-4.html
new file mode 100644
index 00000000..a7fc39c4
--- /dev/null
+++ b/benchv2/results/bench-2026-05-05-145041-0-4-3-rc-4.html
@@ -0,0 +1,671 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>KalamDB Benchmark Report</title>
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js"></script>
+<style>
+  :root {
+    --bg: #0d1017;
+    --surface: #151922;
+    --surface2: #1c2130;
+    --surface3: #232839;
+    --border: #2a3044;
+    --border-light: #353b52;
+    --text: #e6e9f0;
+    --text2: #8891a8;
+    --text3: #5c6580;
+    --accent: #6366f1;
+    --accent2: #818cf8;
+    --accent-glow: rgba(99,102,241,0.12);
+    --green: #22c55e;
+    --green-bg: rgba(34,197,94,0.08);
+    --red: #ef4444;
+    --red-bg: rgba(239,68,68,0.08);
+    --orange: #f59e0b;
+    --blue: #3b82f6;
+    --purple: #a855f7;
+    --cyan: #06b6d4;
+    --radius: 10px;
+  }
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: var(--bg);
+    color: var(--text);
+    line-height: 1.65;
+    font-size: 15px;
+    -webkit-font-smoothing: antialiased;
+  }
+  .page { width: 100%; padding: 2rem 2.5rem; }
+
+  /* ── Header ── */
+  header {
+    text-align: center;
+    padding: 2.5rem 0 2rem;
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 2rem;
+  }
+  header h1 {
+    font-size: 2.2rem;
+    font-weight: 800;
+    letter-spacing: -0.02em;
+    background: linear-gradient(135deg, var(--accent), var(--purple));
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin-bottom: 0.4rem;
+  }
+  header .subtitle { color: var(--text2); font-size: 0.92rem; }
+  .meta {
+    display: flex;
+    gap: 0.75rem;
+    justify-content: center;
+    margin-top: 1rem;
+    flex-wrap: wrap;
+  }
+  .meta span {
+    background: var(--surface);
+    padding: 0.35rem 0.9rem;
+    border-radius: 20px;
+    font-size: 0.8rem;
+    border: 1px solid var(--border);
+    color: var(--text2);
+  }
+
+  /* ── Summary cards ── */
+  .summary-cards {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 1rem;
+    margin-bottom: 2rem;
+  }
+  .card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 1.4rem;
+    text-align: center;
+    transition: border-color .2s;
+  }
+  .card:hover { border-color: var(--border-light); }
+  .card .value {
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--accent2);
+    letter-spacing: -0.02em;
+  }
+  .card .label { color: var(--text2); font-size: 0.82rem; margin-top: 0.3rem; }
+  .card.pass .value { color: var(--green); }
+  .card.fail .value { color: var(--red); }
+  .breakdown-card {
+    text-align: left;
+    padding: 1.15rem 1.2rem;
+  }
+  .card-heading {
+    color: var(--text);
+    font-size: 0.82rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+  }
+  .summary-breakdown {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    gap: 0.55rem;
+    margin-top: 0.8rem;
+  }
+  .summary-breakdown-item {
+    background: var(--surface2);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 0.55rem 0.65rem;
+  }
+  .summary-breakdown-value {
+    display: block;
+    color: var(--text);
+    font-size: 1.3rem;
+    font-weight: 700;
+    line-height: 1.1;
+  }
+  .summary-breakdown-label {
+    display: block;
+    color: var(--text3);
+    font-size: 0.72rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-top: 0.24rem;
+  }
+  .summary-breakdown-item.tone-good .summary-breakdown-value { color: var(--green); }
+  .summary-breakdown-item.tone-warn .summary-breakdown-value { color: var(--orange); }
+  .summary-breakdown-item.tone-bad .summary-breakdown-value { color: var(--red); }
+  .summary-breakdown-item.tone-muted .summary-breakdown-value { color: var(--text2); }
+  .card-note {
+    color: var(--text3);
+    font-size: 0.74rem;
+    margin-top: 0.65rem;
+  }
+
+  .sys-panel {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 1.2rem;
+    margin-bottom: 1.5rem;
+  }
+  .sys-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 0.8rem 1.1rem;
+  }
+  .sys-item {
+    background: var(--surface2);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 0.55rem 0.75rem;
+  }
+  .sys-item .k {
+    color: var(--text3);
+    font-size: 0.73rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 0.2rem;
+  }
+  .sys-item .v {
+    color: var(--text);
+    font-size: 0.88rem;
+    font-weight: 500;
+    word-break: break-word;
+  }
+
+  /* ── Charts ── */
+  .charts {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1.25rem;
+    margin-bottom: 2rem;
+  }
+  .chart-box {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 1.4rem;
+  }
+  .chart-box h3 {
+    margin-bottom: 1rem;
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text);
+  }
+  .chart-box.wide { grid-column: 1 / -1; }
+
+  /* ── Table ── */
+  .section-title {
+    font-size: 1.15rem;
+    font-weight: 700;
+    margin-bottom: 1rem;
+    color: var(--text);
+  }
+  .table-wrap {
+    overflow-x: auto;
+    border-radius: var(--radius);
+    border: 1px solid var(--border);
+    margin-bottom: 2rem;
+  }
+  table {
+    width: 100%;
+    border-collapse: collapse;
+    background: var(--surface);
+    font-size: 0.88rem;
+  }
+  th {
+    background: var(--surface2);
+    padding: 0.75rem 0.9rem;
+    text-align: left;
+    font-size: 0.72rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--text3);
+    font-weight: 600;
+    white-space: nowrap;
+    position: sticky;
+    top: 0;
+    border-bottom: 2px solid var(--border);
+    border-right: 1px solid var(--border);
+  }
+  th:last-child { border-right: none; }
+  td {
+    padding: 0.65rem 0.9rem;
+    border-top: 1px solid var(--border);
+    border-right: 1px solid var(--border);
+    vertical-align: middle;
+  }
+  td:last-child { border-right: none; }
+  td.num {
+    text-align: right;
+    font-variant-numeric: tabular-nums;
+    font-family: 'JetBrains Mono', 'SF Mono', 'Fira Code', 'Cascadia Code', monospace;
+    font-size: 0.84rem;
+    color: var(--text);
+    white-space: nowrap;
+  }
+  td.num[title] { cursor: help; }
+  td.ops { color: var(--cyan); font-weight: 600; }
+  td.desc-col {
+    color: var(--text2);
+    max-width: 420px;
+    min-width: 320px;
+    white-space: normal;
+  }
+  .desc-wrap {
+    display: flex;
+    flex-direction: column;
+    gap: 0.45rem;
+  }
+  .desc-summary {
+    color: var(--text2);
+    line-height: 1.45;
+    cursor: help;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 3;
+    overflow: hidden;
+    text-decoration: underline dotted transparent;
+    text-underline-offset: 0.18rem;
+  }
+  .desc-summary:hover { text-decoration-color: var(--text3); }
+  .desc-summary:focus-visible {
+    outline: 1px solid rgba(129,140,248,0.5);
+    outline-offset: 3px;
+    text-decoration-color: var(--text3);
+  }
+  .detail-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.35rem;
+  }
+  .detail-pill {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    padding: 0.18rem 0.5rem;
+    border-radius: 999px;
+    background: rgba(129,140,248,0.08);
+    border: 1px solid rgba(129,140,248,0.16);
+    color: var(--text2);
+    font-size: 0.72rem;
+    line-height: 1.2;
+    white-space: nowrap;
+  }
+  .detail-label { color: var(--text3); }
+  .detail-value { color: var(--text); }
+  .hover-tooltip {
+    position: fixed;
+    left: 0;
+    top: 0;
+    z-index: 9999;
+    max-width: min(34rem, calc(100vw - 2rem));
+    padding: 0.75rem 0.9rem;
+    border-radius: 10px;
+    background: rgba(28,33,48,0.98);
+    border: 1px solid var(--border-light);
+    color: var(--text);
+    box-shadow: 0 18px 38px rgba(0,0,0,0.4);
+    font-size: 0.82rem;
+    line-height: 1.45;
+    white-space: normal;
+    pointer-events: none;
+    opacity: 0;
+    transform: translateY(4px);
+    transition: opacity .14s ease, transform .14s ease;
+  }
+  .hover-tooltip.is-visible {
+    opacity: 1;
+    transform: translateY(0);
+  }
+  tr:hover td { background: var(--surface2); }
+  tbody tr:nth-child(even) td { background: rgba(255,255,255,0.012); }
+  tbody tr:nth-child(even):hover td { background: var(--surface2); }
+
+  /* ── Badges ── */
+  .badge {
+    display: inline-block;
+    padding: 0.2rem 0.65rem;
+    border-radius: 6px;
+    font-size: 0.7rem;
+    font-weight: 700;
+    letter-spacing: 0.04em;
+  }
+  .badge-pass { background: var(--green-bg); color: var(--green); border: 1px solid rgba(34,197,94,0.2); }
+  .badge-fail { background: var(--red-bg); color: var(--red); border: 1px solid rgba(239,68,68,0.2); }
+  .cat-badge {
+    display: inline-block;
+    padding: 0.15rem 0.55rem;
+    border-radius: 6px;
+    font-size: 0.72rem;
+    font-weight: 500;
+    background: var(--accent-glow);
+    color: var(--accent2);
+  }
+  .error-msg { color: var(--red); font-size: 0.78rem; }
+
+  /* ── Verdict badges ── */
+  .verdict {
+    display: inline-block;
+    padding: 0.2rem 0.65rem;
+    border-radius: 6px;
+    font-size: 0.72rem;
+    font-weight: 600;
+    white-space: nowrap;
+  }
+  .verdict-excellent { background: var(--green-bg); color: var(--green); border: 1px solid rgba(34,197,94,0.25); }
+  .verdict-acceptable { background: rgba(245,158,11,0.08); color: var(--orange); border: 1px solid rgba(245,158,11,0.25); }
+  .verdict-slow { background: var(--red-bg); color: var(--red); border: 1px solid rgba(239,68,68,0.25); }
+  .verdict-failed { background: var(--red-bg); color: var(--red); border: 1px solid rgba(239,68,68,0.25); }
+
+  /* ── Comparison delta ── */
+  .delta {
+    display: inline-block;
+    padding: 0.15rem 0.55rem;
+    border-radius: 6px;
+    font-size: 0.72rem;
+    font-weight: 500;
+    white-space: nowrap;
+  }
+  .delta-faster { background: var(--green-bg); color: var(--green); }
+  .delta-slower { background: var(--red-bg); color: var(--red); }
+  .delta-same { color: var(--text3); }
+  .delta-none { color: var(--text3); }
+  tfoot td {
+    background: var(--surface2);
+    border-top: 2px solid var(--border-light);
+    font-weight: 600;
+  }
+  .suite-total-label {
+    color: var(--text);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-size: 0.76rem;
+  }
+  .suite-total-value {
+    color: var(--accent2);
+    font-size: 0.92rem;
+  }
+  .suite-total-meta {
+    color: var(--text2);
+    font-size: 0.8rem;
+    white-space: nowrap;
+  }
+
+  footer {
+    text-align: center;
+    padding: 1.5rem 0;
+    color: var(--text3);
+    font-size: 0.78rem;
+    border-top: 1px solid var(--border);
+    margin-top: 1rem;
+  }
+
+  @media (max-width: 1000px) {
+    .page { padding: 1rem; }
+    .charts { grid-template-columns: 1fr; }
+    .chart-box.wide { grid-column: 1; }
+    .summary-breakdown { grid-template-columns: 1fr; }
+  }
+</style>
+</head>
+<body>
+<div class="page">
+
+<header>
+  <h1>KalamDB Benchmark Report</h1>
+  <div class="subtitle">Performance analysis &mdash; v0.4.3-rc.4</div>
+  <div class="meta">
+    <span>http://127.0.0.1:8080</span>
+    <span>2026-05-05T14:50:41.736143+00:00</span>
+    <span>100 iters</span>
+    <span>5 warmup</span>
+    <span>10 concurrency</span>
+    <span>100.0K max subs</span>
+  </div>
+</header>
+
+<div class="summary-cards">
+  <div class="card">
+    <div class="value">38</div>
+    <div class="label">Total Benchmarks</div>
+  </div>
+  <div class="card pass">
+    <div class="value">38</div>
+    <div class="label">Passed</div>
+  </div>
+  <div class="card fail">
+    <div class="value">0</div>
+    <div class="label">Failed</div>
+  </div>
+  <div class="card breakdown-card"><div class="card-heading">Verdict Mix</div><div class="summary-breakdown"><div class="summary-breakdown-item tone-good"><span class="summary-breakdown-value">33</span><span class="summary-breakdown-label">Excellent</span></div><div class="summary-breakdown-item tone-warn"><span class="summary-breakdown-value">4</span><span class="summary-breakdown-label">Acceptable</span></div><div class="summary-breakdown-item tone-bad"><span class="summary-breakdown-value">1</span><span class="summary-breakdown-label">Slow</span></div></div><div class="card-note">successful benchmarks only</div></div>
+  <div class="card breakdown-card"><div class="card-heading">Compared To Previous</div><div class="summary-breakdown"><div class="summary-breakdown-item tone-good"><span class="summary-breakdown-value">1</span><span class="summary-breakdown-label">Faster</span></div><div class="summary-breakdown-item tone-muted"><span class="summary-breakdown-value">29</span><span class="summary-breakdown-label">Same</span></div><div class="summary-breakdown-item tone-bad"><span class="summary-breakdown-value">8</span><span class="summary-breakdown-label">Slower</span></div></div><div class="card-note">against 2026-04-29T19:14:33.905313+00:00</div></div>
+  <div class="card">
+    <div class="value">237.663s</div>
+    <div class="label">Measured Benchmark Time</div>
+  </div>
+  <div class="card">
+    <div class="value">271.290s</div>
+    <div class="label">Wall Clock Duration</div>
+  </div>
+</div>
+
+<div class="sys-panel">
+  <div class="section-title">System Information</div>
+  <div class="sys-grid">
+    <div class="sys-item"><div class="k">Hostname</div><div class="v">Jamals-MacBook-Pro.local</div></div>
+    <div class="sys-item"><div class="k">Machine Model</div><div class="v">MacBookPro18,3</div></div>
+    <div class="sys-item"><div class="k">CPU Model</div><div class="v">Apple M1 Pro</div></div>
+    <div class="sys-item"><div class="k">CPU Cores</div><div class="v">10 logical / 10 physical</div></div>
+    <div class="sys-item"><div class="k">Total Memory</div><div class="v">16.00 GiB</div></div>
+    <div class="sys-item"><div class="k">Available Memory</div><div class="v">10.74 GiB</div></div>
+    <div class="sys-item"><div class="k">Used Memory</div><div class="v">5.26 GiB</div></div>
+    <div class="sys-item"><div class="k">Memory Usage</div><div class="v">32.9%</div></div>
+    <div class="sys-item"><div class="k">OS</div><div class="v">Darwin macOS 26.5</div></div>
+    <div class="sys-item"><div class="k">Kernel</div><div class="v">25.5.0</div></div>
+    <div class="sys-item"><div class="k">Architecture</div><div class="v">aarch64</div></div>
+  </div>
+</div>
+
+<div class="charts">
+  <div class="chart-box wide">
+    <h3>Latency by Operation (µs)</h3>
+    <canvas id="latencyChart" height="70"></canvas>
+  </div>
+  <div class="chart-box">
+    <h3>Throughput (ops/sec)</h3>
+    <canvas id="throughputChart" height="120"></canvas>
+  </div>
+  <div class="chart-box">
+    <h3>Avg Latency by Category (µs)</h3>
+    <canvas id="categoryChart" height="120"></canvas>
+  </div>
+</div>
+
+<div class="section-title">Detailed Results</div>
+<div class="table-wrap">
+<table>
+  <thead>
+    <tr>
+      <th>Status</th>
+      <th>Benchmark</th>
+      <th>Category</th>
+      <th>Description</th>
+      <th style="text-align:right">Iters</th>
+      <th style="text-align:right">Mean</th>
+      <th style="text-align:right">P50</th>
+      <th style="text-align:right">P95</th>
+      <th style="text-align:right">P99</th>
+      <th style="text-align:right">Min</th>
+      <th style="text-align:right">Max</th>
+      <th style="text-align:right">Ops/sec</th>
+      <th style="text-align:right">Total</th>
+      <th>Verdict</th>
+      <th>vs Prev</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr><td><span class="badge badge-pass">PASS</span></td><td><strong>create_table</strong></td><td><span class="cat-badge">DDL</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="CREATE TABLE with 3 columns" data-full-description="CREATE TABLE with 3 columns" tabindex="0">CREATE TABLE with 3 columns</div></div></td><td class="num">100</td><td class="num" title="402µs exact">402µs</td><td class="num" title="384µs exact">384µs</td><td class="num" title="508µs exact">508µs</td><td class="num" title="589µs exact">589µs</td><td class="num" title="351µs exact">351µs</td><td class="num" title="603µs exact">603µs</td><td class="num ops">2.5K</td><td class="num" title="40224µs exact">40.2ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 406µs">~ 406µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>drop_table</strong></td><td><span class="cat-badge">DDL</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="DROP TABLE on a previously created table" data-full-description="DROP TABLE on a previously created table" tabindex="0">DROP TABLE on a previously created table</div></div></td><td class="num">100</td><td class="num" title="4727µs exact">4.73ms</td><td class="num" title="4742µs exact">4.74ms</td><td class="num" title="5810µs exact">5.81ms</td><td class="num" title="5889µs exact">5.89ms</td><td class="num" title="3344µs exact">3.34ms</td><td class="num" title="6695µs exact">6.70ms</td><td class="num ops">212</td><td class="num" title="472671µs exact">472.7ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 4619µs">~ 4619µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>single_insert</strong></td><td><span class="cat-badge">Insert</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="INSERT a single row into a table" data-full-description="INSERT a single row into a table" tabindex="0">INSERT a single row into a table</div></div></td><td class="num">100</td><td class="num" title="270µs exact">270µs</td><td class="num" title="269µs exact">269µs</td><td class="num" title="319µs exact">319µs</td><td class="num" title="416µs exact">416µs</td><td class="num" title="211µs exact">211µs</td><td class="num" title="451µs exact">451µs</td><td class="num ops">3.7K</td><td class="num" title="27050µs exact">27.1ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 263µs">~ 263µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>bulk_insert</strong></td><td><span class="cat-badge">Insert</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="One INSERT statement with 50 rows (statement-scoped transaction)" data-full-description="One INSERT statement with 50 rows (statement-scoped transaction)" tabindex="0">One INSERT statement with 50 rows (statement-scoped transaction)</div></div></td><td class="num">100</td><td class="num" title="986µs exact">986µs</td><td class="num" title="966µs exact">966µs</td><td class="num" title="1160µs exact">1.16ms</td><td class="num" title="1195µs exact">1.20ms</td><td class="num" title="827µs exact">827µs</td><td class="num" title="1326µs exact">1.33ms</td><td class="num ops">1.0K</td><td class="num" title="98563µs exact">98.6ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 992µs">~ 992µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>transaction_multi_insert</strong></td><td><span class="cat-badge">Insert</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Explicit BEGIN/COMMIT with 50 single-row INSERT statements" data-full-description="Explicit BEGIN/COMMIT with 50 single-row INSERT statements" tabindex="0">Explicit BEGIN/COMMIT with 50 single-row INSERT statements</div></div></td><td class="num">100</td><td class="num" title="3161µs exact">3.16ms</td><td class="num" title="3131µs exact">3.13ms</td><td class="num" title="3602µs exact">3.60ms</td><td class="num" title="3978µs exact">3.98ms</td><td class="num" title="2822µs exact">2.82ms</td><td class="num" title="3997µs exact">4.00ms</td><td class="num ops">316</td><td class="num" title="316058µs exact">316.1ms</td><td><span class="verdict verdict-acceptable">🟡 Acceptable</span></td><td><span class="delta delta-same" title="previous mean: 3126µs">~ 3126µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>select_all</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT * from a 200-row table" data-full-description="SELECT * from a 200-row table" tabindex="0">SELECT * from a 200-row table</div></div></td><td class="num">100</td><td class="num" title="796µs exact">796µs</td><td class="num" title="774µs exact">774µs</td><td class="num" title="889µs exact">889µs</td><td class="num" title="1034µs exact">1.03ms</td><td class="num" title="753µs exact">753µs</td><td class="num" title="1040µs exact">1.04ms</td><td class="num ops">1.3K</td><td class="num" title="79602µs exact">79.6ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 782µs">~ 782µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>select_by_filter</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT with WHERE clause on a 200-row table" data-full-description="SELECT with WHERE clause on a 200-row table" tabindex="0">SELECT with WHERE clause on a 200-row table</div></div></td><td class="num">100</td><td class="num" title="405µs exact">405µs</td><td class="num" title="400µs exact">400µs</td><td class="num" title="497µs exact">497µs</td><td class="num" title="558µs exact">558µs</td><td class="num" title="321µs exact">321µs</td><td class="num" title="563µs exact">563µs</td><td class="num ops">2.5K</td><td class="num" title="40536µs exact">40.5ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 397µs">~ 397µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>select_count</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT COUNT(*) on a 200-row table" data-full-description="SELECT COUNT(*) on a 200-row table" tabindex="0">SELECT COUNT(*) on a 200-row table</div></div></td><td class="num">100</td><td class="num" title="628µs exact">628µs</td><td class="num" title="616µs exact">616µs</td><td class="num" title="728µs exact">728µs</td><td class="num" title="750µs exact">750µs</td><td class="num" title="580µs exact">580µs</td><td class="num" title="813µs exact">813µs</td><td class="num ops">1.6K</td><td class="num" title="62847µs exact">62.8ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 608µs">↓3% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>select_order_by_limit</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT with ORDER BY + LIMIT 10 on a 200-row table" data-full-description="SELECT with ORDER BY + LIMIT 10 on a 200-row table" tabindex="0">SELECT with ORDER BY + LIMIT 10 on a 200-row table</div></div></td><td class="num">100</td><td class="num" title="809µs exact">809µs</td><td class="num" title="794µs exact">794µs</td><td class="num" title="947µs exact">947µs</td><td class="num" title="1118µs exact">1.12ms</td><td class="num" title="761µs exact">761µs</td><td class="num" title="1153µs exact">1.15ms</td><td class="num ops">1.2K</td><td class="num" title="80940µs exact">80.9ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 831µs">~ 831µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>single_update</strong></td><td><span class="cat-badge">Update</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="UPDATE a single row by filter condition" data-full-description="UPDATE a single row by filter condition" tabindex="0">UPDATE a single row by filter condition</div></div></td><td class="num">100</td><td class="num" title="907µs exact">907µs</td><td class="num" title="889µs exact">889µs</td><td class="num" title="1094µs exact">1.09ms</td><td class="num" title="1249µs exact">1.25ms</td><td class="num" title="818µs exact">818µs</td><td class="num" title="1320µs exact">1.32ms</td><td class="num ops">1.1K</td><td class="num" title="90708µs exact">90.7ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 869µs">↓4% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>single_delete</strong></td><td><span class="cat-badge">Delete</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="DELETE a single row by filter condition" data-full-description="DELETE a single row by filter condition" tabindex="0">DELETE a single row by filter condition</div></div></td><td class="num">100</td><td class="num" title="1323µs exact">1.32ms</td><td class="num" title="1300µs exact">1.30ms</td><td class="num" title="1530µs exact">1.53ms</td><td class="num" title="1632µs exact">1.63ms</td><td class="num" title="1208µs exact">1.21ms</td><td class="num" title="1681µs exact">1.68ms</td><td class="num ops">756</td><td class="num" title="132325µs exact">132.3ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 1265µs">↓5% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_insert</strong></td><td><span class="cat-badge">Concurrent</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N concurrent INSERT operations in parallel (N = concurrency setting)" data-full-description="N concurrent INSERT operations in parallel (N = concurrency setting)" tabindex="0">N concurrent INSERT operations in parallel (N = concurrency setting)</div></div></td><td class="num">100</td><td class="num" title="1371µs exact">1.37ms</td><td class="num" title="1285µs exact">1.28ms</td><td class="num" title="1684µs exact">1.68ms</td><td class="num" title="1912µs exact">1.91ms</td><td class="num" title="1134µs exact">1.13ms</td><td class="num" title="4860µs exact">4.86ms</td><td class="num ops">729</td><td class="num" title="137091µs exact">137.1ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 1344µs">~ 1344µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_select</strong></td><td><span class="cat-badge">Concurrent</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N concurrent SELECT operations in parallel (N = concurrency setting)" data-full-description="N concurrent SELECT operations in parallel (N = concurrency setting)" tabindex="0">N concurrent SELECT operations in parallel (N = concurrency setting)</div></div></td><td class="num">100</td><td class="num" title="1200µs exact">1.20ms</td><td class="num" title="1210µs exact">1.21ms</td><td class="num" title="1389µs exact">1.39ms</td><td class="num" title="1433µs exact">1.43ms</td><td class="num" title="885µs exact">885µs</td><td class="num" title="1474µs exact">1.47ms</td><td class="num ops">833</td><td class="num" title="120044µs exact">120.0ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 1155µs">↓4% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>point_lookup</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT by primary key from a 10K-row table (single row lookup)" data-full-description="SELECT by primary key from a 10K-row table (single row lookup)" tabindex="0">SELECT by primary key from a 10K-row table (single row lookup)</div><div class="detail-list"><span class="detail-pill" title="Baseline: phase-0 performance"><span class="detail-label">Baseline</span><span class="detail-value">phase-0 performance</span></span><span class="detail-pill" title="Query Class: primary-key lookup"><span class="detail-label">Query Class</span><span class="detail-value">primary-key lookup</span></span><span class="detail-pill" title="Dataset: 10000 seeded rows"><span class="detail-label">Dataset</span><span class="detail-value">10000 seeded rows</span></span><span class="detail-pill" title="Query Shape: SELECT * FROM &lt;ns&gt;.point_lookup WHERE id = ?"><span class="detail-label">Query Shape</span><span class="detail-value">SELECT * FROM &lt;ns&gt;.point_lookup WHERE id = ?</span></span></div></div></td><td class="num">100</td><td class="num" title="392µs exact">392µs</td><td class="num" title="394µs exact">394µs</td><td class="num" title="452µs exact">452µs</td><td class="num" title="514µs exact">514µs</td><td class="num" title="322µs exact">322µs</td><td class="num" title="536µs exact">536µs</td><td class="num ops">2.5K</td><td class="num" title="39239µs exact">39.2ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 386µs">~ 386µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>aggregate_query</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="GROUP BY + SUM/AVG/COUNT on a 10K-row table (analytical query performance)" data-full-description="GROUP BY + SUM/AVG/COUNT on a 10K-row table (analytical query performance)" tabindex="0">GROUP BY + SUM/AVG/COUNT on a 10K-row table (analytical query performance)</div></div></td><td class="num">100</td><td class="num" title="28346µs exact">28.3ms</td><td class="num" title="28173µs exact">28.2ms</td><td class="num" title="29822µs exact">29.8ms</td><td class="num" title="31097µs exact">31.1ms</td><td class="num" title="26976µs exact">27.0ms</td><td class="num" title="31688µs exact">31.7ms</td><td class="num ops">35</td><td class="num" title="2834569µs exact">2.835s</td><td><span class="verdict verdict-slow">🔴 Slow</span></td><td><span class="delta delta-slower" title="previous mean: 27518µs">↓3% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>multi_table_join</strong></td><td><span class="cat-badge">Select</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT with subquery across two tables (200 customers, 1000 orders)" data-full-description="SELECT with subquery across two tables (200 customers, 1000 orders)" tabindex="0">SELECT with subquery across two tables (200 customers, 1000 orders)</div></div></td><td class="num">100</td><td class="num" title="3143µs exact">3.14ms</td><td class="num" title="3098µs exact">3.10ms</td><td class="num" title="3454µs exact">3.45ms</td><td class="num" title="3720µs exact">3.72ms</td><td class="num" title="3006µs exact">3.01ms</td><td class="num" title="3830µs exact">3.83ms</td><td class="num ops">318</td><td class="num" title="314311µs exact">314.3ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 3076µs">~ 3076µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>large_payload_insert</strong></td><td><span class="cat-badge">Insert</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="INSERT rows with ~4KB TEXT payloads (serialization + storage throughput)" data-full-description="INSERT rows with ~4KB TEXT payloads (serialization + storage throughput)" tabindex="0">INSERT rows with ~4KB TEXT payloads (serialization + storage throughput)</div></div></td><td class="num">100</td><td class="num" title="1657µs exact">1.66ms</td><td class="num" title="1646µs exact">1.65ms</td><td class="num" title="1884µs exact">1.88ms</td><td class="num" title="2051µs exact">2.05ms</td><td class="num" title="1461µs exact">1.46ms</td><td class="num" title="2142µs exact">2.14ms</td><td class="num ops">604</td><td class="num" title="165667µs exact">165.7ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 1656µs">~ 1656µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>wide_column_insert</strong></td><td><span class="cat-badge">Insert</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="INSERT into a 20-column table (wide schema overhead)" data-full-description="INSERT into a 20-column table (wide schema overhead)" tabindex="0">INSERT into a 20-column table (wide schema overhead)</div></div></td><td class="num">100</td><td class="num" title="919µs exact">919µs</td><td class="num" title="890µs exact">890µs</td><td class="num" title="1082µs exact">1.08ms</td><td class="num" title="1238µs exact">1.24ms</td><td class="num" title="818µs exact">818µs</td><td class="num" title="1260µs exact">1.26ms</td><td class="num ops">1.1K</td><td class="num" title="91947µs exact">91.9ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 903µs">~ 903µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>bulk_delete</strong></td><td><span class="cat-badge">Delete</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="DELETE 100 rows at once with a range filter (bulk deletion)" data-full-description="DELETE 100 rows at once with a range filter (bulk deletion)" tabindex="0">DELETE 100 rows at once with a range filter (bulk deletion)</div></div></td><td class="num">100</td><td class="num" title="69050µs exact">69.1ms</td><td class="num" title="69288µs exact">69.3ms</td><td class="num" title="75547µs exact">75.5ms</td><td class="num" title="76753µs exact">76.8ms</td><td class="num" title="61249µs exact">61.2ms</td><td class="num" title="80458µs exact">80.5ms</td><td class="num ops">14</td><td class="num" title="6905026µs exact">6.905s</td><td><span class="verdict verdict-acceptable">🟡 Acceptable</span></td><td><span class="delta delta-same" title="previous mean: 67553µs">~ 67553µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>sequential_crud</strong></td><td><span class="cat-badge">DML</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="INSERT → UPDATE → SELECT → DELETE full DML lifecycle per iteration" data-full-description="INSERT → UPDATE → SELECT → DELETE full DML lifecycle per iteration" tabindex="0">INSERT → UPDATE → SELECT → DELETE full DML lifecycle per iteration</div></div></td><td class="num">100</td><td class="num" title="2280µs exact">2.28ms</td><td class="num" title="2208µs exact">2.21ms</td><td class="num" title="2719µs exact">2.72ms</td><td class="num" title="3235µs exact">3.24ms</td><td class="num" title="1573µs exact">1.57ms</td><td class="num" title="10276µs exact">10.3ms</td><td class="num ops">439</td><td class="num" title="227969µs exact">228.0ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 2159µs">↓6% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>alter_table</strong></td><td><span class="cat-badge">DDL</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="ALTER TABLE ADD COLUMN + DROP COLUMN (schema evolution latency)" data-full-description="ALTER TABLE ADD COLUMN + DROP COLUMN (schema evolution latency)" tabindex="0">ALTER TABLE ADD COLUMN + DROP COLUMN (schema evolution latency)</div></div></td><td class="num">100</td><td class="num" title="1232µs exact">1.23ms</td><td class="num" title="1138µs exact">1.14ms</td><td class="num" title="1587µs exact">1.59ms</td><td class="num" title="2324µs exact">2.32ms</td><td class="num" title="1068µs exact">1.07ms</td><td class="num" title="2452µs exact">2.45ms</td><td class="num ops">812</td><td class="num" title="123153µs exact">123.2ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 1193µs">↓3% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_update</strong></td><td><span class="cat-badge">Concurrent</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N concurrent UPDATE operations on the same table (write contention test)" data-full-description="N concurrent UPDATE operations on the same table (write contention test)" tabindex="0">N concurrent UPDATE operations on the same table (write contention test)</div></div></td><td class="num">100</td><td class="num" title="3240µs exact">3.24ms</td><td class="num" title="3212µs exact">3.21ms</td><td class="num" title="4294µs exact">4.29ms</td><td class="num" title="5139µs exact">5.14ms</td><td class="num" title="2120µs exact">2.12ms</td><td class="num" title="5472µs exact">5.47ms</td><td class="num ops">309</td><td class="num" title="324019µs exact">324.0ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-faster" title="previous mean: 3370µs">↑4% faster</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_mixed_dml</strong></td><td><span class="cat-badge">Concurrent</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Concurrent INSERT + UPDATE + DELETE on the same table (multi-op contention)" data-full-description="Concurrent INSERT + UPDATE + DELETE on the same table (multi-op contention)" tabindex="0">Concurrent INSERT + UPDATE + DELETE on the same table (multi-op contention)</div></div></td><td class="num">100</td><td class="num" title="3268µs exact">3.27ms</td><td class="num" title="3258µs exact">3.26ms</td><td class="num" title="4069µs exact">4.07ms</td><td class="num" title="4386µs exact">4.39ms</td><td class="num" title="2309µs exact">2.31ms</td><td class="num" title="4649µs exact">4.65ms</td><td class="num ops">306</td><td class="num" title="326783µs exact">326.8ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 3244µs">~ 3244µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>namespace_isolation</strong></td><td><span class="cat-badge">Concurrent</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Concurrent queries across 5 different namespaces (isolation test)" data-full-description="Concurrent queries across 5 different namespaces (isolation test)" tabindex="0">Concurrent queries across 5 different namespaces (isolation test)</div></div></td><td class="num">100</td><td class="num" title="1817µs exact">1.82ms</td><td class="num" title="1808µs exact">1.81ms</td><td class="num" title="2124µs exact">2.12ms</td><td class="num" title="2229µs exact">2.23ms</td><td class="num" title="1512µs exact">1.51ms</td><td class="num" title="2411µs exact">2.41ms</td><td class="num ops">551</td><td class="num" title="181652µs exact">181.7ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 1822µs">~ 1822µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>subscribe_initial_load</strong></td><td><span class="cat-badge">Subscribe</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Subscribe to a 1000-row user table and receive the full initial data batch" data-full-description="Subscribe to a 1000-row user table and receive the full initial data batch" tabindex="0">Subscribe to a 1000-row user table and receive the full initial data batch</div></div></td><td class="num">100</td><td class="num" title="6406µs exact">6.41ms</td><td class="num" title="6328µs exact">6.33ms</td><td class="num" title="6727µs exact">6.73ms</td><td class="num" title="7116µs exact">7.12ms</td><td class="num" title="6252µs exact">6.25ms</td><td class="num" title="7516µs exact">7.52ms</td><td class="num ops">156</td><td class="num" title="640588µs exact">640.6ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 6326µs">~ 6326µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>subscribe_change_latency</strong></td><td><span class="cat-badge">Subscribe</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Latency from INSERT to subscriber receiving the change notification" data-full-description="Latency from INSERT to subscriber receiving the change notification" tabindex="0">Latency from INSERT to subscriber receiving the change notification</div></div></td><td class="num">100</td><td class="num" title="51885µs exact">51.9ms</td><td class="num" title="50602µs exact">50.6ms</td><td class="num" title="60177µs exact">60.2ms</td><td class="num" title="75003µs exact">75.0ms</td><td class="num" title="46229µs exact">46.2ms</td><td class="num" title="76132µs exact">76.1ms</td><td class="num ops">19</td><td class="num" title="5188492µs exact">5.188s</td><td><span class="verdict verdict-acceptable">🟡 Acceptable</span></td><td><span class="delta delta-same" title="previous mean: 51379µs">~ 51379µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>reconnect_subscribe</strong></td><td><span class="cat-badge">Subscribe</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Disconnect and re-subscribe to a user table (reconnection overhead)" data-full-description="Disconnect and re-subscribe to a user table (reconnection overhead)" tabindex="0">Disconnect and re-subscribe to a user table (reconnection overhead)</div></div></td><td class="num">100</td><td class="num" title="10051µs exact">10.1ms</td><td class="num" title="10250µs exact">10.3ms</td><td class="num" title="11058µs exact">11.1ms</td><td class="num" title="11181µs exact">11.2ms</td><td class="num" title="8819µs exact">8.82ms</td><td class="num" title="11354µs exact">11.4ms</td><td class="num ops">99</td><td class="num" title="1005135µs exact">1.005s</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 10342µs">~ 10342µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>flushed_parquet_query</strong></td><td><span class="cat-badge">Storage</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="SELECT from a shared table with 20 flushed Parquet files (200K rows)" data-full-description="SELECT from a shared table with 20 flushed Parquet files (200K rows)" tabindex="0">SELECT from a shared table with 20 flushed Parquet files (200K rows)</div></div></td><td class="num">100</td><td class="num" title="153249µs exact">153.2ms</td><td class="num" title="184604µs exact">184.6ms</td><td class="num" title="246566µs exact">246.6ms</td><td class="num" title="255057µs exact">255.1ms</td><td class="num" title="24227µs exact">24.2ms</td><td class="num" title="257815µs exact">257.8ms</td><td class="num ops">7</td><td class="num" title="15324861µs exact">15.325s</td><td><span class="verdict verdict-acceptable">🟡 Acceptable</span></td><td><span class="delta delta-same" title="previous mean: 152145µs">~ 152145µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_subscribers</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N WebSocket live-query subscribers receiving changes from concurrent writes" data-full-description="N WebSocket live-query subscribers receiving changes from concurrent writes" tabindex="0">N WebSocket live-query subscribers receiving changes from concurrent writes</div></div></td><td class="num">100</td><td class="num" title="1554848µs exact">1.555s</td><td class="num" title="1555272µs exact">1.555s</td><td class="num" title="1576874µs exact">1.577s</td><td class="num" title="1579660µs exact">1.580s</td><td class="num" title="1523989µs exact">1.524s</td><td class="num" title="1621753µs exact">1.622s</td><td class="num ops">1</td><td class="num" title="155484760µs exact">2.59m</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 1556231µs">~ 1556231µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_publishers</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N concurrent INSERTs into a topic-sourced table (measures publish overhead)" data-full-description="N concurrent INSERTs into a topic-sourced table (measures publish overhead)" tabindex="0">N concurrent INSERTs into a topic-sourced table (measures publish overhead)</div></div></td><td class="num">100</td><td class="num" title="1465µs exact">1.46ms</td><td class="num" title="1412µs exact">1.41ms</td><td class="num" title="1807µs exact">1.81ms</td><td class="num" title="1897µs exact">1.90ms</td><td class="num" title="1260µs exact">1.26ms</td><td class="num" title="2070µs exact">2.07ms</td><td class="num ops">683</td><td class="num" title="146474µs exact">146.5ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 1491µs">~ 1491µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>concurrent_consumers</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N concurrent topic CONSUME calls pulling messages in parallel" data-full-description="N concurrent topic CONSUME calls pulling messages in parallel" tabindex="0">N concurrent topic CONSUME calls pulling messages in parallel</div></div></td><td class="num">100</td><td class="num" title="614µs exact">614µs</td><td class="num" title="610µs exact">610µs</td><td class="num" title="688µs exact">688µs</td><td class="num" title="714µs exact">714µs</td><td class="num" title="530µs exact">530µs</td><td class="num" title="734µs exact">734µs</td><td class="num ops">1.6K</td><td class="num" title="61448µs exact">61.4ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 618µs">~ 618µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>sql_1k_concurrent</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="1000 concurrent SQL SELECT queries at once (RPS degradation test)" data-full-description="1000 concurrent SQL SELECT queries at once (RPS degradation test)" tabindex="0">1000 concurrent SQL SELECT queries at once (RPS degradation test)</div><div class="detail-list"><span class="detail-pill" title="Baseline: phase-0 performance"><span class="detail-label">Baseline</span><span class="detail-value">phase-0 performance</span></span><span class="detail-pill" title="Query Class: concurrent read burst"><span class="detail-label">Query Class</span><span class="detail-value">concurrent read burst</span></span><span class="detail-pill" title="Dataset: 500 seeded rows"><span class="detail-label">Dataset</span><span class="detail-value">500 seeded rows</span></span><span class="detail-pill" title="Burst: 1000 concurrent SQL queries"><span class="detail-label">Burst</span><span class="detail-value">1000 concurrent SQL queries</span></span><span class="detail-pill" title="Query Mix: pk lookup, count, selective order-by limit, narrow projection"><span class="detail-label">Query Mix</span><span class="detail-value">pk lookup, count, selective order-by limit, narrow projection</span></span></div></div></td><td class="num">100</td><td class="num" title="152294µs exact">152.3ms</td><td class="num" title="151536µs exact">151.5ms</td><td class="num" title="158048µs exact">158.0ms</td><td class="num" title="161511µs exact">161.5ms</td><td class="num" title="145510µs exact">145.5ms</td><td class="num" title="173239µs exact">173.2ms</td><td class="num ops">7</td><td class="num" title="15229428µs exact">15.229s</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 152325µs">~ 152325µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>create_user</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="CREATE USER (auth subsystem stress test)" data-full-description="CREATE USER (auth subsystem stress test)" tabindex="0">CREATE USER (auth subsystem stress test)</div></div></td><td class="num">100</td><td class="num" title="1237µs exact">1.24ms</td><td class="num" title="1212µs exact">1.21ms</td><td class="num" title="1392µs exact">1.39ms</td><td class="num" title="1514µs exact">1.51ms</td><td class="num" title="1161µs exact">1.16ms</td><td class="num" title="1546µs exact">1.55ms</td><td class="num ops">808</td><td class="num" title="123715µs exact">123.7ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 1220µs">~ 1220µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>drop_user</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="DROP USER (auth subsystem teardown stress test)" data-full-description="DROP USER (auth subsystem teardown stress test)" tabindex="0">DROP USER (auth subsystem teardown stress test)</div></div></td><td class="num">100</td><td class="num" title="278µs exact">278µs</td><td class="num" title="252µs exact">252µs</td><td class="num" title="368µs exact">368µs</td><td class="num" title="431µs exact">431µs</td><td class="num" title="230µs exact">230µs</td><td class="num" title="544µs exact">544µs</td><td class="num ops">3.6K</td><td class="num" title="27816µs exact">27.8ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 273µs">~ 273µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>connection_storm</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N simultaneous login + SQL + cycles (connection setup overhead)" data-full-description="N simultaneous login + SQL + cycles (connection setup overhead)" tabindex="0">N simultaneous login + SQL + cycles (connection setup overhead)</div></div></td><td class="num">100</td><td class="num" title="275406µs exact">275.4ms</td><td class="num" title="274268µs exact">274.3ms</td><td class="num" title="284981µs exact">285.0ms</td><td class="num" title="300631µs exact">300.6ms</td><td class="num" title="265960µs exact">266.0ms</td><td class="num" title="317678µs exact">317.7ms</td><td class="num ops">4</td><td class="num" title="27540574µs exact">27.541s</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 275462µs">~ 275462µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>mixed_read_write</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="50/50 concurrent reads + writes on same table (contention test)" data-full-description="50/50 concurrent reads + writes on same table (contention test)" tabindex="0">50/50 concurrent reads + writes on same table (contention test)</div><div class="detail-list"><span class="detail-pill" title="Baseline: phase-0 performance"><span class="detail-label">Baseline</span><span class="detail-value">phase-0 performance</span></span><span class="detail-pill" title="Query Class: mixed concurrent read/write"><span class="detail-label">Query Class</span><span class="detail-value">mixed concurrent read/write</span></span><span class="detail-pill" title="Dataset: 200 seeded rows"><span class="detail-label">Dataset</span><span class="detail-value">200 seeded rows</span></span><span class="detail-pill" title="Mix: 5 reads / 5 writes"><span class="detail-label">Mix</span><span class="detail-value">5 reads / 5 writes</span></span><span class="detail-pill" title="Read Shapes: range filter, count-star, order-by desc limit"><span class="detail-label">Read Shapes</span><span class="detail-value">range filter, count-star, order-by desc limit</span></span></div></div></td><td class="num">100</td><td class="num" title="2217µs exact">2.22ms</td><td class="num" title="2202µs exact">2.20ms</td><td class="num" title="2831µs exact">2.83ms</td><td class="num" title="3745µs exact">3.75ms</td><td class="num" title="1452µs exact">1.45ms</td><td class="num" title="5767µs exact">5.77ms</td><td class="num ops">451</td><td class="num" title="221651µs exact">221.7ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-slower" title="previous mean: 2106µs">↓5% slower</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>wide_fanout_query</strong></td><td><span class="cat-badge">Load</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="N concurrent large-result-set SELECTs (serialization + memory pressure)" data-full-description="N concurrent large-result-set SELECTs (serialization + memory pressure)" tabindex="0">N concurrent large-result-set SELECTs (serialization + memory pressure)</div></div></td><td class="num">100</td><td class="num" title="5952µs exact">5.95ms</td><td class="num" title="5922µs exact">5.92ms</td><td class="num" title="6479µs exact">6.48ms</td><td class="num" title="7132µs exact">7.13ms</td><td class="num" title="5334µs exact">5.33ms</td><td class="num" title="7892µs exact">7.89ms</td><td class="num ops">168</td><td class="num" title="595211µs exact">595.2ms</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 5991µs">~ 5991µs prior</span></td></tr><tr><td><span class="badge badge-pass">PASS</span></td><td><strong>subscriber_scale</strong></td><td><span class="cat-badge">Scale</span></td><td class="desc-col"><div class="desc-wrap"><div class="desc-summary" title="Progressively ramps cumulative live-query subscribers across tiers 10 -&gt; 100 -&gt; 500 -&gt; 1.0K -&gt; 2.0K -&gt; 5.0K -&gt; 10.0K -&gt; 25.0K -&gt; 50.0K -&gt; 100.0K to verify connection establishment, subscription completion, and INSERT fanout delivery. Delivery probes run at 10 -&gt; 100 -&gt; 500 -&gt; 1.0K -&gt; 2.0K -&gt; 5.0K -&gt; 10.0K -&gt; 25.0K -&gt; 50.0K -&gt; 100.0K. This run is configured with connect_batch=1.0K, wave_size=500, wave_pause=0ms, connect_timeout=30.0s, 1 shared WebSocket target, 100 subscriptions per shared WebSocket connection, and a pooled shared-connection budget of 1.0K." data-full-description="Progressively ramps cumulative live-query subscribers across tiers 10 -&gt; 100 -&gt; 500 -&gt; 1.0K -&gt; 2.0K -&gt; 5.0K -&gt; 10.0K -&gt; 25.0K -&gt; 50.0K -&gt; 100.0K to verify connection establishment, subscription completion, and INSERT fanout delivery. Delivery probes run at 10 -&gt; 100 -&gt; 500 -&gt; 1.0K -&gt; 2.0K -&gt; 5.0K -&gt; 10.0K -&gt; 25.0K -&gt; 50.0K -&gt; 100.0K. This run is configured with connect_batch=1.0K, wave_size=500, wave_pause=0ms, connect_timeout=30.0s, 1 shared WebSocket target, 100 subscriptions per shared WebSocket connection, and a pooled shared-connection budget of 1.0K." tabindex="0">Progressive live-query subscriber scale and insert fanout verification up to 100.0K</div><div class="detail-list"><span class="detail-pill" title="Max: 100.0K"><span class="detail-label">Max</span><span class="detail-value">100.0K</span></span><span class="detail-pill" title="Tiers: 10 checkpoints to 100.0K"><span class="detail-label">Tiers</span><span class="detail-value">10 checkpoints to 100.0K</span></span><span class="detail-pill" title="Batch/Wave: 1.0K / 500"><span class="detail-label">Batch/Wave</span><span class="detail-value">1.0K / 500</span></span><span class="detail-pill" title="Pause/Timeout: 0ms / 30.0s"><span class="detail-label">Pause/Timeout</span><span class="detail-value">0ms / 30.0s</span></span><span class="detail-pill" title="Shared WS: 1.0K conns @ 100 subs/ws across 1 target"><span class="detail-label">Shared WS</span><span class="detail-value">1.0K conns @ 100 subs/ws across 1 target</span></span><span class="detail-pill" title="Delivery Checks: all tiers to 10.0K + 25.0K/50.0K/100.0K"><span class="detail-label">Delivery Checks</span><span class="detail-value">all tiers to 10.0K + 25.0K/50.0K/100.0K</span></span></div></div></td><td class="num">1</td><td class="num" title="2839613µs exact">2.840s</td><td class="num" title="2839613µs exact">2.840s</td><td class="num" title="2839613µs exact">2.840s</td><td class="num" title="2839613µs exact">2.840s</td><td class="num" title="2839613µs exact">2.840s</td><td class="num" title="2839613µs exact">2.840s</td><td class="num ops">0</td><td class="num" title="2839613µs exact">2.840s</td><td><span class="verdict verdict-excellent">🟢 Excellent</span></td><td><span class="delta delta-same" title="previous mean: 2855095µs">~ 2855095µs prior</span></td></tr>
+  </tbody>
+  <tfoot><tr class="suite-total-row"><td colspan="12" class="suite-total-label">Whole Bench Totals</td><td class="num suite-total-value" title="237662760µs exact">237.663s</td><td colspan="2" class="suite-total-meta" title="271289952µs exact">Wall clock 271.290s</td></tr></tfoot>
+</table>
+</div>
+
+<div id="descriptionTooltip" class="hover-tooltip" hidden></div>
+
+<footer>
+  KalamDB v0.4.3-rc.4 &mdash; Generated 2026-05-05T14:50:41.736143+00:00
+</footer>
+
+</div>
+
+<script>
+Chart.defaults.color = '#8891a8';
+Chart.defaults.borderColor = '#2a3044';
+Chart.defaults.font.family = "'Inter', -apple-system, sans-serif";
+const COLORS = ['#6366f1','#22c55e','#f59e0b','#3b82f6','#ef4444','#a855f7','#ec4899','#06b6d4','#f97316','#84cc16','#64748b'];
+
+// Latency chart
+new Chart(document.getElementById('latencyChart'), {
+  type: 'bar',
+  data: {
+    labels: ["create_table","drop_table","single_insert","bulk_insert","transaction_multi_insert","select_all","select_by_filter","select_count","select_order_by_limit","single_update","single_delete","concurrent_insert","concurrent_select","point_lookup","aggregate_query","multi_table_join","large_payload_insert","wide_column_insert","bulk_delete","sequential_crud","alter_table","concurrent_update","concurrent_mixed_dml","namespace_isolation","subscribe_initial_load","subscribe_change_latency","reconnect_subscribe","flushed_parquet_query","concurrent_subscribers","concurrent_publishers","concurrent_consumers","sql_1k_concurrent","create_user","drop_user","connection_storm","mixed_read_write","wide_fanout_query","subscriber_scale"],
+    datasets: [
+      { label: 'Mean', data: [402.2,4726.7,270.5,985.6,3160.6,796.0,405.4,628.5,809.4,907.1,1323.2,1370.9,1200.4,392.4,28345.7,3143.1,1656.7,919.5,69050.3,2279.7,1231.5,3240.2,3267.8,1816.5,6405.9,51884.9,10051.4,153248.6,1554847.6,1464.7,614.5,152294.3,1237.2,278.2,275405.7,2216.5,5952.1,2839613.0], backgroundColor: '#6366f1cc', borderRadius: 3 },
+      { label: 'P95',  data: [508.1,5809.6,319.2,1159.7,3602.2,889.3,497.1,728.0,946.9,1093.8,1529.8,1684.3,1389.2,452.1,29822.1,3453.6,1884.1,1082.1,75547.3,2719.3,1586.5,4293.6,4069.4,2123.6,6727.3,60177.2,11058.2,246566.3,1576873.6,1807.1,688.0,158048.2,1392.2,368.4,284980.6,2831.1,6479.1,2839613.0],  backgroundColor: '#f59e0bcc', borderRadius: 3 },
+      { label: 'P99',  data: [589.1,5889.1,416.4,1195.3,3978.2,1034.1,558.0,749.6,1118.4,1248.7,1631.5,1911.8,1433.4,514.2,31097.0,3720.1,2050.9,1238.2,76753.4,3235.1,2324.3,5139.4,4385.7,2228.8,7116.0,75003.4,11180.8,255056.9,1579660.2,1896.8,714.2,161511.5,1514.3,431.1,300631.2,3745.4,7131.7,2839613.0],  backgroundColor: '#ef4444cc', borderRadius: 3 },
+    ]
+  },
+  options: {
+    responsive: true,
+    plugins: { legend: { position: 'top' } },
+    scales: {
+      y: { beginAtZero: true, title: { display: true, text: 'Latency (µs)' }, grid: { color: '#1c2130' } },
+      x: { ticks: { maxRotation: 45 }, grid: { color: '#1c2130' } }
+    }
+  }
+});
+
+// Throughput chart
+new Chart(document.getElementById('throughputChart'), {
+  type: 'bar',
+  data: {
+    labels: ["create_table","drop_table","single_insert","bulk_insert","transaction_multi_insert","select_all","select_by_filter","select_count","select_order_by_limit","single_update","single_delete","concurrent_insert","concurrent_select","point_lookup","aggregate_query","multi_table_join","large_payload_insert","wide_column_insert","bulk_delete","sequential_crud","alter_table","concurrent_update","concurrent_mixed_dml","namespace_isolation","subscribe_initial_load","subscribe_change_latency","reconnect_subscribe","flushed_parquet_query","concurrent_subscribers","concurrent_publishers","concurrent_consumers","sql_1k_concurrent","create_user","drop_user","connection_storm","mixed_read_write","wide_fanout_query","subscriber_scale"],
+    datasets: [{ label: 'Ops/sec', data: [2486.1,211.6,3696.9,1014.6,316.4,1256.2,2466.9,1591.2,1235.5,1102.4,755.7,729.4,833.0,2548.5,35.3,318.2,603.6,1087.6,14.5,438.7,812.0,308.6,306.0,550.5,156.1,19.3,99.5,6.5,0.6,682.7,1627.4,6.6,808.3,3595.1,3.6,451.2,168.0,0.4], backgroundColor: COLORS, borderRadius: 3 }]
+  },
+  options: {
+    indexAxis: 'y',
+    responsive: true,
+    plugins: { legend: { display: false } },
+    scales: {
+      x: { beginAtZero: true, title: { display: true, text: 'Operations / second' }, grid: { color: '#1c2130' } },
+      y: { grid: { display: false } }
+    }
+  }
+});
+
+// Category chart
+new Chart(document.getElementById('categoryChart'), {
+  type: 'doughnut',
+  data: {
+    labels: ["DDL","Insert","Select","Update","Delete","Concurrent","DML","Subscribe","Storage","Load","Scale"],
+    datasets: [{ data: [2120.2,1398.6,4931.5,907.1,35186.8,2179.2,2279.7,22780.7,153248.6,221590.1,2839613.0], backgroundColor: COLORS, borderWidth: 0 }]
+  },
+  options: {
+    responsive: true,
+    cutout: '55%',
+    plugins: {
+      legend: { position: 'right' },
+      tooltip: { callbacks: { label: (ctx) => ctx.label + ': ' + ctx.parsed.toFixed(0) + ' µs avg' } }
+    }
+  }
+});
+
+const descriptionTooltip = document.getElementById('descriptionTooltip');
+const descriptionTriggers = document.querySelectorAll('.desc-summary[data-full-description]');
+
+function positionDescriptionTooltip(left, top) {
+  if (!descriptionTooltip || descriptionTooltip.hidden) {
+    return;
+  }
+
+  const margin = 16;
+  const tooltipWidth = descriptionTooltip.offsetWidth;
+  const tooltipHeight = descriptionTooltip.offsetHeight;
+  let nextLeft = left;
+  let nextTop = top;
+
+  if (nextLeft + tooltipWidth > window.innerWidth - margin) {
+    nextLeft = window.innerWidth - tooltipWidth - margin;
+  }
+
+  if (nextTop + tooltipHeight > window.innerHeight - margin) {
+    nextTop = top - tooltipHeight - 18;
+  }
+
+  if (nextLeft < margin) {
+    nextLeft = margin;
+  }
+
+  if (nextTop < margin) {
+    nextTop = margin;
+  }
+
+  descriptionTooltip.style.left = `${nextLeft}px`;
+  descriptionTooltip.style.top = `${nextTop}px`;
+}
+
+function showDescriptionTooltip(trigger, left, top) {
+  if (!descriptionTooltip) {
+    return;
+  }
+
+  const text = trigger.dataset.fullDescription;
+  if (!text) {
+    return;
+  }
+
+  descriptionTooltip.textContent = text;
+  descriptionTooltip.hidden = false;
+  descriptionTooltip.classList.add('is-visible');
+  positionDescriptionTooltip(left, top);
+}
+
+function hideDescriptionTooltip() {
+  if (!descriptionTooltip) {
+    return;
+  }
+
+  descriptionTooltip.classList.remove('is-visible');
+  descriptionTooltip.hidden = true;
+}
+
+descriptionTriggers.forEach((trigger) => {
+  trigger.addEventListener('mouseenter', (event) => {
+    showDescriptionTooltip(trigger, event.clientX + 14, event.clientY + 18);
+  });
+
+  trigger.addEventListener('mousemove', (event) => {
+    positionDescriptionTooltip(event.clientX + 14, event.clientY + 18);
+  });
+
+  trigger.addEventListener('mouseleave', hideDescriptionTooltip);
+
+  trigger.addEventListener('focus', () => {
+    const rect = trigger.getBoundingClientRect();
+    showDescriptionTooltip(trigger, rect.left, rect.bottom + 12);
+  });
+
+  trigger.addEventListener('blur', hideDescriptionTooltip);
+});
+
+window.addEventListener('scroll', hideDescriptionTooltip, true);
+window.addEventListener('resize', hideDescriptionTooltip);
+</script>
+</body>
+</html>
diff --git a/benchv2/results/bench-2026-05-05-145041-0-4-3-rc-4.json b/benchv2/results/bench-2026-05-05-145041-0-4-3-rc-4.json
new file mode 100644
index 00000000..bfe75e7a
--- /dev/null
+++ b/benchv2/results/bench-2026-05-05-145041-0-4-3-rc-4.json
@@ -0,0 +1,842 @@
+{
+  "version": "0.4.3-rc.4",
+  "server_url": "http://127.0.0.1:8080",
+  "timestamp": "2026-05-05T14:50:41.735687+00:00",
+  "config": {
+    "iterations": 100,
+    "warmup": 5,
+    "concurrency": 10,
+    "namespace": "bench_144609",
+    "max_subscribers": 100000
+  },
+  "system": {
+    "hostname": "Jamals-MacBook-Pro.local",
+    "machine_model": "MacBookPro18,3",
+    "os_name": "Darwin",
+    "os_version": "macOS 26.5",
+    "kernel_version": "25.5.0",
+    "architecture": "aarch64",
+    "cpu_model": "Apple M1 Pro",
+    "cpu_logical_cores": 10,
+    "cpu_physical_cores": 10,
+    "total_memory_bytes": 17179869184,
+    "available_memory_bytes": 11530731520,
+    "used_memory_bytes": 5649137664,
+    "used_memory_percent": 32.88230895996094
+  },
+  "results": [
+    {
+      "name": "create_table",
+      "category": "DDL",
+      "description": "CREATE TABLE with 3 columns",
+      "full_description": "CREATE TABLE with 3 columns",
+      "details": [],
+      "iterations": 100,
+      "total_us": 40224,
+      "mean_us": 402.24,
+      "median_us": 384.0,
+      "p95_us": 508.05,
+      "p99_us": 589.14,
+      "min_us": 351.0,
+      "max_us": 603.0,
+      "stddev_us": 50.16057448159094,
+      "ops_per_sec": 2486.0779634049322,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "drop_table",
+      "category": "DDL",
+      "description": "DROP TABLE on a previously created table",
+      "full_description": "DROP TABLE on a previously created table",
+      "details": [],
+      "iterations": 100,
+      "total_us": 472671,
+      "mean_us": 4726.71,
+      "median_us": 4742.5,
+      "p95_us": 5809.55,
+      "p99_us": 5889.140000000004,
+      "min_us": 3344.0,
+      "max_us": 6695.0,
+      "stddev_us": 720.1989525208442,
+      "ops_per_sec": 211.56364574936902,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "single_insert",
+      "category": "Insert",
+      "description": "INSERT a single row into a table",
+      "full_description": "INSERT a single row into a table",
+      "details": [],
+      "iterations": 100,
+      "total_us": 27050,
+      "mean_us": 270.5,
+      "median_us": 269.0,
+      "p95_us": 319.2,
+      "p99_us": 416.3500000000002,
+      "min_us": 211.0,
+      "max_us": 451.0,
+      "stddev_us": 35.43510215374671,
+      "ops_per_sec": 3696.857670979667,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "bulk_insert",
+      "category": "Insert",
+      "description": "One INSERT statement with 50 rows (statement-scoped transaction)",
+      "full_description": "One INSERT statement with 50 rows (statement-scoped transaction)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 98563,
+      "mean_us": 985.63,
+      "median_us": 966.5,
+      "p95_us": 1159.65,
+      "p99_us": 1195.3200000000006,
+      "min_us": 827.0,
+      "max_us": 1326.0,
+      "stddev_us": 95.90469332634459,
+      "ops_per_sec": 1014.579507523107,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "transaction_multi_insert",
+      "category": "Insert",
+      "description": "Explicit BEGIN/COMMIT with 50 single-row INSERT statements",
+      "full_description": "Explicit BEGIN/COMMIT with 50 single-row INSERT statements",
+      "details": [],
+      "iterations": 100,
+      "total_us": 316058,
+      "mean_us": 3160.58,
+      "median_us": 3131.0,
+      "p95_us": 3602.2,
+      "p99_us": 3978.19,
+      "min_us": 2822.0,
+      "max_us": 3997.0,
+      "stddev_us": 232.96035905039486,
+      "ops_per_sec": 316.39762322105435,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "select_all",
+      "category": "Select",
+      "description": "SELECT * from a 200-row table",
+      "full_description": "SELECT * from a 200-row table",
+      "details": [],
+      "iterations": 100,
+      "total_us": 79602,
+      "mean_us": 796.02,
+      "median_us": 774.0,
+      "p95_us": 889.3000000000001,
+      "p99_us": 1034.06,
+      "min_us": 753.0,
+      "max_us": 1040.0,
+      "stddev_us": 55.84610527823292,
+      "ops_per_sec": 1256.2498429687696,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "select_by_filter",
+      "category": "Select",
+      "description": "SELECT with WHERE clause on a 200-row table",
+      "full_description": "SELECT with WHERE clause on a 200-row table",
+      "details": [],
+      "iterations": 100,
+      "total_us": 40536,
+      "mean_us": 405.36,
+      "median_us": 399.5,
+      "p95_us": 497.15,
+      "p99_us": 558.05,
+      "min_us": 321.0,
+      "max_us": 563.0,
+      "stddev_us": 45.44827673945249,
+      "ops_per_sec": 2466.942964278666,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "select_count",
+      "category": "Select",
+      "description": "SELECT COUNT(*) on a 200-row table",
+      "full_description": "SELECT COUNT(*) on a 200-row table",
+      "details": [],
+      "iterations": 100,
+      "total_us": 62847,
+      "mean_us": 628.47,
+      "median_us": 615.5,
+      "p95_us": 728.05,
+      "p99_us": 749.6400000000003,
+      "min_us": 580.0,
+      "max_us": 813.0,
+      "stddev_us": 42.818021080999635,
+      "ops_per_sec": 1591.1658472162553,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "select_order_by_limit",
+      "category": "Select",
+      "description": "SELECT with ORDER BY + LIMIT 10 on a 200-row table",
+      "full_description": "SELECT with ORDER BY + LIMIT 10 on a 200-row table",
+      "details": [],
+      "iterations": 100,
+      "total_us": 80940,
+      "mean_us": 809.4,
+      "median_us": 794.5,
+      "p95_us": 946.8999999999999,
+      "p99_us": 1118.3500000000001,
+      "min_us": 761.0,
+      "max_us": 1153.0,
+      "stddev_us": 65.57623368448682,
+      "ops_per_sec": 1235.4830738818878,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "single_update",
+      "category": "Update",
+      "description": "UPDATE a single row by filter condition",
+      "full_description": "UPDATE a single row by filter condition",
+      "details": [],
+      "iterations": 100,
+      "total_us": 90708,
+      "mean_us": 907.08,
+      "median_us": 889.0,
+      "p95_us": 1093.7999999999997,
+      "p99_us": 1248.7200000000003,
+      "min_us": 818.0,
+      "max_us": 1320.0,
+      "stddev_us": 92.11100900434204,
+      "ops_per_sec": 1102.4385941703047,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "single_delete",
+      "category": "Delete",
+      "description": "DELETE a single row by filter condition",
+      "full_description": "DELETE a single row by filter condition",
+      "details": [],
+      "iterations": 100,
+      "total_us": 132325,
+      "mean_us": 1323.25,
+      "median_us": 1300.0,
+      "p95_us": 1529.8,
+      "p99_us": 1631.5000000000002,
+      "min_us": 1208.0,
+      "max_us": 1681.0,
+      "stddev_us": 99.69381154618405,
+      "ops_per_sec": 755.7150954090308,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_insert",
+      "category": "Concurrent",
+      "description": "N concurrent INSERT operations in parallel (N = concurrency setting)",
+      "full_description": "N concurrent INSERT operations in parallel (N = concurrency setting)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 137091,
+      "mean_us": 1370.91,
+      "median_us": 1285.0,
+      "p95_us": 1684.3,
+      "p99_us": 1911.7800000000152,
+      "min_us": 1134.0,
+      "max_us": 4860.0,
+      "stddev_us": 383.49914977583444,
+      "ops_per_sec": 729.4424871071041,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_select",
+      "category": "Concurrent",
+      "description": "N concurrent SELECT operations in parallel (N = concurrency setting)",
+      "full_description": "N concurrent SELECT operations in parallel (N = concurrency setting)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 120044,
+      "mean_us": 1200.44,
+      "median_us": 1210.0,
+      "p95_us": 1389.2,
+      "p99_us": 1433.41,
+      "min_us": 885.0,
+      "max_us": 1474.0,
+      "stddev_us": 112.78757364034732,
+      "ops_per_sec": 833.0278897737496,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "point_lookup",
+      "category": "Select",
+      "description": "SELECT by primary key from a 10K-row table (single row lookup)",
+      "full_description": "SELECT by primary key from a 10K-row table (single row lookup)",
+      "details": [
+        {
+          "label": "Baseline",
+          "value": "phase-0 performance"
+        },
+        {
+          "label": "Query Class",
+          "value": "primary-key lookup"
+        },
+        {
+          "label": "Dataset",
+          "value": "10000 seeded rows"
+        },
+        {
+          "label": "Query Shape",
+          "value": "SELECT * FROM <ns>.point_lookup WHERE id = ?"
+        }
+      ],
+      "iterations": 100,
+      "total_us": 39239,
+      "mean_us": 392.39,
+      "median_us": 393.5,
+      "p95_us": 452.15,
+      "p99_us": 514.2200000000001,
+      "min_us": 322.0,
+      "max_us": 536.0,
+      "stddev_us": 39.03246382593895,
+      "ops_per_sec": 2548.4849257116643,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "aggregate_query",
+      "category": "Select",
+      "description": "GROUP BY + SUM/AVG/COUNT on a 10K-row table (analytical query performance)",
+      "full_description": "GROUP BY + SUM/AVG/COUNT on a 10K-row table (analytical query performance)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 2834569,
+      "mean_us": 28345.69,
+      "median_us": 28173.0,
+      "p95_us": 29822.149999999998,
+      "p99_us": 31096.97,
+      "min_us": 26976.0,
+      "max_us": 31688.0,
+      "stddev_us": 861.7272611599698,
+      "ops_per_sec": 35.27873196948107,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "multi_table_join",
+      "category": "Select",
+      "description": "SELECT with subquery across two tables (200 customers, 1000 orders)",
+      "full_description": "SELECT with subquery across two tables (200 customers, 1000 orders)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 314311,
+      "mean_us": 3143.11,
+      "median_us": 3097.5,
+      "p95_us": 3453.5999999999995,
+      "p99_us": 3720.1100000000006,
+      "min_us": 3006.0,
+      "max_us": 3830.0,
+      "stddev_us": 153.6981756297686,
+      "ops_per_sec": 318.15622106766864,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "large_payload_insert",
+      "category": "Insert",
+      "description": "INSERT rows with ~4KB TEXT payloads (serialization + storage throughput)",
+      "full_description": "INSERT rows with ~4KB TEXT payloads (serialization + storage throughput)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 165667,
+      "mean_us": 1656.67,
+      "median_us": 1645.5,
+      "p95_us": 1884.1000000000001,
+      "p99_us": 2050.9200000000005,
+      "min_us": 1461.0,
+      "max_us": 2142.0,
+      "stddev_us": 124.09470601361713,
+      "ops_per_sec": 603.6205158540928,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "wide_column_insert",
+      "category": "Insert",
+      "description": "INSERT into a 20-column table (wide schema overhead)",
+      "full_description": "INSERT into a 20-column table (wide schema overhead)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 91947,
+      "mean_us": 919.47,
+      "median_us": 890.5,
+      "p95_us": 1082.1499999999999,
+      "p99_us": 1238.2200000000003,
+      "min_us": 818.0,
+      "max_us": 1260.0,
+      "stddev_us": 86.98060331783951,
+      "ops_per_sec": 1087.5830641565249,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "bulk_delete",
+      "category": "Delete",
+      "description": "DELETE 100 rows at once with a range filter (bulk deletion)",
+      "full_description": "DELETE 100 rows at once with a range filter (bulk deletion)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 6905026,
+      "mean_us": 69050.26,
+      "median_us": 69288.5,
+      "p95_us": 75547.3,
+      "p99_us": 76753.42000000001,
+      "min_us": 61249.0,
+      "max_us": 80458.0,
+      "stddev_us": 4743.810426867899,
+      "ops_per_sec": 14.482204701329147,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "sequential_crud",
+      "category": "DML",
+      "description": "INSERT → UPDATE → SELECT → DELETE full DML lifecycle per iteration",
+      "full_description": "INSERT → UPDATE → SELECT → DELETE full DML lifecycle per iteration",
+      "details": [],
+      "iterations": 100,
+      "total_us": 227969,
+      "mean_us": 2279.69,
+      "median_us": 2207.5,
+      "p95_us": 2719.35,
+      "p99_us": 3235.1200000000363,
+      "min_us": 1573.0,
+      "max_us": 10276.0,
+      "stddev_us": 863.477520368549,
+      "ops_per_sec": 438.65613307072454,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "alter_table",
+      "category": "DDL",
+      "description": "ALTER TABLE ADD COLUMN + DROP COLUMN (schema evolution latency)",
+      "full_description": "ALTER TABLE ADD COLUMN + DROP COLUMN (schema evolution latency)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 123153,
+      "mean_us": 1231.53,
+      "median_us": 1138.0,
+      "p95_us": 1586.5499999999997,
+      "p99_us": 2324.290000000001,
+      "min_us": 1068.0,
+      "max_us": 2452.0,
+      "stddev_us": 239.5923075526087,
+      "ops_per_sec": 811.9980836845225,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_update",
+      "category": "Concurrent",
+      "description": "N concurrent UPDATE operations on the same table (write contention test)",
+      "full_description": "N concurrent UPDATE operations on the same table (write contention test)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 324019,
+      "mean_us": 3240.19,
+      "median_us": 3211.5,
+      "p95_us": 4293.599999999999,
+      "p99_us": 5139.360000000002,
+      "min_us": 2120.0,
+      "max_us": 5472.0,
+      "stddev_us": 707.1247613977451,
+      "ops_per_sec": 308.6238769948676,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_mixed_dml",
+      "category": "Concurrent",
+      "description": "Concurrent INSERT + UPDATE + DELETE on the same table (multi-op contention)",
+      "full_description": "Concurrent INSERT + UPDATE + DELETE on the same table (multi-op contention)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 326783,
+      "mean_us": 3267.83,
+      "median_us": 3258.0,
+      "p95_us": 4069.45,
+      "p99_us": 4385.660000000001,
+      "min_us": 2309.0,
+      "max_us": 4649.0,
+      "stddev_us": 527.4424101839044,
+      "ops_per_sec": 306.0134707129808,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "namespace_isolation",
+      "category": "Concurrent",
+      "description": "Concurrent queries across 5 different namespaces (isolation test)",
+      "full_description": "Concurrent queries across 5 different namespaces (isolation test)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 181652,
+      "mean_us": 1816.52,
+      "median_us": 1807.5,
+      "p95_us": 2123.6,
+      "p99_us": 2228.840000000001,
+      "min_us": 1512.0,
+      "max_us": 2411.0,
+      "stddev_us": 163.07465477597376,
+      "ops_per_sec": 550.5031598881377,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "subscribe_initial_load",
+      "category": "Subscribe",
+      "description": "Subscribe to a 1000-row user table and receive the full initial data batch",
+      "full_description": "Subscribe to a 1000-row user table and receive the full initial data batch",
+      "details": [],
+      "iterations": 100,
+      "total_us": 640588,
+      "mean_us": 6405.88,
+      "median_us": 6327.5,
+      "p95_us": 6727.349999999999,
+      "p99_us": 7116.040000000002,
+      "min_us": 6252.0,
+      "max_us": 7516.0,
+      "stddev_us": 188.35643623382524,
+      "ops_per_sec": 156.10657708230562,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "subscribe_change_latency",
+      "category": "Subscribe",
+      "description": "Latency from INSERT to subscriber receiving the change notification",
+      "full_description": "Latency from INSERT to subscriber receiving the change notification",
+      "details": [],
+      "iterations": 100,
+      "total_us": 5188492,
+      "mean_us": 51884.92,
+      "median_us": 50602.0,
+      "p95_us": 60177.2,
+      "p99_us": 75003.40000000001,
+      "min_us": 46229.0,
+      "max_us": 76132.0,
+      "stddev_us": 5134.65751846403,
+      "ops_per_sec": 19.273422797992172,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "reconnect_subscribe",
+      "category": "Subscribe",
+      "description": "Disconnect and re-subscribe to a user table (reconnection overhead)",
+      "full_description": "Disconnect and re-subscribe to a user table (reconnection overhead)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 1005135,
+      "mean_us": 10051.35,
+      "median_us": 10250.5,
+      "p95_us": 11058.25,
+      "p99_us": 11180.75,
+      "min_us": 8819.0,
+      "max_us": 11354.0,
+      "stddev_us": 673.4560100516939,
+      "ops_per_sec": 99.4891233515896,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "flushed_parquet_query",
+      "category": "Storage",
+      "description": "SELECT from a shared table with 20 flushed Parquet files (200K rows)",
+      "full_description": "SELECT from a shared table with 20 flushed Parquet files (200K rows)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 15324861,
+      "mean_us": 153248.61,
+      "median_us": 184603.5,
+      "p95_us": 246566.30000000002,
+      "p99_us": 255056.86000000002,
+      "min_us": 24227.0,
+      "max_us": 257815.0,
+      "stddev_us": 89556.73054504095,
+      "ops_per_sec": 6.525344667073979,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_subscribers",
+      "category": "Load",
+      "description": "N WebSocket live-query subscribers receiving changes from concurrent writes",
+      "full_description": "N WebSocket live-query subscribers receiving changes from concurrent writes",
+      "details": [],
+      "iterations": 100,
+      "total_us": 155484760,
+      "mean_us": 1554847.6,
+      "median_us": 1555271.5,
+      "p95_us": 1576873.55,
+      "p99_us": 1579660.1800000004,
+      "min_us": 1523989.0,
+      "max_us": 1621753.0,
+      "stddev_us": 18147.870440780473,
+      "ops_per_sec": 0.6431498495415242,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_publishers",
+      "category": "Load",
+      "description": "N concurrent INSERTs into a topic-sourced table (measures publish overhead)",
+      "full_description": "N concurrent INSERTs into a topic-sourced table (measures publish overhead)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 146474,
+      "mean_us": 1464.74,
+      "median_us": 1411.5,
+      "p95_us": 1807.1,
+      "p99_us": 1896.750000000001,
+      "min_us": 1260.0,
+      "max_us": 2070.0,
+      "stddev_us": 161.13841343028136,
+      "ops_per_sec": 682.7150210958941,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "concurrent_consumers",
+      "category": "Load",
+      "description": "N concurrent topic CONSUME calls pulling messages in parallel",
+      "full_description": "N concurrent topic CONSUME calls pulling messages in parallel",
+      "details": [],
+      "iterations": 100,
+      "total_us": 61448,
+      "mean_us": 614.48,
+      "median_us": 609.5,
+      "p95_us": 688.05,
+      "p99_us": 714.2000000000002,
+      "min_us": 530.0,
+      "max_us": 734.0,
+      "stddev_us": 44.06617613076813,
+      "ops_per_sec": 1627.3922666319488,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "sql_1k_concurrent",
+      "category": "Load",
+      "description": "1000 concurrent SQL SELECT queries at once (RPS degradation test)",
+      "full_description": "1000 concurrent SQL SELECT queries at once (RPS degradation test)",
+      "details": [
+        {
+          "label": "Baseline",
+          "value": "phase-0 performance"
+        },
+        {
+          "label": "Query Class",
+          "value": "concurrent read burst"
+        },
+        {
+          "label": "Dataset",
+          "value": "500 seeded rows"
+        },
+        {
+          "label": "Burst",
+          "value": "1000 concurrent SQL queries"
+        },
+        {
+          "label": "Query Mix",
+          "value": "pk lookup, count, selective order-by limit, narrow projection"
+        }
+      ],
+      "iterations": 100,
+      "total_us": 15229428,
+      "mean_us": 152294.28,
+      "median_us": 151536.5,
+      "p95_us": 158048.25,
+      "p99_us": 161511.46000000005,
+      "min_us": 145510.0,
+      "max_us": 173239.0,
+      "stddev_us": 3578.683977626017,
+      "ops_per_sec": 6.566234792271909,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "create_user",
+      "category": "Load",
+      "description": "CREATE USER (auth subsystem stress test)",
+      "full_description": "CREATE USER (auth subsystem stress test)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 123715,
+      "mean_us": 1237.15,
+      "median_us": 1212.5,
+      "p95_us": 1392.15,
+      "p99_us": 1514.3200000000002,
+      "min_us": 1161.0,
+      "max_us": 1546.0,
+      "stddev_us": 76.0145354255329,
+      "ops_per_sec": 808.3094208462999,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "drop_user",
+      "category": "Load",
+      "description": "DROP USER (auth subsystem teardown stress test)",
+      "full_description": "DROP USER (auth subsystem teardown stress test)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 27816,
+      "mean_us": 278.16,
+      "median_us": 252.0,
+      "p95_us": 368.4,
+      "p99_us": 431.14000000000055,
+      "min_us": 230.0,
+      "max_us": 544.0,
+      "stddev_us": 53.786281154250105,
+      "ops_per_sec": 3595.0532067874606,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "connection_storm",
+      "category": "Load",
+      "description": "N simultaneous login + SQL + cycles (connection setup overhead)",
+      "full_description": "N simultaneous login + SQL + cycles (connection setup overhead)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 27540574,
+      "mean_us": 275405.74,
+      "median_us": 274268.5,
+      "p95_us": 284980.55000000005,
+      "p99_us": 300631.19000000006,
+      "min_us": 265960.0,
+      "max_us": 317678.0,
+      "stddev_us": 7786.12463558143,
+      "ops_per_sec": 3.6310063835270827,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "mixed_read_write",
+      "category": "Load",
+      "description": "50/50 concurrent reads + writes on same table (contention test)",
+      "full_description": "50/50 concurrent reads + writes on same table (contention test)",
+      "details": [
+        {
+          "label": "Baseline",
+          "value": "phase-0 performance"
+        },
+        {
+          "label": "Query Class",
+          "value": "mixed concurrent read/write"
+        },
+        {
+          "label": "Dataset",
+          "value": "200 seeded rows"
+        },
+        {
+          "label": "Mix",
+          "value": "5 reads / 5 writes"
+        },
+        {
+          "label": "Read Shapes",
+          "value": "range filter, count-star, order-by desc limit"
+        }
+      ],
+      "iterations": 100,
+      "total_us": 221651,
+      "mean_us": 2216.51,
+      "median_us": 2201.5,
+      "p95_us": 2831.1,
+      "p99_us": 3745.4200000000105,
+      "min_us": 1452.0,
+      "max_us": 5767.0,
+      "stddev_us": 517.9256702452485,
+      "ops_per_sec": 451.1597060243356,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "wide_fanout_query",
+      "category": "Load",
+      "description": "N concurrent large-result-set SELECTs (serialization + memory pressure)",
+      "full_description": "N concurrent large-result-set SELECTs (serialization + memory pressure)",
+      "details": [],
+      "iterations": 100,
+      "total_us": 595211,
+      "mean_us": 5952.11,
+      "median_us": 5921.5,
+      "p95_us": 6479.15,
+      "p99_us": 7131.680000000004,
+      "min_us": 5334.0,
+      "max_us": 7892.0,
+      "stddev_us": 365.1158912460591,
+      "ops_per_sec": 168.00764770812367,
+      "success": true,
+      "error": null
+    },
+    {
+      "name": "subscriber_scale",
+      "category": "Scale",
+      "description": "Progressive live-query subscriber scale and insert fanout verification up to 100.0K",
+      "full_description": "Progressively ramps cumulative live-query subscribers across tiers 10 -> 100 -> 500 -> 1.0K -> 2.0K -> 5.0K -> 10.0K -> 25.0K -> 50.0K -> 100.0K to verify connection establishment, subscription completion, and INSERT fanout delivery. Delivery probes run at 10 -> 100 -> 500 -> 1.0K -> 2.0K -> 5.0K -> 10.0K -> 25.0K -> 50.0K -> 100.0K. This run is configured with connect_batch=1.0K, wave_size=500, wave_pause=0ms, connect_timeout=30.0s, 1 shared WebSocket target, 100 subscriptions per shared WebSocket connection, and a pooled shared-connection budget of 1.0K.",
+      "details": [
+        {
+          "label": "Max",
+          "value": "100.0K"
+        },
+        {
+          "label": "Tiers",
+          "value": "10 checkpoints to 100.0K"
+        },
+        {
+          "label": "Batch/Wave",
+          "value": "1.0K / 500"
+        },
+        {
+          "label": "Pause/Timeout",
+          "value": "0ms / 30.0s"
+        },
+        {
+          "label": "Shared WS",
+          "value": "1.0K conns @ 100 subs/ws across 1 target"
+        },
+        {
+          "label": "Delivery Checks",
+          "value": "all tiers to 10.0K + 25.0K/50.0K/100.0K"
+        }
+      ],
+      "iterations": 1,
+      "total_us": 2839613,
+      "mean_us": 2839613.0,
+      "median_us": 2839613.0,
+      "p95_us": 2839613.0,
+      "p99_us": 2839613.0,
+      "min_us": 2839613.0,
+      "max_us": 2839613.0,
+      "stddev_us": 0.0,
+      "ops_per_sec": 0.3521606641468397,
+      "success": true,
+      "error": null
+    }
+  ],
+  "summary": {
+    "total_benchmarks": 38,
+    "passed": 38,
+    "failed": 0,
+    "total_duration_ms": 271289.95200000005,
+    "measured_duration_ms": 237662.76
+  }
+}
\ No newline at end of file
diff --git a/cli/README.md b/cli/README.md
index 1b97eed4..3d6d4c56 100644
--- a/cli/README.md
+++ b/cli/README.md
@@ -139,7 +139,6 @@ EXECUTION:
     -f, --file <FILE>               Execute SQL from file and exit
     -c, --command <SQL>             Execute SQL command and exit
     --subscribe <SQL>               Subscribe to a table or live query
-    --unsubscribe <ID>              Unsubscribe from a subscription (non-interactive)
     --list-subscriptions            List active subscriptions (non-interactive)
 
 OUTPUT:
@@ -206,13 +205,12 @@ Special commands starting with backslash (`\`):
 | `\format <table\|json\|csv>` | Set output format |
 | `\dt` / `\tables` | List tables |
 | `\d <table>` / `\describe <table>` | Describe a table (`<table>` or `<namespace.table>`) |
-| `\as <user> <SQL>` | Wrap one statement as `EXECUTE AS USER` |
+| `\as <user_id> <SQL>` | Wrap one statement as `EXECUTE AS '<user_id>'` |
 | `\stats` / `\metrics` | Show system stats |
 | `\health` | Check server health |
 | `\flush` | Execute STORAGE FLUSH ALL |
 | `\refresh-tables` / `\refresh` | Refresh autocomplete cache |
-| `\subscribe <SQL>` / `\watch <SQL>` / `\live <SQL>` | Start live query |
-| `\unsubscribe` / `\unwatch` | Cancel live query |
+| `\live <SQL>` / `\subscribe <SQL>` | Start live query (`\subscribe` is an alias) |
 | `\show-credentials` / `\credentials` | Show stored credentials |
 | `\update-credentials <u> <p>` | Update stored credentials |
 | `\delete-credentials` | Delete stored credentials |
@@ -226,7 +224,9 @@ Tips:
 - Use **Tab** for auto-completion of SQL keywords, namespaces, tables, and columns.
 - Use **↑/↓** to navigate command history.
 - Use `\format json` or `\format csv` to switch output formats.
-- Use `\subscribe <SQL>` for live updates.
+- Use `\live <SQL>` for live updates.
+- Run `BACKUP DATABASE TO '/tmp/kalamdb-backup.tar.gz';` as SQL for server-side backups.
+- Run `EXPORT USER DATA;` followed by `SHOW EXPORT;` to fetch your export download URL.
 
 ### Output Formats
 
diff --git a/cli/src/args.rs b/cli/src/args.rs
index be08cd4f..db9a9721 100644
--- a/cli/src/args.rs
+++ b/cli/src/args.rs
@@ -218,7 +218,6 @@ pub struct Cli {
             "list_instances",
             "subscribe",
             "list_subscriptions",
-            "unsubscribe",
             "consume"
         ]
     )]
@@ -249,10 +248,6 @@ pub struct Cli {
     )]
     pub watch_interval: Duration,
 
-    /// Unsubscribe from a subscription
-    #[arg(long = "unsubscribe")]
-    pub unsubscribe: Option<String>,
-
     /// List active subscriptions
     #[arg(long = "list-subscriptions")]
     pub list_subscriptions: bool,
@@ -285,8 +280,10 @@ pub struct Cli {
 
 #[cfg(test)]
 mod tests {
-    use super::parse_watch_interval;
-    use std::time::Duration;
+    use clap::Parser;
+
+    use super::{parse_watch_interval, Cli};
+    use std::{path::Path, time::Duration};
 
     #[test]
     fn parse_watch_interval_defaults_to_seconds() {
@@ -309,4 +306,39 @@ mod tests {
     fn parse_watch_interval_handles_default_five_seconds_literal() {
         assert_eq!(parse_watch_interval("5s").unwrap(), Duration::from_secs(5));
     }
+
+    #[test]
+    fn short_connection_and_execution_flags_parse() {
+        let cli = Cli::try_parse_from([
+            "kalam",
+            "-u",
+            "http://127.0.0.1:8080",
+            "-c",
+            "SELECT 1",
+            "-v",
+        ])
+        .expect("short flags should parse");
+
+        assert_eq!(cli.url.as_deref(), Some("http://127.0.0.1:8080"));
+        assert_eq!(cli.command.as_deref(), Some("SELECT 1"));
+        assert!(cli.verbose);
+    }
+
+    #[test]
+    fn short_host_port_and_file_flags_parse() {
+        let cli = Cli::try_parse_from([
+            "kalam",
+            "-H",
+            "127.0.0.1",
+            "-p",
+            "8080",
+            "-f",
+            "./queries.sql",
+        ])
+        .expect("short flags should parse");
+
+        assert_eq!(cli.host.as_deref(), Some("127.0.0.1"));
+        assert_eq!(cli.port, 8080);
+        assert_eq!(cli.file.as_deref(), Some(Path::new("./queries.sql")));
+    }
 }
diff --git a/cli/src/commands/subscriptions.rs b/cli/src/commands/subscriptions.rs
index b19ed906..e8730a75 100644
--- a/cli/src/commands/subscriptions.rs
+++ b/cli/src/commands/subscriptions.rs
@@ -12,16 +12,11 @@ fn print_list_subscriptions() {
     println!("  • No persistent subscription registry is currently implemented");
 }
 
-fn print_unsubscribe_message() {
-    println!("To unsubscribe from an active subscription, use Ctrl+C in the terminal");
-    println!("where the subscription is running, or kill the process.");
-}
-
 pub async fn handle_subscriptions(
     cli: &Cli,
     credential_store: &mut FileCredentialStore,
 ) -> Result<bool> {
-    if !(cli.list_subscriptions || cli.subscribe.is_some() || cli.unsubscribe.is_some()) {
+    if !(cli.list_subscriptions || cli.subscribe.is_some()) {
         return Ok(false);
     }
 
@@ -30,11 +25,6 @@ pub async fn handle_subscriptions(
         return Ok(true);
     }
 
-    if cli.unsubscribe.is_some() {
-        print_unsubscribe_message();
-        return Ok(true);
-    }
-
     // Only subscriptions require a server session.
     // Load configuration
     let config = CLIConfiguration::load(&cli.config)?;
diff --git a/cli/src/parser.rs b/cli/src/parser.rs
index 59ab8425..4ab505cc 100644
--- a/cli/src/parser.rs
+++ b/cli/src/parser.rs
@@ -6,6 +6,12 @@
 
 use crate::error::{CLIError, Result};
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum FlushTarget {
+    All,
+    Table(String),
+}
+
 /// Parsed command
 #[derive(Debug, Clone, PartialEq)]
 pub enum Command {
@@ -21,7 +27,7 @@ pub enum Command {
     /// Meta-commands (backslash commands)
     Quit,
     Help,
-    Flush,
+    Flush(FlushTarget),
     ClusterSnapshot,
     ClusterPurge {
         upto: u64,
@@ -45,7 +51,6 @@ pub enum Command {
     Describe(String),
     SetFormat(String),
     Subscribe(String),
-    Unsubscribe,
     RefreshTables,
     ShowCredentials,
     UpdateCredentials {
@@ -93,10 +98,7 @@ pub(crate) const META_COMMAND_COMPLETIONS: &[&str] = &[
     "\\refresh-tables",
     "\\refresh",
     "\\subscribe",
-    "\\watch",
     "\\live",
-    "\\unsubscribe",
-    "\\unwatch",
     "\\show-credentials",
     "\\credentials",
     "\\update-credentials",
@@ -150,7 +152,7 @@ impl CommandParser {
             "\\help" | "\\?" => Ok(Command::Help),
             "\\sessions" => Ok(Command::Sessions),
             "\\stats" | "\\metrics" => Ok(Command::Stats),
-            "\\flush" => Ok(Command::Flush),
+            "\\flush" => Self::parse_flush_command(args),
             "\\cluster" => {
                 if args.is_empty() {
                     Err(CLIError::ParseError(
@@ -279,7 +281,6 @@ impl CommandParser {
                     Ok(Command::Subscribe(args.join(" ")))
                 }
             },
-            "\\unsubscribe" | "\\unwatch" => Ok(Command::Unsubscribe),
             "\\refresh-tables" | "\\refresh" => Ok(Command::RefreshTables),
             "\\show-credentials" | "\\credentials" => Ok(Command::ShowCredentials),
             "\\update-credentials" => {
@@ -409,6 +410,27 @@ impl CommandParser {
             sql: sql.to_string(),
         })
     }
+
+    fn parse_flush_command(args: &[&str]) -> Result<Command> {
+        match args {
+            [] => Ok(Command::Flush(FlushTarget::All)),
+            [subcommand] if subcommand.eq_ignore_ascii_case("all") => {
+                Ok(Command::Flush(FlushTarget::All))
+            },
+            [subcommand, table @ ..] if subcommand.eq_ignore_ascii_case("table") => {
+                if table.is_empty() {
+                    Err(CLIError::ParseError(
+                        "\\flush table requires a table name".into(),
+                    ))
+                } else {
+                    Ok(Command::Flush(FlushTarget::Table(table.join(" "))))
+                }
+            },
+            _ => Err(CLIError::ParseError(
+                "\\flush supports: \\flush, \\flush all, or \\flush table <table>".into(),
+            )),
+        }
+    }
 }
 
 impl Default for CommandParser {
@@ -442,6 +464,24 @@ mod tests {
         assert_eq!(parser.parse("\\?").unwrap(), Command::Help);
     }
 
+    #[test]
+    fn test_parse_flush_shortcuts() {
+        let parser = CommandParser::new();
+
+        assert_eq!(parser.parse("\\flush").unwrap(), Command::Flush(FlushTarget::All));
+        assert_eq!(parser.parse("\\flush all").unwrap(), Command::Flush(FlushTarget::All));
+        assert_eq!(
+            parser.parse("\\flush table messages").unwrap(),
+            Command::Flush(FlushTarget::Table("messages".to_string()))
+        );
+    }
+
+    #[test]
+    fn test_parse_flush_table_requires_target() {
+        let parser = CommandParser::new();
+        assert!(parser.parse("\\flush table").is_err());
+    }
+
     #[test]
     fn test_parse_describe() {
         let parser = CommandParser::new();
@@ -523,6 +563,115 @@ mod tests {
         assert_eq!(parser.parse("\\cluster rebalance").unwrap(), Command::ClusterRebalance);
     }
 
+    #[test]
+    fn test_parse_meta_command_aliases() {
+        let parser = CommandParser::new();
+
+        assert_eq!(parser.parse("\\health").unwrap(), Command::Health);
+        assert_eq!(parser.parse("\\dt").unwrap(), Command::ListTables);
+        assert_eq!(parser.parse("\\tables").unwrap(), Command::ListTables);
+        assert_eq!(parser.parse("\\info").unwrap(), Command::Info);
+        assert_eq!(parser.parse("\\session").unwrap(), Command::Info);
+        assert_eq!(parser.parse("\\show-credentials").unwrap(), Command::ShowCredentials);
+        assert_eq!(parser.parse("\\credentials").unwrap(), Command::ShowCredentials);
+        assert_eq!(parser.parse("\\delete-credentials").unwrap(), Command::DeleteCredentials);
+        assert_eq!(parser.parse("\\refresh-tables").unwrap(), Command::RefreshTables);
+        assert_eq!(parser.parse("\\refresh").unwrap(), Command::RefreshTables);
+    }
+
+    #[test]
+    fn test_parse_format_subscribe_and_credential_update_commands() {
+        let parser = CommandParser::new();
+
+        assert_eq!(
+            parser.parse("\\format json").unwrap(),
+            Command::SetFormat("json".to_string())
+        );
+        assert_eq!(
+            parser.parse("\\subscribe SELECT * FROM app.messages").unwrap(),
+            Command::Subscribe("SELECT * FROM app.messages".to_string())
+        );
+        assert_eq!(
+            parser.parse("\\watch SELECT * FROM app.messages").unwrap(),
+            Command::Subscribe("SELECT * FROM app.messages".to_string())
+        );
+        assert_eq!(
+            parser.parse("\\update-credentials admin kalamdb123").unwrap(),
+            Command::UpdateCredentials {
+                username: "admin".to_string(),
+                password: "kalamdb123".to_string(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_parse_consume_command_with_all_options() {
+        let parser = CommandParser::new();
+
+        assert_eq!(
+            parser
+                .parse("\\consume app.events --group workers --from earliest --limit 5 --timeout 12")
+                .unwrap(),
+            Command::Consume {
+                topic: "app.events".to_string(),
+                group: Some("workers".to_string()),
+                from: Some("earliest".to_string()),
+                limit: Some(5),
+                timeout: Some(12),
+            }
+        );
+    }
+
+    #[test]
+    fn test_parse_consume_command_rejects_invalid_arguments() {
+        let parser = CommandParser::new();
+
+        assert!(parser.parse("\\consume").is_err());
+        assert!(parser.parse("\\consume app.events --limit nope").is_err());
+        assert!(parser.parse("\\consume app.events --timeout nope").is_err());
+        assert!(parser.parse("\\consume app.events --bogus 1").is_err());
+    }
+
+    #[test]
+    fn test_parse_cluster_command_aliases() {
+        let parser = CommandParser::new();
+
+        assert_eq!(parser.parse("\\cluster snapshot").unwrap(), Command::ClusterSnapshot);
+        assert_eq!(
+            parser.parse("\\cluster purge --upto 42").unwrap(),
+            Command::ClusterPurge { upto: 42 }
+        );
+        assert_eq!(
+            parser.parse("\\cluster purge 42").unwrap(),
+            Command::ClusterPurge { upto: 42 }
+        );
+        assert_eq!(
+            parser.parse("\\cluster trigger-election").unwrap(),
+            Command::ClusterTriggerElection
+        );
+        assert_eq!(
+            parser.parse("\\cluster trigger election").unwrap(),
+            Command::ClusterTriggerElection
+        );
+        assert_eq!(
+            parser.parse("\\cluster transfer-leader 7").unwrap(),
+            Command::ClusterTransferLeader { node_id: 7 }
+        );
+        assert_eq!(
+            parser.parse("\\cluster transfer leader 7").unwrap(),
+            Command::ClusterTransferLeader { node_id: 7 }
+        );
+        assert_eq!(parser.parse("\\cluster stepdown").unwrap(), Command::ClusterStepdown);
+        assert_eq!(parser.parse("\\cluster step-down").unwrap(), Command::ClusterStepdown);
+        assert_eq!(parser.parse("\\cluster clear").unwrap(), Command::ClusterClear);
+        assert_eq!(parser.parse("\\cluster list").unwrap(), Command::ClusterList);
+        assert_eq!(parser.parse("\\cluster ls").unwrap(), Command::ClusterList);
+        assert_eq!(
+            parser.parse("\\cluster list groups").unwrap(),
+            Command::ClusterListGroups
+        );
+    }
+
     #[test]
     fn test_parse_cluster_leave_is_rejected() {
         let parser = CommandParser::new();
diff --git a/cli/src/session.rs b/cli/src/session.rs
index 17852f63..d2edf6df 100644
--- a/cli/src/session.rs
+++ b/cli/src/session.rs
@@ -180,6 +180,9 @@ pub struct CLISession {
     /// Session is connected
     connected: bool,
 
+    /// Current namespace for unqualified SQL statements
+    current_namespace: Option<String>,
+
     /// Active subscription paused state
     subscription_paused: bool,
 
@@ -370,6 +373,7 @@ impl CLISession {
             format,
             color,
             connected,
+            current_namespace: None,
             subscription_paused: false,
             loading_threshold_ms: loading_threshold_ms.unwrap_or(200),
             animations,
@@ -510,9 +514,13 @@ impl CLISession {
             None
         };
 
+        let request_namespace = self.request_namespace();
+
         // Execute the query
         let result = if upload_parts.is_empty() {
-            self.client.execute_query(&sql_to_send, None, None, None).await
+            self.client
+                .execute_query(&sql_to_send, None, None, request_namespace)
+                .await
         } else {
             let mut parts_for_send = Vec::with_capacity(upload_parts.len());
             for part in upload_parts.iter_mut() {
@@ -530,7 +538,7 @@ impl CLISession {
                     &sql_to_send,
                     Some(parts_for_send),
                     None,
-                    None,
+                    request_namespace,
                     upload_progress,
                 )
                 .await
@@ -550,11 +558,16 @@ impl CLISession {
     pub async fn execute(&mut self, sql: &str) -> Result<()> {
         let start = Instant::now();
         let elapsed = start.elapsed();
+        let namespace_switch = Self::parse_namespace_switch(sql);
 
         let result = self.execute_query_response(sql).await;
 
         match result {
             Ok(response) => {
+                if let Some(namespace) = namespace_switch {
+                    self.current_namespace = Some(namespace);
+                }
+
                 if let Some((config, server_message)) =
                     Self::extract_subscription_config(&response)?
                 {
@@ -655,6 +668,99 @@ impl CLISession {
         Ok((modified_sql, uploads))
     }
 
+    fn parse_namespace_switch(sql: &str) -> Option<String> {
+        let trimmed = sql.trim().trim_end_matches(';').trim();
+        if trimmed.is_empty() {
+            return None;
+        }
+
+        if let Some(remainder) = Self::strip_ascii_prefix(trimmed, "USE NAMESPACE") {
+            return Self::parse_namespace_identifier(remainder);
+        }
+
+        if let Some(remainder) = Self::strip_ascii_prefix(trimmed, "SET NAMESPACE") {
+            return Self::parse_namespace_identifier(remainder);
+        }
+
+        let remainder = Self::strip_ascii_prefix(trimmed, "USE")?;
+        let remainder = remainder.trim();
+        if remainder.eq_ignore_ascii_case("NAMESPACE") {
+            return None;
+        }
+
+        Self::parse_namespace_identifier(remainder)
+    }
+
+    fn strip_ascii_prefix<'a>(value: &'a str, prefix: &str) -> Option<&'a str> {
+        let prefix_len = prefix.len();
+        if value.len() < prefix_len || !value[..prefix_len].eq_ignore_ascii_case(prefix) {
+            return None;
+        }
+
+        Some(&value[prefix_len..])
+    }
+
+    fn parse_namespace_identifier(input: &str) -> Option<String> {
+        let trimmed = input.trim();
+        if trimmed.is_empty() {
+            return None;
+        }
+
+        let first = trimmed.chars().next()?;
+        if matches!(first, '\'' | '"' | '`') {
+            return Self::parse_quoted_namespace_identifier(trimmed, first);
+        }
+
+        let end = trimmed
+            .char_indices()
+            .find_map(|(index, ch)| (ch.is_whitespace() || ch == ';').then_some(index))
+            .unwrap_or(trimmed.len());
+
+        let namespace = &trimmed[..end];
+        if namespace.is_empty() || namespace.contains('.') {
+            return None;
+        }
+
+        if !trimmed[end..].trim().is_empty() {
+            return None;
+        }
+
+        Some(namespace.to_string())
+    }
+
+    fn parse_quoted_namespace_identifier(input: &str, quote: char) -> Option<String> {
+        let mut namespace = String::new();
+        let mut chars = input.char_indices().peekable();
+        let (_, opening_quote) = chars.next()?;
+        if opening_quote != quote {
+            return None;
+        }
+
+        while let Some((index, ch)) = chars.next() {
+            if ch == quote {
+                if chars.peek().map(|(_, next)| *next == quote).unwrap_or(false) {
+                    namespace.push(quote);
+                    chars.next();
+                    continue;
+                }
+
+                if namespace.is_empty() || namespace.contains('.') {
+                    return None;
+                }
+
+                if !input[index + ch.len_utf8()..].trim().is_empty() {
+                    return None;
+                }
+
+                return Some(namespace);
+            }
+
+            namespace.push(ch);
+        }
+
+        None
+    }
+
     fn is_file_call_at(sql: &str, idx: usize) -> bool {
         let bytes = sql.as_bytes();
         let needle = b"file";
@@ -900,6 +1006,18 @@ impl CLISession {
         }
     }
 
+    fn request_namespace(&self) -> Option<&str> {
+        self.current_namespace.as_deref()
+    }
+
+    fn effective_namespace(&self) -> &str {
+        self.request_namespace().unwrap_or("default")
+    }
+
+    fn current_namespace_label(&self) -> String {
+        format!("ns:{}", self.effective_namespace())
+    }
+
     fn primary_prompt(&self) -> String {
         // On Windows, rustyline has critical issues with ANSI color codes in prompts
         // The terminal cannot properly calculate display width, causing cursor misalignment
@@ -954,6 +1072,12 @@ impl CLISession {
             format!("{}@{}", self.username, self.server_host)
         };
 
+        let namespace = if use_colors_in_prompt {
+            self.current_namespace_label().magenta().to_string()
+        } else {
+            self.current_namespace_label()
+        };
+
         let arrow = if use_colors_in_prompt {
             if use_unicode {
                 "❯".bright_blue().bold().to_string()
@@ -964,7 +1088,7 @@ impl CLISession {
             ">".to_string()
         };
 
-        let parts = [status, brand_with_profile, identity];
+        let parts = [status, brand_with_profile, identity, namespace];
         let body = parts.join(" ");
         format!("{} {} ", body, arrow)
     }
@@ -2767,24 +2891,10 @@ impl CLISession {
                 .unwrap()
                 .as_nanos()
         );
-        let config = SubscriptionConfig::new(sub_id, query);
+        let config = self.build_subscription_config(query, sub_id)?;
         self.run_subscription_with_timeout(config, timeout).await
     }
 
-    /// Unsubscribe from active subscription via command line
-    ///
-    /// Since subscriptions run in a blocking loop, this method sends a signal
-    /// to cancel the active subscription. In practice, this would need to be
-    /// called from a different thread/context than the running subscription.
-    pub async fn unsubscribe(&mut self, _subscription_id: &str) -> Result<()> {
-        // For command-line usage, we can't easily interrupt a running subscription
-        // from the same process. This would require a more complex signaling mechanism.
-        // For now, inform the user how to cancel subscriptions.
-        println!("To unsubscribe from an active subscription, use Ctrl+C in the terminal");
-        println!("where the subscription is running, or kill the process.");
-        Ok(())
-    }
-
     /// List active subscriptions via command line
     ///
     /// Since subscriptions are managed per CLI session and run in blocking mode,
@@ -3080,6 +3190,7 @@ mod tests {
     #[derive(Debug)]
     struct TestServerState {
         sql_authorization_headers: Vec<String>,
+        sql_request_bodies: Vec<String>,
         refresh_authorization_headers: Vec<String>,
         health_authorization_headers: Vec<String>,
         cluster_health_authorization_headers: Vec<String>,
@@ -3091,6 +3202,7 @@ mod tests {
         fn default() -> Self {
             Self {
                 sql_authorization_headers: Vec::new(),
+                sql_request_bodies: Vec::new(),
                 refresh_authorization_headers: Vec::new(),
                 health_authorization_headers: Vec::new(),
                 cluster_health_authorization_headers: Vec::new(),
@@ -3230,7 +3342,9 @@ mod tests {
             },
             "/v1/api/sql" => {
                 if let Some(header) = authorization.clone() {
-                    state.lock().await.sql_authorization_headers.push(header.clone());
+                    let mut guard = state.lock().await;
+                    guard.sql_authorization_headers.push(header.clone());
+                    guard.sql_request_bodies.push(request.body.clone());
                     match header.as_str() {
                         "Bearer expired-token" => (
                             "HTTP/1.1 401 Unauthorized",
@@ -3311,6 +3425,7 @@ mod tests {
     struct TestHttpRequest {
         path: String,
         headers: HashMap<String, String>,
+        body: String,
     }
 
     async fn read_http_request(stream: &mut TcpStream) -> std::io::Result<TestHttpRequest> {
@@ -3360,7 +3475,13 @@ mod tests {
             }
         }
 
-        Ok(TestHttpRequest { path, headers })
+        let body = String::from_utf8_lossy(&buffer[header_end..]).to_string();
+
+        Ok(TestHttpRequest {
+            path,
+            headers,
+            body,
+        })
     }
 
     fn create_temp_store() -> (FileCredentialStore, TempDir) {
@@ -3410,6 +3531,71 @@ mod tests {
         assert_eq!(table_name, "message logs");
     }
 
+    #[test]
+    fn test_parse_namespace_switch_statements() {
+        assert_eq!(
+            CLISession::parse_namespace_switch("USE NAMESPACE chat;"),
+            Some("chat".to_string())
+        );
+        assert_eq!(
+            CLISession::parse_namespace_switch("SET NAMESPACE \"team chat\""),
+            Some("team chat".to_string())
+        );
+        assert_eq!(
+            CLISession::parse_namespace_switch("USE billing"),
+            Some("billing".to_string())
+        );
+        assert_eq!(
+            CLISession::parse_namespace_switch("USE NAMESPACE chat; SELECT 1"),
+            None
+        );
+    }
+
+    #[tokio::test]
+    #[timeout(5000)]
+    async fn test_execute_input_applies_current_namespace_to_followup_queries() {
+        let server = TestServer::spawn().await;
+
+        let mut session = CLISession::with_auth_and_instance(
+            server.base_url.clone(),
+            AuthProvider::jwt_token("fresh-token".to_string()),
+            OutputFormat::Json,
+            false,
+            None,
+            None,
+            Some("admin".to_string()),
+            None,
+            false,
+            None,
+            None,
+            None,
+            CLIConfiguration::default(),
+            crate::config::default_config_path(),
+            false,
+        )
+        .await
+        .expect("session should initialize");
+
+        session
+            .execute_input("USE NAMESPACE chat;")
+            .await
+            .expect("use namespace should succeed");
+        session
+            .execute_input("SELECT * FROM messages;")
+            .await
+            .expect("follow-up query should succeed");
+
+        assert_eq!(session.current_namespace.as_deref(), Some("chat"));
+
+        let state = server.state.lock().await;
+        assert_eq!(state.sql_request_bodies.len(), 2);
+        assert!(
+            state.sql_request_bodies[1].contains("\"namespace_id\":\"chat\""),
+            "expected namespace_id form field in request body: {}",
+            state.sql_request_bodies[1]
+        );
+    }
+
     #[tokio::test]
     #[timeout(5000)]
     async fn test_health_check_does_not_fall_back_to_authenticated_sql() {
diff --git a/cli/src/session/commands.rs b/cli/src/session/commands.rs
index ffe56771..4f3b3aa6 100644
--- a/cli/src/session/commands.rs
+++ b/cli/src/session/commands.rs
@@ -6,7 +6,7 @@ use kalam_client::SubscriptionConfig;
 use super::{CLISession, OutputFormat};
 use crate::{
     error::{CLIError, Result},
-    parser::Command,
+    parser::{Command, FlushTarget},
 };
 
 impl CLISession {
@@ -25,9 +25,22 @@ impl CLISession {
             Command::Help => {
                 self.show_help();
             },
-            Command::Flush => {
-                println!("Storage flushing all tables in current namespace...");
-                match self.execute("STORAGE FLUSH ALL").await {
+            Command::Flush(target) => {
+                let flush_sql = self.build_flush_query(&target)?;
+
+                match &target {
+                    FlushTarget::All => println!(
+                        "Storage flushing all tables in namespace '{}'...",
+                        self.effective_namespace()
+                    ),
+                    FlushTarget::Table(table) => println!(
+                        "Storage flushing table '{}' in namespace context '{}'...",
+                        table,
+                        self.effective_namespace()
+                    ),
+                }
+
+                match self.execute(&flush_sql).await {
                     Ok(_) => println!("Storage flush completed successfully"),
                     Err(e) => eprintln!("Storage flush failed: {}", e),
                 }
@@ -105,7 +118,6 @@ impl CLISession {
                 },
             },
             Command::Subscribe(query) => {
-                let (clean_sql, options) = Self::extract_subscribe_options(&query);
                 let sub_id = format!(
                     "sub_{}",
                     std::time::SystemTime::now()
@@ -113,13 +125,9 @@ impl CLISession {
                         .unwrap()
                         .as_nanos()
                 );
-                let mut config = SubscriptionConfig::new(sub_id, clean_sql);
-                config.options = options;
+                let config = self.build_subscription_config(&query, sub_id)?;
                 self.run_subscription(config).await?;
             },
-            Command::Unsubscribe => {
-                println!("No active subscription to cancel");
-            },
             Command::RefreshTables => {
                 println!("Table names refreshed");
             },
@@ -201,12 +209,155 @@ impl CLISession {
         }
 
         Ok(format!(
-            "EXECUTE AS USER '{}' ({})",
+            "EXECUTE AS '{}' ({})",
             Self::escape_sql_literal(&normalized_user),
             inner_sql,
         ))
     }
 
+    fn build_flush_query(&self, target: &FlushTarget) -> Result<String> {
+        match target {
+            FlushTarget::All => Ok("STORAGE FLUSH ALL".to_string()),
+            FlushTarget::Table(table) => {
+                Self::build_flush_table_query(table, Some(self.effective_namespace()))
+            },
+        }
+    }
+
+    pub(super) fn build_subscription_config(
+        &self,
+        query: &str,
+        subscription_id: String,
+    ) -> Result<SubscriptionConfig> {
+        let (clean_sql, options) = Self::extract_subscribe_options(query);
+        let qualified_sql = Self::qualify_subscription_sql(&clean_sql, self.effective_namespace())?;
+        let mut config = SubscriptionConfig::new(subscription_id, qualified_sql);
+        config.options = options;
+        Ok(config)
+    }
+
+    fn qualify_subscription_sql(sql: &str, default_namespace: &str) -> Result<String> {
+        let trimmed = sql.trim().trim_end_matches(';').trim();
+        if trimmed.is_empty() {
+            return Err(CLIError::ParseError(
+                "\\live requires a SELECT query".to_string(),
+            ));
+        }
+
+        let Some(from_idx) = Self::find_subscription_from_clause(trimmed) else {
+            return Ok(trimmed.to_string());
+        };
+
+        let relation_start = trimmed[from_idx..]
+            .char_indices()
+            .find_map(|(offset, ch)| (!ch.is_whitespace()).then_some(from_idx + offset));
+        let Some(relation_start) = relation_start else {
+            return Ok(trimmed.to_string());
+        };
+
+        let relation_end = Self::find_subscription_relation_end(trimmed, relation_start);
+        let relation = trimmed[relation_start..relation_end].trim();
+
+        let parts = Self::split_identifier_parts(relation).map_err(|_| {
+            CLIError::ParseError(
+                "\\live expects SELECT ... FROM <table> or <namespace.table>".to_string(),
+            )
+        })?;
+
+        if parts.len() != 1 {
+            return Ok(trimmed.to_string());
+        }
+
+        let qualified_relation = format!("{}.{}", Self::quote_identifier(default_namespace), relation);
+
+        Ok(format!(
+            "{}{}{}",
+            &trimmed[..relation_start],
+            qualified_relation,
+            &trimmed[relation_end..]
+        ))
+    }
+
+    fn find_subscription_from_clause(sql: &str) -> Option<usize> {
+        let mut in_single_quotes = false;
+        let mut in_double_quotes = false;
+
+        for (index, ch) in sql.char_indices() {
+            match ch {
+                '\'' if !in_double_quotes => in_single_quotes = !in_single_quotes,
+                '"' if !in_single_quotes => in_double_quotes = !in_double_quotes,
+                _ => {},
+            }
+
+            if in_single_quotes || in_double_quotes {
+                continue;
+            }
+
+            let end = index + 4;
+            if end > sql.len() || !sql[index..end].eq_ignore_ascii_case("from") {
+                continue;
+            }
+
+            let prev = sql[..index].chars().last();
+            let next = sql[end..].chars().next();
+            let prev_is_ident = prev.is_some_and(Self::is_subscription_identifier_char);
+            let next_is_ident = next.is_some_and(Self::is_subscription_identifier_char);
+
+            if !prev_is_ident && !next_is_ident {
+                return Some(end);
+            }
+        }
+
+        None
+    }
+
+    fn find_subscription_relation_end(sql: &str, start: usize) -> usize {
+        let mut in_double_quotes = false;
+
+        for (offset, ch) in sql[start..].char_indices() {
+            match ch {
+                '"' => in_double_quotes = !in_double_quotes,
+                _ if !in_double_quotes && ch.is_whitespace() => return start + offset,
+                _ => {},
+            }
+        }
+
+        sql.len()
+    }
+
+    fn is_subscription_identifier_char(ch: char) -> bool {
+        ch.is_ascii_alphanumeric() || ch == '_'
+    }
+
+    fn build_flush_table_query(target: &str, default_namespace: Option<&str>) -> Result<String> {
+        let trimmed = target.trim().trim_end_matches(';').trim();
+        if trimmed.is_empty() {
+            return Err(CLIError::ParseError(
+                "\\flush table requires a table name".to_string(),
+            ));
+        }
+
+        let parts = Self::split_identifier_parts(trimmed)?;
+        match parts.as_slice() {
+            [table_name] => {
+                let namespace = default_namespace.unwrap_or("default");
+                Ok(format!(
+                    "STORAGE FLUSH TABLE {}.{}",
+                    Self::quote_identifier(namespace),
+                    Self::quote_identifier(table_name),
+                ))
+            },
+            [namespace, table_name] => Ok(format!(
+                "STORAGE FLUSH TABLE {}.{}",
+                Self::quote_identifier(namespace),
+                Self::quote_identifier(table_name),
+            )),
+            _ => Err(CLIError::ParseError(
+                "\\flush table expects <table> or <namespace.table>".to_string(),
+            )),
+        }
+    }
+
     fn normalize_execute_as_user(user: &str) -> Result<String> {
         let trimmed = user.trim();
         if trimmed.is_empty() {
@@ -302,6 +453,10 @@ impl CLISession {
         value.replace('\'', "''")
     }
 
+    fn quote_identifier(value: &str) -> String {
+        format!("\"{}\"", value.replace('"', "\"\""))
+    }
+
     fn print_help_section(title: &str) {
         println!("{}", title.yellow().bold());
     }
@@ -334,12 +489,18 @@ impl CLISession {
             ("\\health", "Run public health probes"),
             ("\\dt, \\tables", "List tables"),
             ("\\d, \\describe <table>", "Describe a table"),
-            ("\\as <user> <SQL>", "Wrap a statement as EXECUTE AS USER"),
+            (
+                "\\as <user_id> <SQL>",
+                "Wrap a statement as EXECUTE AS '<user_id>'",
+            ),
             ("\\format <table|json|csv>", "Change output format"),
             ("\\refresh-tables, \\refresh", "Refresh autocomplete caches"),
             ("\\stats, \\metrics", "Show system stats"),
             ("\\sessions", "Show active sessions"),
-            ("\\flush", "Run STORAGE FLUSH ALL"),
+            (
+                "\\flush [all|table <table>]",
+                "Run STORAGE FLUSH using the current namespace",
+            ),
             ("\\cluster <subcommand>", "Cluster operations"),
             ("\\consume <topic>", "Consume topic messages"),
         ] {
@@ -349,10 +510,8 @@ impl CLISession {
 
         Self::print_help_section("Live Queries");
         for (command, description) in [
-            ("\\subscribe <SELECT ...>", "Start a live query"),
-            ("\\watch <SELECT ...>", "Alias of \\subscribe"),
-            ("\\live <SELECT ...>", "Short alias of \\subscribe"),
-            ("\\unsubscribe, \\unwatch", "Stop the active live query"),
+            ("\\live <SELECT ...>", "Start a live query"),
+            ("\\subscribe <SELECT ...>", "Alias of \\live"),
         ] {
             Self::print_help_row(command, description);
         }
@@ -360,6 +519,17 @@ impl CLISession {
         println!("  {}", "system.* tables are not subscribable.".dimmed());
         println!();
 
+        Self::print_help_section("Backup and Export SQL");
+        println!("  Run these as normal SQL statements:");
+        Self::print_help_example("BACKUP DATABASE TO '/tmp/kalamdb-backup.tar.gz';");
+        Self::print_help_example("EXPORT USER DATA;");
+        Self::print_help_example("SHOW EXPORT;");
+        println!(
+            "  {}",
+            "SHOW EXPORT returns a download_url for the finished user export.".dimmed()
+        );
+        println!();
+
         Self::print_help_section("Cluster Commands");
         for (command, description) in [
             ("\\cluster list", "List cluster nodes"),
@@ -408,9 +578,11 @@ impl CLISession {
         println!();
 
         Self::print_help_section("Examples");
+        Self::print_help_example("USE NAMESPACE chat;");
         Self::print_help_example("SELECT * FROM system.tables LIMIT 5;");
+        Self::print_help_example("\\flush table messages");
         Self::print_help_example("\\describe chat.messages;");
-        Self::print_help_example("\\as alice SELECT * FROM user.orders LIMIT 5;");
+        Self::print_help_example("\\as user_123 SELECT * FROM user.orders LIMIT 5;");
         Self::print_help_example("\\cluster list");
         println!();
     }
@@ -652,12 +824,43 @@ mod tests {
     fn test_build_execute_as_query_wraps_statement() {
         let query = CLISession::build_execute_as_query("alice", "SELECT * FROM user.orders;  ")
             .unwrap();
-        assert_eq!(query, "EXECUTE AS USER 'alice' (SELECT * FROM user.orders)");
+        assert_eq!(query, "EXECUTE AS 'alice' (SELECT * FROM user.orders)");
     }
 
     #[test]
     fn test_build_execute_as_query_escapes_user_literal() {
         let query = CLISession::build_execute_as_query("o'brien", "SELECT 1").unwrap();
-        assert_eq!(query, "EXECUTE AS USER 'o''brien' (SELECT 1)");
+        assert_eq!(query, "EXECUTE AS 'o''brien' (SELECT 1)");
+    }
+
+    #[test]
+    fn test_build_flush_table_query_uses_current_namespace_for_unqualified_table() {
+        let query = CLISession::build_flush_table_query("messages", Some("chat")).unwrap();
+        assert_eq!(query, "STORAGE FLUSH TABLE \"chat\".\"messages\"");
+    }
+
+    #[test]
+    fn test_build_flush_table_query_preserves_explicit_namespace() {
+        let query = CLISession::build_flush_table_query("billing.invoices", Some("chat"))
+            .unwrap();
+        assert_eq!(query, "STORAGE FLUSH TABLE \"billing\".\"invoices\"");
+    }
+
+    #[test]
+    fn test_qualify_subscription_sql_uses_current_namespace() {
+        let query =
+            CLISession::qualify_subscription_sql("SELECT * FROM messages WHERE id = 1", "chat")
+                .unwrap();
+
+        assert_eq!(query, "SELECT * FROM \"chat\".messages WHERE id = 1");
+    }
+
+    #[test]
+    fn test_qualify_subscription_sql_preserves_explicit_namespace() {
+        let query =
+            CLISession::qualify_subscription_sql("SELECT ID FROM billing.messages", "chat")
+                .unwrap();
+
+        assert_eq!(query, "SELECT ID FROM billing.messages");
     }
 }
diff --git a/cli/src/session/info.rs b/cli/src/session/info.rs
index ba022d45..eea03c22 100644
--- a/cli/src/session/info.rs
+++ b/cli/src/session/info.rs
@@ -74,6 +74,7 @@ impl CLISession {
         println!("{}", "Connection:".yellow().bold());
         print_info_row("Server URL", self.server_url.green());
         print_info_row("User ID", self.username.green());
+        print_info_row("Namespace", self.effective_namespace().green());
         print_info_row(
             "Connected",
             if self.connected {
diff --git a/cli/tests/cli/test_cli_auth_admin.rs b/cli/tests/cli/test_cli_auth_admin.rs
index b8e93ff6..b4494c67 100644
--- a/cli/tests/cli/test_cli_auth_admin.rs
+++ b/cli/tests/cli/test_cli_auth_admin.rs
@@ -13,15 +13,24 @@
 //! ```
 // TODO: Remove this since we have most of the tests covered by the integration tests
 #![allow(unused_imports)]
+use std::sync::OnceLock;
 use std::time::Duration;
 
 use assert_cmd::Command;
+use tokio::sync::Mutex as TokioMutex;
 
 use crate::common::*;
 
+fn admin_cli_test_mutex() -> &'static TokioMutex<()> {
+    static LOCK: OnceLock<TokioMutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| TokioMutex::new(()))
+}
+
 /// Test that root user can create namespaces
 #[tokio::test]
 async fn test_root_can_create_namespace() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running at {}. Skipping test.", server_url());
         return;
@@ -96,6 +105,8 @@ async fn test_root_can_create_namespace() {
 /// Test that root user can create and drop tables
 #[tokio::test]
 async fn test_root_can_create_drop_tables() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -139,6 +150,8 @@ async fn test_root_can_create_drop_tables() {
 /// Test CREATE NAMESPACE via CLI with root authentication
 #[tokio::test]
 async fn test_cli_create_namespace_as_root() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -181,6 +194,8 @@ async fn test_cli_create_namespace_as_root() {
 /// Test that non-admin users cannot create namespaces
 #[tokio::test]
 async fn test_regular_user_cannot_create_namespace() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -219,6 +234,8 @@ async fn test_regular_user_cannot_create_namespace() {
 /// Test CLI with explicit username/password
 #[tokio::test]
 async fn test_cli_with_explicit_credentials() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -238,6 +255,8 @@ async fn test_cli_with_explicit_credentials() {
 /// Test admin operations via CLI
 #[tokio::test]
 async fn test_cli_admin_operations() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -305,6 +324,8 @@ async fn test_cli_admin_operations() {
 /// Test SHOW NAMESPACES command
 #[tokio::test]
 async fn test_cli_show_namespaces() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -324,6 +345,8 @@ async fn test_cli_show_namespaces() {
 /// Test STORAGE FLUSH TABLE command via CLI
 #[tokio::test]
 async fn test_cli_flush_table() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
@@ -536,6 +559,8 @@ async fn test_cli_flush_table() {
 /// Test STORAGE FLUSH ALL command via CLI
 #[tokio::test]
 async fn test_cli_flush_all_tables() {
+    let _guard = admin_cli_test_mutex().lock().await;
+
     if !is_server_running_with_auth().await {
         eprintln!("⚠️  Server not running. Skipping test.");
         return;
diff --git a/cli/tests/cli/test_cli_doc_matrix.rs b/cli/tests/cli/test_cli_doc_matrix.rs
index 5de38923..83dda609 100644
--- a/cli/tests/cli/test_cli_doc_matrix.rs
+++ b/cli/tests/cli/test_cli_doc_matrix.rs
@@ -21,9 +21,16 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
         tests: &'a [&'a str],
     }
 
-    // This is the canonical docs inventory from KalamSite/content/getting-started/cli.mdx.
+    // This is the canonical docs inventory from ../KalamSite/content/server/getting-started/cli.mdx.
     let matrix = vec![
         // Connection/auth flags
+        Coverage {
+            item: "-u",
+            tests: &[
+                "short_connection_and_execution_flags_parse",
+                "test_cli_help_command",
+            ],
+        },
         Coverage {
             item: "--url",
             tests: &[
@@ -31,6 +38,13 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
                 "test_cli_runtime_timeout_and_spinner_flags_work",
             ],
         },
+        Coverage {
+            item: "-H",
+            tests: &[
+                "short_host_port_and_file_flags_parse",
+                "test_cli_host_and_port_work_against_running_server",
+            ],
+        },
         Coverage {
             item: "--host",
             tests: &[
@@ -38,6 +52,13 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
                 "test_cli_host_and_port_work_against_running_server",
             ],
         },
+        Coverage {
+            item: "-p",
+            tests: &[
+                "short_host_port_and_file_flags_parse",
+                "test_cli_host_and_port_work_against_running_server",
+            ],
+        },
         Coverage {
             item: "--port",
             tests: &[
@@ -62,10 +83,24 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
             tests: &["test_cli_multiple_instances"],
         },
         // Query/output flags
+        Coverage {
+            item: "-c",
+            tests: &[
+                "short_connection_and_execution_flags_parse",
+                "test_cli_color_output",
+            ],
+        },
         Coverage {
             item: "--command",
             tests: &["test_cli_color_output"],
         },
+        Coverage {
+            item: "-f",
+            tests: &[
+                "short_host_port_and_file_flags_parse",
+                "test_cli_batch_file_execution",
+            ],
+        },
         Coverage {
             item: "--file",
             tests: &["test_cli_batch_file_execution"],
@@ -132,10 +167,6 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
             item: "--list-subscriptions",
             tests: &["test_cli_subscription_commands"],
         },
-        Coverage {
-            item: "--unsubscribe",
-            tests: &["test_cli_subscription_commands"],
-        },
         // Consume flags
         Coverage {
             item: "--consume",
@@ -215,10 +246,25 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
             item: "--config",
             tests: &["test_cli_load_config_file"],
         },
+        Coverage {
+            item: "-v",
+            tests: &[
+                "short_connection_and_execution_flags_parse",
+                "test_cli_verbose_output",
+            ],
+        },
         Coverage {
             item: "--verbose",
             tests: &["test_cli_verbose_output"],
         },
+        Coverage {
+            item: "-h",
+            tests: &["test_cli_short_help_command"],
+        },
+        Coverage {
+            item: "-V",
+            tests: &["test_cli_short_version_command"],
+        },
         Coverage {
             item: "--version",
             tests: &["test_cli_version_command"],
@@ -369,10 +415,6 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
             item: "\\subscribe",
             tests: &["test_cli_subscribe_flags_work_end_to_end"],
         },
-        Coverage {
-            item: "\\watch",
-            tests: &["test_cli_meta_commands_doc_smoke_non_interactive"],
-        },
         Coverage {
             item: "\\live",
             tests: &[
@@ -380,14 +422,6 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
                 "test_cli_meta_commands_doc_smoke_non_interactive",
             ],
         },
-        Coverage {
-            item: "\\unsubscribe",
-            tests: &["test_cli_meta_commands_doc_smoke_non_interactive"],
-        },
-        Coverage {
-            item: "\\unwatch",
-            tests: &["test_cli_meta_commands_doc_smoke_non_interactive"],
-        },
         Coverage {
             item: "\\consume",
             tests: &["test_cli_consume_flags_work_end_to_end"],
@@ -462,6 +496,7 @@ fn test_docs_matrix_has_execution_tests_for_documented_flags_and_commands() {
         include_str!("test_cli_auth.rs"),
         include_str!("test_cli_auth_admin.rs"),
         include_str!("test_cli_doc_matrix.rs"),
+        include_str!("../../src/args.rs"),
         include_str!("../users/test_admin.rs"),
         include_str!("../tables/test_user_tables.rs"),
         include_str!("../subscription/test_subscribe.rs"),
@@ -824,6 +859,27 @@ fn test_cli_version_command() {
     assert!(stdout.contains("Commit:"), "version output should include commit metadata");
 }
 
+#[test]
+fn test_cli_short_help_command() {
+    let mut cmd = create_cli_command();
+    cmd.arg("-h");
+
+    cmd.assert()
+        .success()
+        .stdout(predicates::str::contains("Interactive SQL terminal"))
+        .stdout(predicates::str::contains("--watch-schema"));
+}
+
+#[test]
+fn test_cli_short_version_command() {
+    let mut cmd = create_cli_command();
+    cmd.arg("-V");
+    let output = cmd.output().expect("run -V");
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(output.status.success(), "-V should succeed");
+    assert!(stdout.contains("Commit:"), "short version output should include commit metadata");
+}
+
 #[test]
 fn test_cli_meta_commands_doc_smoke_non_interactive() {
     // Interactive meta-commands are parsed in REPL mode, not by `--command`.
@@ -849,15 +905,12 @@ fn test_cli_meta_commands_doc_smoke_non_interactive() {
         "\\refresh-tables",
         "\\refresh",
         "\\subscribe",
-        "\\watch",
         "\\live",
         "\\consume",
         "\\show-credentials",
         "\\credentials",
         "\\update-credentials",
         "\\delete-credentials",
-        "\\unsubscribe",
-        "\\unwatch",
         "\\flush",
         "\\cluster",
     ];
diff --git a/cli/tests/common/mod.rs b/cli/tests/common/mod.rs
index 765a67e6..3b73e15c 100644
--- a/cli/tests/common/mod.rs
+++ b/cli/tests/common/mod.rs
@@ -4,6 +4,7 @@ extern crate kalam_cli;
 use std::os::unix::io::AsRawFd;
 use std::{
     collections::{HashMap, HashSet, VecDeque},
+    fs,
     fs::OpenOptions,
     io::{BufRead, BufReader},
     net::TcpListener,
@@ -11,7 +12,7 @@ use std::{
     process::{Child, Command, Stdio},
     sync::{mpsc as std_mpsc, Mutex, OnceLock},
     thread,
-    time::{Duration, Instant},
+    time::{Duration, Instant, SystemTime},
 };
 
 #[cfg(unix)]
@@ -88,21 +89,18 @@ static LOGIN_MUTEX: OnceLock<TokioMutex<()>> = OnceLock::new();
 static TOKEN_FILE_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
 static TEST_CLI_HOME_DIR: OnceLock<PathBuf> = OnceLock::new();
 static TEST_CLI_CREDENTIALS_PATH: OnceLock<PathBuf> = OnceLock::new();
-static SHARED_HTTP_CLIENT: OnceLock<Client> = OnceLock::new();
 
 const LEADER_CACHE_TTL: Duration = Duration::from_secs(5);
 
 pub fn shared_http_client() -> Client {
-    SHARED_HTTP_CLIENT
-        .get_or_init(|| {
-            Client::builder()
-                .pool_max_idle_per_host(512)
-                .pool_idle_timeout(Duration::from_secs(90))
-                .tcp_nodelay(true)
-                .build()
-                .expect("failed to build shared test HTTP client")
-        })
-        .clone()
+    // Tests use separate tokio runtimes, so reusing one global reqwest client can leave pooled
+    // dispatch tasks bound to a runtime that has already shut down.
+    Client::builder()
+        .pool_max_idle_per_host(512)
+        .pool_idle_timeout(Duration::from_secs(90))
+        .tcp_nodelay(true)
+        .build()
+        .expect("failed to build test HTTP client")
 }
 
 #[derive(Clone, Debug)]
@@ -1194,9 +1192,8 @@ fn kalamdb_server_bin() -> Result<PathBuf, Box<dyn std::error::Error>> {
         return Ok(PathBuf::from(path));
     }
 
-    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    path.pop();
-    path.push("target");
+    let repo_root = workspace_root();
+    let mut path = repo_root.join("target");
     path.push("debug");
     path.push(if cfg!(windows) {
         "kalamdb-server.exe"
@@ -1204,16 +1201,91 @@ fn kalamdb_server_bin() -> Result<PathBuf, Box<dyn std::error::Error>> {
         "kalamdb-server"
     });
 
-    if path.exists() {
-        Ok(path)
-    } else {
-        Err(format!(
+    if !path.exists() || is_server_binary_stale(&repo_root, &path)? {
+        build_kalamdb_server_binary(&repo_root)?;
+    }
+
+    if !path.exists() {
+        return Err(format!(
             "kalamdb-server binary not found at {}. Build it with `cargo build -p kalamdb-server \
              --bin kalamdb-server`.",
             path.display()
         )
-        .into())
+        .into());
     }
+
+    Ok(path)
+}
+
+fn workspace_root() -> PathBuf {
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.pop();
+    path
+}
+
+fn build_kalamdb_server_binary(repo_root: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    let status = Command::new("cargo")
+        .arg("build")
+        .arg("-p")
+        .arg("kalamdb-server")
+        .arg("--bin")
+        .arg("kalamdb-server")
+        .current_dir(repo_root)
+        .status()?;
+
+    if status.success() {
+        Ok(())
+    } else {
+        Err("Failed to build kalamdb-server binary for fresh test server".into())
+    }
+}
+
+fn is_server_binary_stale(
+    repo_root: &Path,
+    binary_path: &Path,
+) -> Result<bool, Box<dyn std::error::Error>> {
+    if !binary_path.exists() {
+        return Ok(true);
+    }
+
+    let binary_mtime = fs::metadata(binary_path)?.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+    let source_roots = [
+        repo_root.join("Cargo.toml"),
+        repo_root.join("Cargo.lock"),
+        repo_root.join("backend/Cargo.toml"),
+        repo_root.join("backend/build.rs"),
+        repo_root.join("backend/src"),
+        repo_root.join("backend/crates"),
+    ];
+
+    for source_root in source_roots {
+        if !source_root.exists() {
+            continue;
+        }
+
+        if latest_modified_time(&source_root)? > binary_mtime {
+            return Ok(true);
+        }
+    }
+
+    Ok(false)
+}
+
+fn latest_modified_time(path: &Path) -> Result<SystemTime, Box<dyn std::error::Error>> {
+    let metadata = fs::metadata(path)?;
+    let mut latest = metadata.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+
+    if metadata.is_dir() {
+        for entry in fs::read_dir(path)? {
+            let entry = entry?;
+            let child_latest = latest_modified_time(&entry.path())?;
+            if child_latest > latest {
+                latest = child_latest;
+            }
+        }
+    }
+
+    Ok(latest)
 }
 
 async fn start_local_test_server() -> Result<AutoTestServer, Box<dyn std::error::Error>> {
@@ -2368,6 +2440,7 @@ fn is_redacted_cluster_sql_error(sql: &str, message: &str) -> bool {
         || lower_sql.starts_with("insert ")
         || lower_sql.starts_with("update ")
         || lower_sql.starts_with("delete ")
+        || lower_sql.starts_with("execute as ")
         || lower_sql.starts_with("execute as user ")
 }
 
diff --git a/cli/tests/smoke/ddl/smoke_test_backup_restore.rs b/cli/tests/smoke/ddl/smoke_test_backup_restore.rs
index a7c12496..934021c8 100644
--- a/cli/tests/smoke/ddl/smoke_test_backup_restore.rs
+++ b/cli/tests/smoke/ddl/smoke_test_backup_restore.rs
@@ -1,9 +1,11 @@
 //! Smoke tests for BACKUP DATABASE / RESTORE DATABASE SQL commands.
 //!
 //! ## What is tested
-//! - `BACKUP DATABASE TO '<path>'` creates a job that completes and writes the expected backup
-//!   directory layout (`rocksdb/`, `storage/`, `snapshots/`, `streams/`).
-//! - `RESTORE DATABASE FROM '<path>'` creates a restore job that reaches a terminal state.
+//! - `BACKUP DATABASE TO '<path>'` creates a job that completes and writes either the expected
+//!   backup directory layout (`rocksdb/`, `storage/`, `snapshots/`, `streams/`) or a `.tar.gz`
+//!   archive containing that layout.
+//! - `RESTORE DATABASE FROM '<path>'` accepts either a backup directory or a `.tar.gz` archive
+//!   and creates a restore job that reaches a terminal state.
 //! - Non-DBA users receive an authorization error when attempting either command.
 //! - `RESTORE DATABASE FROM '<non-existent-path>'` returns a clear error immediately (no job
 //!   created).
@@ -49,9 +51,16 @@ fn tmp_backup_path(suffix: &str) -> PathBuf {
     std::env::temp_dir().join(unique)
 }
 
+/// Return a fresh `.tar.gz` archive path suitable for archive backup tests.
+fn tmp_backup_archive_path(suffix: &str) -> PathBuf {
+    let unique = generate_unique_namespace(suffix);
+    std::env::temp_dir().join(format!("{}.tar.gz", unique))
+}
+
 // ── tests ────────────────────────────────────────────────────────────────────
 
-/// BACKUP DATABASE creates a completed job and writes the expected directory layout.
+/// BACKUP DATABASE creates a completed job and writes the expected directory layout
+/// when the target path is a directory.
 #[ntest::timeout(300_000)]
 #[test]
 fn smoke_backup_database_job_completes() {
@@ -97,6 +106,45 @@ fn smoke_backup_database_job_completes() {
     let _ = std::fs::remove_dir_all(&backup_path);
 }
 
+/// BACKUP DATABASE writes a `.tar.gz` archive when the target path ends with
+/// `.tar.gz`.
+#[ntest::timeout(300_000)]
+#[test]
+fn smoke_backup_database_archive_job_completes() {
+    if !require_server_running() {
+        return;
+    }
+
+    let backup_path = tmp_backup_archive_path("kdb_bkp_archive");
+
+    let output = execute_sql_as_root_via_client(&format!(
+        "BACKUP DATABASE TO '{}'",
+        backup_path.display()
+    ))
+    .expect("BACKUP DATABASE archive should succeed");
+
+    let job_id =
+        parse_job_id(&output).unwrap_or_else(|| panic!("Could not parse job id from: {}", output));
+
+    let status = wait_for_job_finished(&job_id, BACKUP_JOB_TIMEOUT)
+        .unwrap_or_else(|e| panic!("Backup archive job wait failed: {}", e));
+
+    assert_eq!(status, "completed", "Backup archive job did not complete: {}", job_id);
+    assert!(backup_path.is_file(), "Backup archive was not created: {}", backup_path.display());
+
+    let bytes = std::fs::read(&backup_path).expect("read backup archive");
+    assert!(bytes.len() >= 2, "Backup archive should not be empty");
+    assert_eq!(
+        &bytes[..2],
+        &[0x1f, 0x8b],
+        "Backup archive should start with gzip magic bytes"
+    );
+
+    println!("✅  Backup archive verified at {}", backup_path.display());
+
+    let _ = std::fs::remove_file(&backup_path);
+}
+
 /// RESTORE DATABASE FROM a valid backup path creates a restore job that completes.
 ///
 /// Restore rewrites on-disk data; a server restart is required to reload it.
@@ -155,6 +203,51 @@ fn smoke_restore_from_backup_job_completes() {
     let _ = std::fs::remove_dir_all(&backup_path);
 }
 
+/// RESTORE DATABASE FROM accepts a `.tar.gz` archive path and creates a restore
+/// job that reaches a terminal state.
+#[ntest::timeout(360_000)]
+#[test]
+fn smoke_restore_from_backup_archive_job_completes() {
+    if !require_server_running() {
+        return;
+    }
+
+    let backup_path = tmp_backup_archive_path("kdb_restore_archive");
+
+    let bkp_out = execute_sql_as_root_via_client(&format!(
+        "BACKUP DATABASE TO '{}'",
+        backup_path.display()
+    ))
+    .expect("BACKUP DATABASE archive should succeed");
+
+    let bkp_job_id = parse_job_id(&bkp_out).unwrap_or_else(|| panic!("No job id in: {}", bkp_out));
+    let bkp_status = wait_for_job_finished(&bkp_job_id, BACKUP_JOB_TIMEOUT)
+        .unwrap_or_else(|e| panic!("Backup archive job wait failed: {}", e));
+    assert_eq!(bkp_status, "completed", "Backup archive must complete before restore test");
+    assert!(backup_path.is_file(), "Backup archive was not created: {}", backup_path.display());
+
+    let restore_out = execute_sql_as_root_via_client(&format!(
+        "RESTORE DATABASE FROM '{}'",
+        backup_path.display()
+    ))
+    .expect("RESTORE DATABASE archive should succeed");
+
+    let restore_job_id = parse_job_id(&restore_out)
+        .unwrap_or_else(|| panic!("Could not parse restore job id from: {}", restore_out));
+
+    let status = wait_for_job_finished(&restore_job_id, RESTORE_JOB_TIMEOUT)
+        .unwrap_or_else(|e| panic!("Restore archive job wait failed: {}", e));
+
+    assert!(
+        status == "completed" || status == "failed",
+        "Restore archive job should be in terminal state; got: {}",
+        status
+    );
+    println!("✅  Restore archive job finished with status '{}'", status);
+
+    let _ = std::fs::remove_file(&backup_path);
+}
+
 /// A regular `user`-role user is forbidden from running BACKUP DATABASE.
 #[ntest::timeout(60_000)]
 #[test]
diff --git a/cli/tests/smoke/ddl/smoke_test_export_user_data.rs b/cli/tests/smoke/ddl/smoke_test_export_user_data.rs
index 74aaaf2a..e7230e55 100644
--- a/cli/tests/smoke/ddl/smoke_test_export_user_data.rs
+++ b/cli/tests/smoke/ddl/smoke_test_export_user_data.rs
@@ -39,10 +39,12 @@ fn parse_job_id(output: &str) -> Option<String> {
     }
 }
 
-/// Translate a download URL from SHOW EXPORT into one reachable by the test
-/// client.  The server may advertise `0.0.0.0` or a bind address that is not
-/// directly routable; we replace the scheme+host+port with the one we already
-/// know works (`server_url()`).
+/// Resolve a SHOW EXPORT download path or URL into one reachable by the test
+/// client.
+///
+/// SHOW EXPORT now returns a relative URI path like `/v1/exports/...`, but the
+/// helper still accepts legacy absolute URLs so the smoke test remains useful
+/// against older servers.
 fn normalize_download_url(raw_url: &str) -> String {
     if let Some(path_start) = raw_url.find("/v1/") {
         format!("{}{}", server_url().trim_end_matches('/'), &raw_url[path_start..])
@@ -175,7 +177,7 @@ fn smoke_export_user_data_job_completes() {
     let _ = execute_sql_as_root_via_client(&format!("DROP USER IF EXISTS {}", export_user));
 }
 
-/// SHOW EXPORT returns the completed job status and a non-empty download URL.
+/// SHOW EXPORT returns the completed job status and a relative download URI.
 #[ntest::timeout(240_000)]
 #[test]
 fn smoke_show_export_returns_completed_status_and_download_url() {
@@ -276,8 +278,13 @@ fn smoke_show_export_returns_completed_status_and_download_url() {
         "download_url should be non-empty for completed export"
     );
     assert!(
-        download_url.contains("/v1/exports/"),
-        "download_url should contain '/v1/exports/'; got '{}'",
+        download_url.starts_with("/v1/exports/"),
+        "download_url should start with '/v1/exports/'; got '{}'",
+        download_url
+    );
+    assert!(
+        !download_url.starts_with("http://") && !download_url.starts_with("https://"),
+        "download_url should be a relative URI path, not an absolute URL; got '{}'",
         download_url
     );
 
@@ -369,7 +376,7 @@ fn smoke_export_download_zip_is_valid() {
 
     assert!(!download_url.is_empty(), "download_url must be non-empty");
 
-    // Normalize URL (replace server advertised host:port with test reachable URL)
+    // Resolve the relative URI path into a concrete URL for the test client.
     let normalized = normalize_download_url(&download_url);
     println!("⬇️  Downloading export from: {}", normalized);
 
diff --git a/cli/tests/subscription/test_subscribe.rs b/cli/tests/subscription/test_subscribe.rs
index ae52febc..5fd9a66f 100644
--- a/cli/tests/subscription/test_subscribe.rs
+++ b/cli/tests/subscription/test_subscribe.rs
@@ -200,23 +200,6 @@ fn test_cli_subscription_commands() {
     let output = cmd.output().unwrap();
     assert!(output.status.success(), "list-subscriptions command should succeed");
 
-    // Test --unsubscribe command (should provide helpful message)
-    let mut cmd = create_cli_command();
-    cmd.arg("-u")
-        .arg(server_url())
-        .arg("--user")
-        .arg(default_username())
-        .arg("--password")
-        .arg(root_password())
-        .arg("--unsubscribe")
-        .arg("test-subscription-id");
-
-    let output = cmd.output().unwrap();
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    assert!(
-        output.status.success() && stdout.contains("Ctrl+C"),
-        "unsubscribe command should provide helpful feedback"
-    );
 }
 
 /// T042: Test live query with WHERE filter
@@ -303,15 +286,6 @@ fn test_cli_subscription_pause_resume() {
     // Ctrl+S pauses output, Ctrl+Q resumes
 }
 
-/// T044: Test unsubscribe command support
-#[test]
-#[ignore] // \unsubscribe is an interactive meta-command that cannot be tested via CLI args
-fn test_cli_unsubscribe() {
-    // Note: \unsubscribe is an interactive meta-command used within a REPL session
-    // It cannot be tested via command-line arguments
-    // Manual testing: Start subscription, then type \unsubscribe in REPL
-}
-
 /// Test CLI subscription with initial data
 #[test]
 fn test_cli_subscription_with_initial_data() {
diff --git a/docs/api/api-reference.md b/docs/api/api-reference.md
index bd186ade..2f304821 100644
--- a/docs/api/api-reference.md
+++ b/docs/api/api-reference.md
@@ -107,7 +107,9 @@ Fields:
 
 - `sql` (required string)
 - `params` (optional array)
-- `namespace_id` (optional string)
+- `namespace_id` (optional string): request-scoped default namespace for
+  unqualified table names. Interactive clients can send this on follow-up
+  requests after a successful `USE namespace`.
 
 ### Multipart body (FILE datatype path)
 
@@ -115,7 +117,7 @@ Expected form parts:
 
 - `sql` (required)
 - `params` (optional; JSON array string)
-- `namespace_id` (optional)
+- `namespace_id` (optional request-scoped default namespace)
 - `file:<placeholder>` one or more file parts
 
 Placeholder mapping:
diff --git a/docs/architecture/decisions/adr-019-subject-scoped-user-identity.md b/docs/architecture/decisions/adr-019-subject-scoped-user-identity.md
index ee4375c8..291067f7 100644
--- a/docs/architecture/decisions/adr-019-subject-scoped-user-identity.md
+++ b/docs/architecture/decisions/adr-019-subject-scoped-user-identity.md
@@ -16,17 +16,17 @@ Ordinary USER-table and STREAM-table access is always subject-scoped to the
 authenticated user.
 
 - No role receives implicit all-user USER-table or STREAM-table reads.
-- Explicit `EXECUTE AS USER` uses a role hierarchy: system can target system/dba/service/user, DBA can target dba/service/user, service can target service/user, and regular users cannot target another user.
-- Target role classification for `EXECUTE AS USER` and USER-table file `user_id` downloads comes from a small in-memory map of service, DBA, and system users maintained by `system.users`; IDs absent from that privileged map are treated as regular users.
-- Self-targeted `EXECUTE AS USER` is allowed as a no-op identity boundary.
-- APIs that accept an optional `user_id` for USER-table resources must authorize cross-user values through the same role hierarchy used by `EXECUTE AS USER`.
+- Explicit `EXECUTE AS '<user_id>'` uses a role hierarchy: system can target system/dba/service/user, DBA can target dba/service/user, service can target service/user, and regular users cannot target another user.
+- Target role classification for `EXECUTE AS '<user_id>'` and USER-table file `user_id` downloads comes from a small in-memory map of service, DBA, and system users maintained by `system.users`; IDs absent from that privileged map are treated as regular users.
+- Self-targeted `EXECUTE AS '<user_id>'` is allowed as a no-op identity boundary.
+- APIs that accept an optional `user_id` for USER-table resources must authorize cross-user values through the same role hierarchy used by `EXECUTE AS '<user_id>'`.
 - Shared tables remain shared through their table access policy, not through user impersonation.
 
 ## Rationale
 
-Role privilege should control administrative capabilities, not silently merge user data planes. Keeping ordinary USER-table and STREAM-table DML and SELECT behavior tied to the authenticated subject avoids accidental cross-user reads, deletes, updates, file downloads, and subscriptions. When a background service must act for a user, `EXECUTE AS USER` provides an explicit, audited boundary governed by the role hierarchy.
+Role privilege should control administrative capabilities, not silently merge user data planes. Keeping ordinary USER-table and STREAM-table DML and SELECT behavior tied to the authenticated subject avoids accidental cross-user reads, deletes, updates, file downloads, and subscriptions. When a background service must act for a user, `EXECUTE AS '<user_id>'` provides an explicit, audited boundary governed by the role hierarchy.
 
-Self-targeted `EXECUTE AS USER` remains valid so existing wrapper syntax can be parsed and audited without introducing a second behavior for the caller's own identity.
+Self-targeted `EXECUTE AS '<user_id>'` remains valid so existing wrapper syntax can be parsed and audited without introducing a second behavior for the caller's own identity.
 
 The privileged-role map avoids fetching high-cardinality regular user rows in impersonation hot paths. `system.users` warms the map from its role index at provider construction and updates it after successful create, role update, and soft-delete operations. Soft-deleted IDs whose persisted role is still service, DBA, or system remain classified as privileged so deletion cannot silently downgrade a target ID into regular-user permissions.
 
@@ -35,17 +35,17 @@ The privileged-role map avoids fetching high-cardinality regular user rows in im
 ### Positive
 
 - DBA, service, system, and regular users all see the same per-subject isolation on USER and STREAM tables.
-- Privileged DML can act on another user's USER-table or STREAM-table rows only through authorized, audited `EXECUTE AS USER`.
+- Privileged DML can act on another user's USER-table or STREAM-table rows only through authorized, audited `EXECUTE AS '<user_id>'`.
 - File download `user_id` query parameters cannot bypass the caller identity or role matrix.
 - Impersonation authorization no longer performs a per-request `system.users` lookup for regular targets.
-- Tests assert both isolation surfaces: direct USER-table and STREAM-table access is scoped, and explicit `EXECUTE AS USER` follows the role matrix.
+- Tests assert both isolation surfaces: direct USER-table and STREAM-table access is scoped, and explicit `EXECUTE AS '<user_id>'` follows the role matrix.
 
 ### Negative
 
-- Background workflows that need to create data for another user must use an account whose role can target that user through `EXECUTE AS USER`.
+- Background workflows that need to create data for another user must use an account whose role can target that user through `EXECUTE AS '<user_id>'`.
 - Historical specs and demos that described implicit privileged USER-table scans are superseded by this policy.
 
 ### Operational implications
 
-- A running server must be restarted after this policy change; old binaries may still allow cross-user `EXECUTE AS USER`.
+- A running server must be restarted after this policy change; old binaries may still allow cross-user `EXECUTE AS '<user_id>'`.
 - Smoke tests should be run against a fresh server when validating this behavior locally.
diff --git a/docs/development/user-table-storage.md b/docs/development/user-table-storage.md
index ad448798..b4b3827f 100644
--- a/docs/development/user-table-storage.md
+++ b/docs/development/user-table-storage.md
@@ -41,16 +41,14 @@ Each user row exposes two columns that drive routing:
 Example: pin `alice` to the EU bucket, leave `bob` on the default table storage.
 
 ```sql
-UPDATE system.users
-SET storage_mode = 'region', storage_id = 's3_eu'
-WHERE username = 'alice';
+ALTER USER 'alice' SET STORAGE_MODE region;
+ALTER USER 'alice' SET STORAGE_ID 's3_eu';
 
-UPDATE system.users
-SET storage_mode = 'table', storage_id = NULL
-WHERE username = 'bob';
+ALTER USER 'bob' SET STORAGE_MODE table;
+ALTER USER 'bob' SET STORAGE_ID NULL;
 ```
 
-Only `dba`/`system` roles should run these updates. A future `ALTER USER` syntax will provide first-class setters, but direct SQL works today.
+Only `dba`/`system` roles can run these statements.
 
 ## 3. Create user tables that honor per-user storage
 
diff --git a/docs/getting-started/cli.md b/docs/getting-started/cli.md
index 6b0707d1..e79134b7 100644
--- a/docs/getting-started/cli.md
+++ b/docs/getting-started/cli.md
@@ -119,7 +119,6 @@ kalam --watch-schema --table app.messages --run "npm run schema:gen" --interval
 - `--subscription-timeout` – subscription idle timeout in seconds (0 = no timeout)
 - `--initial-data-timeout` – max seconds to wait for initial data batch
 - `--list-subscriptions` – list active subscriptions
-- `--unsubscribe <subscription_id>` – unsubscribe by id
 - `--watch-schema` – poll `system.tables` and run a local command on schema changes
 - `--namespace` – repeat to scope schema watch to one or more namespaces
 - `--table` – repeat to scope schema watch to one or more `namespace.table` targets
@@ -139,13 +138,12 @@ In interactive mode, meta-commands start with `\`:
 | `\history`, `\h`                | Open command history                      |
 | `\dt`, `\tables`               | List tables (`system.tables`)             |
 | `\d <table>`, `\describe <table>` | Describe table                         |
-| `\as <user> <SQL>`              | Wrap one statement as `EXECUTE AS USER`   |
+| `\as <user_id> <SQL>`           | Wrap one statement as `EXECUTE AS '<user_id>'` |
 | `\stats`, `\metrics`          | Show `system.stats`                       |
 | `\health`                       | Server healthcheck                        |
 | `\flush`                        | Run `STORAGE FLUSH ALL`                   |
 | `\format table|json|csv`        | Change output format                      |
-| `\subscribe <SQL>`, `\watch <SQL>`, `\live <SQL>` | Start live subscription |
-| `\unsubscribe`, `\unwatch`      | No-op (prints “No active subscription to cancel”) |
+| `\live <SQL>`, `\subscribe <SQL>` | Start live subscription (`\subscribe` is an alias) |
 | `\cluster ...`                  | Cluster commands (see below)              |
 | `\refresh-tables`, `\refresh` | Refresh autocomplete metadata             |
 | `\sessions`                     | Show active sessions                      |
@@ -154,6 +152,14 @@ In interactive mode, meta-commands start with `\`:
 | `\update-credentials <u> <p>`  | Update stored credentials                 |
 | `\delete-credentials`          | Delete stored credentials                 |
 
+Backup/export SQL examples you can run directly from the CLI:
+
+```sql
+BACKUP DATABASE TO '/tmp/kalamdb-backup.tar.gz';
+EXPORT USER DATA;
+SHOW EXPORT;
+```
+
 ### Cluster meta-commands
 
 - `\cluster snapshot`
diff --git a/docs/getting-started/quick-start.md b/docs/getting-started/quick-start.md
index bbd52c0b..84db437d 100644
--- a/docs/getting-started/quick-start.md
+++ b/docs/getting-started/quick-start.md
@@ -77,10 +77,10 @@ JSON
 
 ## 7. Next steps
 
-### Optional: `EXECUTE AS USER`
+### Optional: `EXECUTE AS`
 
 Use wrapper syntax only. Ordinary USER-table and STREAM-table access stays
-scoped to the authenticated user; explicit `EXECUTE AS USER` follows the role
+scoped to the authenticated user; explicit `EXECUTE AS` follows the role
 hierarchy: system can target any role, DBA can target DBA/service/user,
 service can target service/user, and regular users can only target themselves.
 
@@ -88,7 +88,7 @@ service can target service/user, and regular users can only target themselves.
 curl -u root: -X POST http://127.0.0.1:8080/v1/api/sql \
   -H 'Content-Type: application/json' \
   -d @- <<'JSON'
-{"sql":"EXECUTE AS USER 'root' (SELECT * FROM app.messages LIMIT 1);"}
+{"sql":"EXECUTE AS 'user_123' (SELECT * FROM app.messages LIMIT 1);"}
 JSON
 ```
 
diff --git a/docs/reference/sql.md b/docs/reference/sql.md
index 97835dcc..66feffdc 100644
--- a/docs/reference/sql.md
+++ b/docs/reference/sql.md
@@ -39,6 +39,10 @@ ALTER NAMESPACE <namespace_name>
 
 ### USE / SET NAMESPACE
 
+Changes the default namespace for the current request or multi-statement batch.
+In the interactive CLI, a successful `USE` also updates the CLI's local
+namespace so later requests automatically send `namespace_id`.
+
 ```sql
 USE <namespace_name>;
 USE NAMESPACE <namespace_name>;
@@ -193,14 +197,14 @@ FROM [<namespace>.]<table_name>
 [LIMIT <n>];
 ```
 
-## Execute As User
+## Execute As
 
-`EXECUTE AS USER` syntax is wrapper-only. It switches USER-table or
+`EXECUTE AS` syntax is wrapper-only. It switches USER-table or
 STREAM-table execution to a target user ID only when the authenticated actor
 role is allowed to target that ID's cached role class.
 
 ```sql
-EXECUTE AS USER '<username>' (
+EXECUTE AS '<user_id>' (
   <single_statement>
 );
 ```
@@ -208,7 +212,7 @@ EXECUTE AS USER '<username>' (
 Examples:
 
 ```sql
-EXECUTE AS USER 'alice' (
+EXECUTE AS 'user_123' (
   SELECT * FROM app.messages WHERE conversation_id = 42
 );
 ```
@@ -216,11 +220,11 @@ EXECUTE AS USER 'alice' (
 Rules:
 
 1. The wrapper must contain exactly one SQL statement.
-2. Username must be single-quoted.
+2. The target user ID must be single-quoted.
 3. System users may target system, dba, service, and user accounts.
 4. DBA users may target dba, service, and user accounts.
 5. Service users may target service and user accounts.
-6. Regular users may only use self-targeted `EXECUTE AS USER` as a no-op identity boundary.
+6. Regular users may only use self-targeted `EXECUTE AS '<user_id>'` as a no-op identity boundary.
 7. The wrapper is valid for USER and STREAM tables; shared tables use their table policy directly.
 8. Target role checks are hot-path cached: service, DBA, and system user IDs are tracked in memory from `system.users`; soft-deleted privileged IDs stay classified by their persisted role, and target IDs not present in that privileged cache are treated as regular users.
 9. Legacy inline `... AS USER 'name'` syntax is not supported.
@@ -233,7 +237,9 @@ Rules:
 CREATE USER '<username>'
   WITH <PASSWORD '<password>' | OAUTH | INTERNAL>
   ROLE <user|service|dba|system>
-  [EMAIL '<email>'];
+  [EMAIL '<email>']
+  [STORAGE_MODE <table|region>]
+  [STORAGE_ID '<storage_id>'];
 ```
 
 ### ALTER USER
@@ -242,6 +248,9 @@ CREATE USER '<username>'
 ALTER USER '<username>' SET PASSWORD '<new_password>';
 ALTER USER '<username>' SET ROLE <user|service|dba|system>;
 ALTER USER '<username>' SET EMAIL '<new_email>';
+ALTER USER '<username>' SET STORAGE_MODE <table|region>;
+ALTER USER '<username>' SET STORAGE_ID '<storage_id>';
+ALTER USER '<username>' SET STORAGE_ID NULL;
 ```
 
 ### DROP USER
@@ -444,27 +453,44 @@ CLUSTER CLEAR;
 
 ## Backup / Restore Commands
 
-### BACKUP DATABASE
+### EXPORT USER DATA
 
 ```sql
-BACKUP DATABASE <namespace> TO '<backup_path>';
-BACKUP DATABASE IF EXISTS <namespace> TO '<backup_path>';
+EXPORT USER DATA;
 ```
 
-### RESTORE DATABASE
+### SHOW EXPORT
+
+```sql
+SHOW EXPORT;
+```
+
+`SHOW EXPORT` returns a `download_url` URI path such as
+`/v1/exports/<user_id>/<export_id>`. Prefix it with your KalamDB server base URL
+when downloading the finished ZIP over HTTP.
+
+### BACKUP DATABASE
 
 ```sql
-RESTORE DATABASE <namespace> FROM '<backup_path>';
-RESTORE DATABASE IF NOT EXISTS <namespace> FROM '<backup_path>';
+BACKUP DATABASE TO '<backup_path>';
 ```
 
-### SHOW BACKUP
+`<backup_path>` is a path on the server filesystem. If it ends with `.tar.gz`
+or `.tgz`, KalamDB writes a single archive file there. Otherwise it writes the
+backup directory layout directly under that path. `BACKUP DATABASE` requires a
+DBA or System role.
+
+### RESTORE DATABASE
 
 ```sql
-SHOW BACKUP FOR DATABASE <namespace>;
-SHOW BACKUPS FOR DATABASE <namespace>;
+RESTORE DATABASE FROM '<backup_path>';
 ```
 
+`<backup_path>` is a path on the server filesystem and may point to either a
+backup directory or a `.tar.gz` / `.tgz` archive created by `BACKUP DATABASE`.
+The restore job stages the files, and a server restart is required to activate
+the restored data. `RESTORE DATABASE` requires a DBA or System role.
+
 ## Built-in Functions (Common)
 
 ```sql
diff --git a/docs/reference/storage-id-usage.md b/docs/reference/storage-id-usage.md
index c0ce6c5e..085d4dc1 100644
--- a/docs/reference/storage-id-usage.md
+++ b/docs/reference/storage-id-usage.md
@@ -117,19 +117,26 @@ Important rules:
 - `STORAGE_ID` is still the fallback storage for the table.
 - User preference fields exist in `system.users` (`storage_mode`, `storage_id`).
 
-## 5) Changing storage per user (current status)
+## 5) Changing storage per user
 
-Today, SQL DML against `system.*` tables is blocked, and `ALTER USER` currently supports only:
-- `SET PASSWORD`
-- `SET ROLE`
-- `SET EMAIL`
+Use `CREATE USER` or `ALTER USER` to set per-user storage preferences without writing directly to `system.users`:
 
-That means there is currently no public SQL command to change a user's `storage_mode` / `storage_id` directly.
+```sql
+CREATE USER 'alice'
+    WITH PASSWORD 'SecurePass123!'
+    ROLE user
+    STORAGE_MODE region
+    STORAGE_ID 's3_eu';
+
+ALTER USER 'alice' SET STORAGE_MODE table;
+ALTER USER 'alice' SET STORAGE_ID 'local';
+ALTER USER 'alice' SET STORAGE_ID NULL;
+```
 
-Current developer workflow:
-- Decide table-level routing with `STORAGE_ID` (+ optional `USE_USER_STORAGE`).
-- For user-level storage overrides, use internal/admin backend flows that update user records, not direct SQL updates.
-- Track progress and limitations in [docs/development/user-table-storage.md](../development/user-table-storage.md).
+Notes:
+- `STORAGE_MODE` accepts `table` or `region`.
+- `STORAGE_ID` must reference an existing row in `system.storages`.
+- `SET STORAGE_ID NULL` clears the stored preference while preserving the current `storage_mode`.
 
 ## 6) Common failures
 
diff --git a/link/kalam-client/LICENSE b/link/kalam-client/LICENSE
new file mode 100644
index 00000000..af6a5982
--- /dev/null
+++ b/link/kalam-client/LICENSE
@@ -0,0 +1,3 @@
+Apache-2.0
+
+See ../../LICENSE.txt for the full repository license text.
\ No newline at end of file
diff --git a/link/kalam-client/tests/proxied/topic_consumption_netem.rs b/link/kalam-client/tests/proxied/topic_consumption_netem.rs
index be985df5..0b0c35a3 100644
--- a/link/kalam-client/tests/proxied/topic_consumption_netem.rs
+++ b/link/kalam-client/tests/proxied/topic_consumption_netem.rs
@@ -193,7 +193,7 @@ fn records_with_op<'a>(records: &'a [ConsumerRecord], op: TopicOp) -> Vec<&'a Co
 }
 
 #[tokio::test]
-#[ntest::timeout(10000)]
+#[ntest::timeout(15000)]
 async fn test_tokio_netem_topic_consume_fragmented_insert_update_delete_and_commit() {
     let result = timeout(Duration::from_secs(60), async {
         let writer = match create_test_client() {
@@ -308,7 +308,7 @@ async fn test_tokio_netem_topic_consume_fragmented_insert_update_delete_and_comm
 }
 
 #[tokio::test]
-#[ntest::timeout(17000)]
+#[ntest::timeout(30000)]
 async fn test_tokio_netem_topic_bandwidth_collapse_poll_recovers_without_losing_offsets() {
     let result = timeout(Duration::from_secs(75), async {
         let writer = match create_test_client() {
@@ -393,7 +393,7 @@ async fn test_tokio_netem_topic_bandwidth_collapse_poll_recovers_without_losing_
 }
 
 #[tokio::test]
-#[ntest::timeout(10000)]
+#[ntest::timeout(15000)]
 async fn test_tokio_netem_topic_commit_failure_can_be_retried_without_replay() {
     let result = timeout(Duration::from_secs(75), async {
         let writer = match create_test_client() {
diff --git a/link/kalam-client/tests/proxied/transport_impairments.rs b/link/kalam-client/tests/proxied/transport_impairments.rs
index 089f19da..4f18a20e 100644
--- a/link/kalam-client/tests/proxied/transport_impairments.rs
+++ b/link/kalam-client/tests/proxied/transport_impairments.rs
@@ -454,7 +454,7 @@ async fn test_proxy_packet_loss_style_stalls_resume_without_replay() {
 /// Very small write slices fragment WebSocket frames at the transport boundary.
 /// The client should parse the stream normally and avoid spurious reconnects.
 #[tokio::test]
-#[ntest::timeout(8000)]
+#[ntest::timeout(15000)]
 async fn test_tokio_netem_fragmented_writes_preserve_live_stream() {
     let result = timeout(Duration::from_secs(45), async {
         let writer = match create_test_client() {
@@ -547,7 +547,7 @@ async fn test_tokio_netem_fragmented_writes_preserve_live_stream() {
 /// the throttle is removed, reconnect resume must deliver only rows after the
 /// checkpoint.
 #[tokio::test]
-#[ntest::timeout(16000)]
+#[ntest::timeout(30000)]
 async fn test_tokio_netem_bandwidth_collapse_forces_resume_without_replay() {
     let result = timeout(Duration::from_secs(75), async {
         let writer = match create_test_client() {
@@ -680,7 +680,7 @@ async fn test_tokio_netem_bandwidth_collapse_forces_resume_without_replay() {
 /// tokio-netem can fail the transport from inside the I/O adapter instead of
 /// aborting the proxy task. The client should treat it as a normal disconnect.
 #[tokio::test]
-#[ntest::timeout(10000)]
+#[ntest::timeout(15000)]
 async fn test_tokio_netem_forced_transport_termination_recovers() {
     let result = timeout(Duration::from_secs(75), async {
         let writer = match create_test_client() {
diff --git a/link/link-common/src/subscription/live_rows_config.rs b/link/link-common/src/subscription/live_rows_config.rs
index cc2b517a..d3d92d1c 100644
--- a/link/link-common/src/subscription/live_rows_config.rs
+++ b/link/link-common/src/subscription/live_rows_config.rs
@@ -25,11 +25,13 @@ impl LiveRowsConfig {
                     continue;
                 }
 
-                if normalized.iter().any(|existing| existing == trimmed) {
+                let normalized_column = trimmed.to_ascii_lowercase();
+
+                if normalized.iter().any(|existing| existing == &normalized_column) {
                     continue;
                 }
 
-                normalized.push(trimmed.to_owned());
+                normalized.push(normalized_column);
             }
         }
 
diff --git a/link/link-common/src/subscription/live_rows_materializer.rs b/link/link-common/src/subscription/live_rows_materializer.rs
index c89a2002..af00bbd6 100644
--- a/link/link-common/src/subscription/live_rows_materializer.rs
+++ b/link/link-common/src/subscription/live_rows_materializer.rs
@@ -137,9 +137,17 @@ impl LiveRowsMaterializer {
     }
 }
 
+fn row_value_by_column<'a>(row: &'a RowData, column: &str) -> Option<&'a KalamCellValue> {
+    row.get(column).or_else(|| {
+        row.iter()
+            .find(|(key, _)| key.eq_ignore_ascii_case(column))
+            .map(|(_, value)| value)
+    })
+}
+
 fn rows_match_on_key_columns(left: &RowData, right: &RowData, key_columns: &[String]) -> bool {
     for column in key_columns {
-        match (left.get(column), right.get(column)) {
+        match (row_value_by_column(left, column), row_value_by_column(right, column)) {
             (Some(KalamCellValue(left_value)), Some(KalamCellValue(right_value)))
                 if left_value == right_value => {},
             _ => return false,
@@ -327,6 +335,40 @@ mod tests {
         }
     }
 
+    #[test]
+    fn matches_key_columns_case_insensitively() {
+        fn row_with_key(column_name: &str, id: &str, value: &str) -> RowData {
+            let mut row = RowData::new();
+            row.insert(column_name.to_string(), KalamCellValue::text(id));
+            row.insert("value".to_string(), KalamCellValue::text(value));
+            row
+        }
+
+        let mut materializer = LiveRowsMaterializer::new(LiveRowsConfig::default());
+
+        let _ = materializer.apply(ChangeEvent::InitialDataBatch {
+            subscription_id: "sub-4".to_string(),
+            rows: vec![row_with_key("ID", "1", "one")],
+            batch_control: batch_control(BatchStatus::Ready),
+        });
+
+        let updated = materializer
+            .apply(ChangeEvent::Update {
+                subscription_id: "sub-4".to_string(),
+                rows: vec![row_with_key("id", "1", "updated")],
+                old_rows: vec![row_with_key("ID", "1", "one")],
+            })
+            .expect("update should emit");
+
+        match updated {
+            LiveRowsEvent::Rows { rows, .. } => {
+                assert_eq!(rows.len(), 1);
+                assert_eq!(rows[0].get("value").and_then(KalamCellValue::as_text), Some("updated"));
+            },
+            other => panic!("unexpected event: {:?}", other),
+        }
+    }
+
     #[test]
     fn emits_empty_snapshot_for_empty_ready_ack() {
         let mut materializer = LiveRowsMaterializer::new(LiveRowsConfig::default());
diff --git a/link/sdks/typescript/consumer/package-lock.json b/link/sdks/typescript/consumer/package-lock.json
index fd7ddc03..962d842d 100644
--- a/link/sdks/typescript/consumer/package-lock.json
+++ b/link/sdks/typescript/consumer/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@kalamdb/consumer",
-  "version": "0.4.2-rc.3",
+  "version": "0.4.3-rc.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@kalamdb/consumer",
-      "version": "0.4.2-rc.3",
+      "version": "0.4.3-rc.4",
       "license": "Apache-2.0",
       "devDependencies": {
         "@types/node": "^25.5.0",
diff --git a/link/sdks/typescript/orm/package-lock.json b/link/sdks/typescript/orm/package-lock.json
index a39752ff..a33255af 100644
--- a/link/sdks/typescript/orm/package-lock.json
+++ b/link/sdks/typescript/orm/package-lock.json
@@ -15,7 +15,7 @@
         "@kalamdb/client": "file:../client",
         "@kalamdb/consumer": "file:../consumer",
         "@types/node": "^25.5.2",
-        "drizzle-orm": "^0.41.0",
+        "drizzle-orm": "^0.45.2",
         "typescript": "^5.8.0"
       },
       "engines": {
@@ -23,7 +23,7 @@
       },
       "peerDependencies": {
         "@kalamdb/client": ">=0.4.0",
-        "drizzle-orm": ">=0.36.0"
+        "drizzle-orm": ">=0.45.2"
       }
     },
     "../client": {
@@ -77,9 +77,9 @@
       }
     },
     "node_modules/drizzle-orm": {
-      "version": "0.41.0",
-      "resolved": "https://registry.npmjs.org/drizzle-orm/-/drizzle-orm-0.41.0.tgz",
-      "integrity": "sha512-7A4ZxhHk9gdlXmTdPj/lREtP+3u8KvZ4yEN6MYVxBzZGex5Wtdc+CWSbu7btgF6TB0N+MNPrvW7RKBbxJchs/Q==",
+      "version": "0.45.2",
+      "resolved": "https://registry.npmjs.org/drizzle-orm/-/drizzle-orm-0.45.2.tgz",
+      "integrity": "sha512-kY0BSaTNYWnoDMVoyY8uxmyHjpJW1geOmBMdSSicKo9CIIWkSxMIj2rkeSR51b8KAPB7m+qysjuHme5nKP+E5Q==",
       "dev": true,
       "license": "Apache-2.0",
       "peerDependencies": {
@@ -91,12 +91,13 @@
         "@neondatabase/serverless": ">=0.10.0",
         "@op-engineering/op-sqlite": ">=2",
         "@opentelemetry/api": "^1.4.1",
-        "@planetscale/database": ">=1",
+        "@planetscale/database": ">=1.13",
         "@prisma/client": "*",
         "@tidbcloud/serverless": "*",
         "@types/better-sqlite3": "*",
         "@types/pg": "*",
         "@types/sql.js": "*",
+        "@upstash/redis": ">=1.34.7",
         "@vercel/postgres": ">=0.8.0",
         "@xata.io/client": "*",
         "better-sqlite3": ">=7",
@@ -154,6 +155,9 @@
         "@types/sql.js": {
           "optional": true
         },
+        "@upstash/redis": {
+          "optional": true
+        },
         "@vercel/postgres": {
           "optional": true
         },
diff --git a/link/sdks/typescript/orm/package.json b/link/sdks/typescript/orm/package.json
index 1313d622..721e7362 100644
--- a/link/sdks/typescript/orm/package.json
+++ b/link/sdks/typescript/orm/package.json
@@ -42,13 +42,13 @@
   },
   "peerDependencies": {
     "@kalamdb/client": ">=0.4.0",
-    "drizzle-orm": ">=0.36.0"
+    "drizzle-orm": ">=0.45.2"
   },
   "devDependencies": {
     "@kalamdb/client": "file:../client",
     "@kalamdb/consumer": "file:../consumer",
     "@types/node": "^25.5.2",
-    "drizzle-orm": "^0.41.0",
+    "drizzle-orm": "^0.45.2",
     "typescript": "^5.8.0"
   },
   "keywords": [
diff --git a/ui/index.html b/ui/index.html
index 74036318..4feace35 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -8,7 +8,6 @@
   </head>
   <body>
     <div id="root"></div>
-    <script src="%BASE_URL%runtime-config.js"></script>
     <script type="module" src="/src/main.tsx"></script>
   </body>
 </html>
diff --git a/ui/package-lock.json b/ui/package-lock.json
index 6d42ddd9..f7ebc7e6 100644
--- a/ui/package-lock.json
+++ b/ui/package-lock.json
@@ -87,7 +87,7 @@
         "@kalamdb/client": "file:../client",
         "@kalamdb/consumer": "file:../consumer",
         "@types/node": "^25.5.2",
-        "drizzle-orm": "^0.41.0",
+        "drizzle-orm": "^0.45.2",
         "typescript": "^5.8.0"
       },
       "engines": {
@@ -95,7 +95,7 @@
       },
       "peerDependencies": {
         "@kalamdb/client": ">=0.4.0",
-        "drizzle-orm": ">=0.36.0"
+        "drizzle-orm": ">=0.45.2"
       }
     },
     "node_modules/@adobe/css-tools": {
diff --git a/ui/src/components/sql-preview/SqlPreviewDialog.tsx b/ui/src/components/sql-preview/SqlPreviewDialog.tsx
index d45478e1..ba030e1e 100644
--- a/ui/src/components/sql-preview/SqlPreviewDialog.tsx
+++ b/ui/src/components/sql-preview/SqlPreviewDialog.tsx
@@ -396,7 +396,7 @@ export function SqlPreviewDialog({ open, options, onClose }: SqlPreviewDialogPro
 
   return (
     <Dialog open={open} onOpenChange={(isOpen) => { if (!isOpen) handleCancel(); }}>
-      <DialogContent className="flex h-[85vh] max-h-[90vh] max-w-5xl flex-col gap-0 overflow-hidden p-0">
+      <DialogContent className="flex h-[85vh] max-h-[90vh] sm:max-w-5xl flex-col gap-0 overflow-hidden p-0">
         <DialogHeader className="border-b px-6 pb-4 pt-6">
           <DialogTitle className="text-lg">
             {options?.title ?? 'SQL Preview'}
diff --git a/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.test.tsx b/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.test.tsx
index 4cb422c6..cb897adb 100644
--- a/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.test.tsx
+++ b/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.test.tsx
@@ -79,5 +79,6 @@ describe("StudioExecutionLog", () => {
     fireEvent.click(timelineButtons[0]);
 
     expect(within(details as HTMLElement).getByText(/select id, name from default.events/i)).toBeTruthy();
+    expect(screen.queryByRole("dialog")).toBeNull();
   });
 });
\ No newline at end of file
diff --git a/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.tsx b/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.tsx
index 4aef80f2..eaf49aa2 100644
--- a/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.tsx
+++ b/ui/src/components/sql-studio-v2/preview/logs/StudioExecutionLog.tsx
@@ -3,13 +3,6 @@ import type { LucideIcon } from "lucide-react";
 import { AlertCircle, ArrowDown, ArrowUp, CheckCircle2, Info } from "lucide-react";
 import { Badge } from "@/components/ui/badge";
 import { CodeBlock } from "@/components/ui/code-block";
-import {
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogHeader,
-  DialogTitle,
-} from "@/components/ui/dialog";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { cn } from "@/lib/utils";
 import type { QueryLogEntry } from "../../shared/types";
@@ -225,11 +218,9 @@ function describeFlow(kind: LogEntryKind): string {
 export function StudioExecutionLog({ logs, status }: StudioExecutionLogProps) {
   const [selectedLogId, setSelectedLogId] = useState<string | null>(null);
   const previousLastLogIdRef = useRef<string | null>(null);
-  const [detailModalId, setDetailModalId] = useState<string | null>(null);
 
   const handleSelectLog = (id: string) => {
     setSelectedLogId(id);
-    setDetailModalId(id);
   };
 
   const decoratedLogs = useMemo(
@@ -392,35 +383,6 @@ export function StudioExecutionLog({ logs, status }: StudioExecutionLogProps) {
             <CodeBlock value={selectedEntry.payload} jsonPreferred maxHeightClassName="h-full max-h-full" />
           </div>
       </section>
-
-      {(() => {
-        const modalEntry = detailModalId
-          ? decoratedLogs.find((item) => item.entry.id === detailModalId)
-          : null;
-        return (
-          <Dialog open={!!modalEntry} onOpenChange={(o) => !o && setDetailModalId(null)}>
-            <DialogContent className="flex max-h-[85vh] max-w-3xl flex-col overflow-hidden">
-              <DialogHeader>
-                <DialogTitle className="flex items-center gap-2 font-mono text-sm">
-                  {modalEntry?.label} • {modalEntry?.title}
-                </DialogTitle>
-                <DialogDescription>
-                  Full payload for the selected event.
-                </DialogDescription>
-              </DialogHeader>
-              <div className="min-h-0 flex-1 overflow-hidden">
-                {modalEntry && (
-                  <CodeBlock
-                    value={modalEntry.payload}
-                    jsonPreferred
-                    maxHeightClassName="h-full max-h-full"
-                  />
-                )}
-              </div>
-            </DialogContent>
-          </Dialog>
-        );
-      })()}
     </div>
   );
 }
diff --git a/ui/src/components/storages/StorageForm.tsx b/ui/src/components/storages/StorageForm.tsx
index b3cf803f..09580386 100644
--- a/ui/src/components/storages/StorageForm.tsx
+++ b/ui/src/components/storages/StorageForm.tsx
@@ -2,6 +2,7 @@ import { useEffect, useMemo, useState } from "react";
 import { AlertCircle, Cloud, Database, HardDrive, Loader2 } from "lucide-react";
 import { useCreateStorageMutation, useUpdateStorageMutation } from "@/store/apiSlice";
 import type { Storage } from "@/services/storageService";
+import { getErrorMessage } from "@/lib/errors";
 import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -202,7 +203,7 @@ export function StorageForm({ open, onOpenChange, storage, onSuccess }: StorageF
       onSuccess();
       onOpenChange(false);
     } catch (submitError) {
-      setError(submitError instanceof Error ? submitError.message : "Failed to save storage");
+      setError(getErrorMessage(submitError, "Failed to save storage"));
     } finally {
       setIsSubmitting(false);
     }
diff --git a/ui/src/components/ui/dialog.tsx b/ui/src/components/ui/dialog.tsx
index 63de5143..2e0a1070 100644
--- a/ui/src/components/ui/dialog.tsx
+++ b/ui/src/components/ui/dialog.tsx
@@ -61,7 +61,7 @@ function DialogContent({
       <DialogPrimitive.Content
         data-slot="dialog-content"
         className={cn(
-          "fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-popover p-4 text-xs/relaxed text-popover-foreground ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+          "fixed top-1/2 left-1/2 z-50 grid w-full max-w-[calc(100%-2rem)] -translate-x-1/2 -translate-y-1/2 gap-4 rounded-xl bg-popover p-4 text-xs/relaxed text-popover-foreground ring-1 ring-foreground/10 duration-100 outline-none sm:max-w-lg data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
           className
         )}
         {...props}
diff --git a/ui/src/components/ui/switch.tsx b/ui/src/components/ui/switch.tsx
index 1ca9db2a..a03e1539 100644
--- a/ui/src/components/ui/switch.tsx
+++ b/ui/src/components/ui/switch.tsx
@@ -12,19 +12,26 @@ function Switch({
 }: React.ComponentProps<typeof SwitchPrimitive.Root> & {
   size?: "sm" | "default"
 }) {
+  const isSmall = size === "sm"
+
   return (
     <SwitchPrimitive.Root
       data-slot="switch"
-      data-size={size}
       className={cn(
-        "peer group/switch relative inline-flex shrink-0 items-center rounded-full border border-transparent transition-all outline-none after:absolute after:-inset-x-3 after:-inset-y-2 focus-visible:border-ring focus-visible:ring-2 focus-visible:ring-ring/30 aria-invalid:border-destructive aria-invalid:ring-2 aria-invalid:ring-destructive/20 data-[size=default]:h-[16.6px] data-[size=default]:w-[28px] data-[size=sm]:h-[14px] data-[size=sm]:w-[24px] dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 data-checked:bg-primary data-unchecked:bg-input dark:data-unchecked:bg-input/80 data-disabled:cursor-not-allowed data-disabled:opacity-50",
+        "peer inline-flex shrink-0 items-center rounded-full border-2 border-transparent shadow-sm transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input dark:data-[state=unchecked]:bg-input/80",
+        isSmall ? "h-4 w-7" : "h-5 w-9",
         className
       )}
       {...props}
     >
       <SwitchPrimitive.Thumb
         data-slot="switch-thumb"
-        className="pointer-events-none block rounded-full bg-background ring-0 transition-transform group-data-[size=default]/switch:size-3.5 group-data-[size=sm]/switch:size-3 group-data-[size=default]/switch:data-checked:translate-x-[calc(100%-2px)] group-data-[size=sm]/switch:data-checked:translate-x-[calc(100%-2px)] dark:data-checked:bg-primary-foreground group-data-[size=default]/switch:data-unchecked:translate-x-0 group-data-[size=sm]/switch:data-unchecked:translate-x-0 dark:data-unchecked:bg-foreground"
+        className={cn(
+          "pointer-events-none block rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=unchecked]:translate-x-0",
+          isSmall
+            ? "h-3 w-3 data-[state=checked]:translate-x-3"
+            : "h-4 w-4 data-[state=checked]:translate-x-4"
+        )}
       />
     </SwitchPrimitive.Root>
   )
diff --git a/ui/src/components/users/DeleteUserDialog.tsx b/ui/src/components/users/DeleteUserDialog.tsx
index 2fb47654..e0a0fd9e 100644
--- a/ui/src/components/users/DeleteUserDialog.tsx
+++ b/ui/src/components/users/DeleteUserDialog.tsx
@@ -8,6 +8,7 @@ import {
   DialogTitle,
 } from '@/components/ui/dialog';
 import { Button } from '@/components/ui/button';
+import { getErrorMessage } from '@/lib/errors';
 import type { User } from '@/services/userService';
 import { Loader2, AlertTriangle } from 'lucide-react';
 
@@ -34,7 +35,7 @@ export function DeleteUserDialog({
       await onConfirm();
       onOpenChange(false);
     } catch (err) {
-      setError(err instanceof Error ? err.message : 'Failed to delete user');
+      setError(getErrorMessage(err, 'Failed to delete user'));
     } finally {
       setIsDeleting(false);
     }
diff --git a/ui/src/components/users/UserForm.tsx b/ui/src/components/users/UserForm.tsx
index f1a90898..3d75c2a7 100644
--- a/ui/src/components/users/UserForm.tsx
+++ b/ui/src/components/users/UserForm.tsx
@@ -3,6 +3,7 @@ import { AlertCircle, Loader2 } from "lucide-react";
 import { useCreateUserMutation, useGetStoragesQuery, useUpdateUserMutation } from "@/store/apiSlice";
 import type { User } from "@/services/userService";
 import { formatTimestamp } from "@/lib/formatters";
+import { getErrorMessage } from "@/lib/errors";
 import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -189,7 +190,6 @@ export function UserForm({ open, onOpenChange, user, onSuccess }: UserFormProps)
         if (normalizedStorageId !== (user.storage_id ?? null)) {
           updateInput.storage_id = normalizedStorageId;
         }
-
         await updateUserMutation({ username: user.user_id, input: updateInput }).unwrap();
       } else {
         await createUserMutation({
@@ -207,7 +207,7 @@ export function UserForm({ open, onOpenChange, user, onSuccess }: UserFormProps)
       onSuccess();
       onOpenChange(false);
     } catch (submitError) {
-      setError(submitError instanceof Error ? submitError.message : "Failed to save user");
+      setError(getErrorMessage(submitError, "Failed to save user"));
     } finally {
       setIsSubmitting(false);
     }
diff --git a/ui/src/lib/errors.test.ts b/ui/src/lib/errors.test.ts
new file mode 100644
index 00000000..458e2637
--- /dev/null
+++ b/ui/src/lib/errors.test.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { getErrorMessage } from "@/lib/errors";
+
+describe("getErrorMessage", () => {
+  it("returns the RTK custom error message used by unwrap rejections", () => {
+    expect(
+      getErrorMessage(
+        { status: "CUSTOM_ERROR", error: "Statement 1 failed: Invalid operation" },
+        "fallback",
+      ),
+    ).toBe("Statement 1 failed: Invalid operation");
+  });
+
+  it("includes nested backend details when present", () => {
+    expect(
+      getErrorMessage(
+        {
+          data: {
+            error: {
+              message: "Statement 1 failed: Invalid operation",
+              details: "UPDATE system.users SET storage_mode = 'table'",
+            },
+          },
+        },
+        "fallback",
+      ),
+    ).toBe(
+      "Statement 1 failed: Invalid operation\nUPDATE system.users SET storage_mode = 'table'",
+    );
+  });
+});
\ No newline at end of file
diff --git a/ui/src/lib/errors.ts b/ui/src/lib/errors.ts
new file mode 100644
index 00000000..b9c1b4ce
--- /dev/null
+++ b/ui/src/lib/errors.ts
@@ -0,0 +1,65 @@
+interface CustomQueryError {
+  status?: string;
+  error?: unknown;
+  data?: unknown;
+  message?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function appendDetails(message: string, details: unknown): string {
+  if (typeof details !== "string") {
+    return message;
+  }
+
+  const trimmedDetails = details.trim();
+  if (!trimmedDetails || message.includes(trimmedDetails)) {
+    return message;
+  }
+
+  return `${message}\n${trimmedDetails}`;
+}
+
+export function getErrorMessage(error: unknown, fallback: string): string {
+  if (typeof error === "string") {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    return error.message || fallback;
+  }
+
+  if (isRecord(error)) {
+    const customError = error as CustomQueryError;
+
+    if (typeof customError.error === "string") {
+      return customError.error;
+    }
+
+    if (isRecord(customError.error)) {
+      const nestedError = customError.error as Record<string, unknown>;
+      if (typeof nestedError.message === "string") {
+        return appendDetails(nestedError.message, nestedError.details);
+      }
+    }
+
+    if (isRecord(customError.data)) {
+      const data = customError.data as Record<string, unknown>;
+      if (typeof data.message === "string") {
+        return appendDetails(data.message, data.details);
+      }
+      if (isRecord(data.error) && typeof data.error.message === "string") {
+        const nestedError = data.error as Record<string, unknown>;
+        return appendDetails(nestedError.message as string, nestedError.details);
+      }
+    }
+
+    if (typeof customError.message === "string") {
+      return customError.message;
+    }
+  }
+
+  return fallback;
+}
\ No newline at end of file
diff --git a/ui/src/services/sql/queries/userQueries.ts b/ui/src/services/sql/queries/userQueries.ts
index 69bdfec0..1dfd7341 100644
--- a/ui/src/services/sql/queries/userQueries.ts
+++ b/ui/src/services/sql/queries/userQueries.ts
@@ -46,6 +46,12 @@ export function buildCreateUserSql(input: CreateUserInput): string {
   if (input.email?.trim()) {
     sql += ` EMAIL '${escapeSqlLiteral(input.email.trim())}'`;
   }
+  if (input.storage_mode) {
+    sql += ` STORAGE_MODE '${escapeSqlLiteral(input.storage_mode)}'`;
+  }
+  if (input.storage_id?.trim()) {
+    sql += ` STORAGE_ID '${escapeSqlLiteral(input.storage_id.trim())}'`;
+  }
   return sql;
 }
 
@@ -61,35 +67,22 @@ export function buildUpdateUserEmailSql(username: string, email: string): string
   return `ALTER USER '${escapeSqlLiteral(username)}' SET EMAIL '${escapeSqlLiteral(email)}'`;
 }
 
-export function buildUpdateUserStorageSql(
+export function buildUpdateUserStorageModeSql(
   username: string,
-  storageMode: "table" | "region" | null | undefined,
-  storageId: string | null | undefined,
-): string | null {
-  const setClauses: string[] = [];
-
-  if (storageMode !== undefined) {
-    setClauses.push(
-      storageMode === null
-        ? "storage_mode = NULL"
-        : `storage_mode = '${escapeSqlLiteral(storageMode)}'`,
-    );
-  }
-
-  if (storageId !== undefined) {
-    const normalizedStorageId = storageId?.trim() ?? "";
-    setClauses.push(
-      normalizedStorageId.length === 0
-        ? "storage_id = NULL"
-        : `storage_id = '${escapeSqlLiteral(normalizedStorageId)}'`,
-    );
-  }
+  storageMode: "table" | "region",
+): string {
+  return `ALTER USER '${escapeSqlLiteral(username)}' SET STORAGE_MODE '${escapeSqlLiteral(storageMode)}'`;
+}
 
-  if (setClauses.length === 0) {
-    return null;
+export function buildUpdateUserStorageIdSql(
+  username: string,
+  storageId: string | null,
+): string {
+  if (storageId === null) {
+    return `ALTER USER '${escapeSqlLiteral(username)}' SET STORAGE_ID NULL`;
   }
 
-  return `UPDATE system.users SET ${setClauses.join(", ")} WHERE user_id = '${escapeSqlLiteral(username)}'`;
+  return `ALTER USER '${escapeSqlLiteral(username)}' SET STORAGE_ID '${escapeSqlLiteral(storageId.trim())}'`;
 }
 
 export function buildDeleteUserSql(username: string): string {
diff --git a/ui/src/services/userService.test.ts b/ui/src/services/userService.test.ts
index 787993fc..11a95023 100644
--- a/ui/src/services/userService.test.ts
+++ b/ui/src/services/userService.test.ts
@@ -1,5 +1,16 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import type { User } from "@/services/userService";
+import { createUser, updateUser } from "@/services/userService";
+
+const executeSqlMock = vi.fn();
+
+vi.mock("@/lib/kalam-client", () => ({
+  executeSql: (sql: string) => executeSqlMock(sql),
+}));
+
+afterEach(() => {
+  executeSqlMock.mockReset();
+});
 
 describe("User type", () => {
   it("uses the schema-backed user_id field directly", () => {
@@ -22,4 +33,47 @@ describe("User type", () => {
 
     expect(user.user_id).toBe("root");
   });
+
+  it("creates users without issuing a direct system.users update", async () => {
+    executeSqlMock.mockResolvedValue([]);
+
+    await createUser({
+      username: "test2",
+      password: "Password123!",
+      role: "user",
+      storage_mode: "table",
+      storage_id: "local",
+    });
+
+    expect(executeSqlMock).toHaveBeenCalledTimes(1);
+    expect(executeSqlMock).toHaveBeenCalledWith(
+      "CREATE USER 'test2' WITH PASSWORD 'Password123!' ROLE 'user' STORAGE_MODE 'table' STORAGE_ID 'local'",
+    );
+  });
+
+  it("updates supported fields with alter-user storage statements", async () => {
+    executeSqlMock.mockResolvedValue([]);
+
+    await updateUser("test2", {
+      role: "dba",
+      storage_mode: "region",
+      storage_id: "archive",
+    });
+
+    expect(executeSqlMock).toHaveBeenCalledTimes(3);
+    expect(executeSqlMock).toHaveBeenNthCalledWith(1, "ALTER USER 'test2' SET ROLE 'dba'");
+    expect(executeSqlMock).toHaveBeenNthCalledWith(2, "ALTER USER 'test2' SET STORAGE_MODE 'region'");
+    expect(executeSqlMock).toHaveBeenNthCalledWith(3, "ALTER USER 'test2' SET STORAGE_ID 'archive'");
+  });
+
+  it("can clear a user storage id via alter user", async () => {
+    executeSqlMock.mockResolvedValue([]);
+
+    await updateUser("test2", {
+      storage_id: null,
+    });
+
+    expect(executeSqlMock).toHaveBeenCalledTimes(1);
+    expect(executeSqlMock).toHaveBeenCalledWith("ALTER USER 'test2' SET STORAGE_ID NULL");
+  });
 });
diff --git a/ui/src/services/userService.ts b/ui/src/services/userService.ts
index cd6d25cd..9a53982f 100644
--- a/ui/src/services/userService.ts
+++ b/ui/src/services/userService.ts
@@ -9,7 +9,8 @@ import {
   buildUpdateUserEmailSql,
   buildUpdateUserPasswordSql,
   buildUpdateUserRoleSql,
-  buildUpdateUserStorageSql,
+  buildUpdateUserStorageIdSql,
+  buildUpdateUserStorageModeSql,
   type CreateUserInput,
   type UpdateUserInput,
 } from "@/services/sql/queries/userQueries";
@@ -44,10 +45,6 @@ export async function fetchUsers(): Promise<User[]> {
 
 export async function createUser(input: CreateUserInput): Promise<void> {
   await executeSql(buildCreateUserSql(input));
-  const storageSql = buildUpdateUserStorageSql(input.username, input.storage_mode, input.storage_id);
-  if (storageSql) {
-    await executeSql(storageSql);
-  }
 }
 
 export async function updateUser(username: string, input: UpdateUserInput): Promise<void> {
@@ -60,9 +57,11 @@ export async function updateUser(username: string, input: UpdateUserInput): Prom
   if (input.email !== undefined) {
     await executeSql(buildUpdateUserEmailSql(username, input.email));
   }
-  const storageSql = buildUpdateUserStorageSql(username, input.storage_mode, input.storage_id);
-  if (storageSql) {
-    await executeSql(storageSql);
+  if (input.storage_mode !== undefined && input.storage_mode !== null) {
+    await executeSql(buildUpdateUserStorageModeSql(username, input.storage_mode));
+  }
+  if (input.storage_id !== undefined) {
+    await executeSql(buildUpdateUserStorageIdSql(username, input.storage_id));
   }
 }
 
diff --git a/ui/vite.config.ts b/ui/vite.config.ts
index 787792ce..ed4bf095 100644
--- a/ui/vite.config.ts
+++ b/ui/vite.config.ts
@@ -2,6 +2,7 @@ import { defineConfig, loadEnv } from "vite";
 import react from "@vitejs/plugin-react";
 import path from "path";
 import fs from "fs";
+import type { PluginOption } from "vite";
 
 function normalizeOrigin(url: string): string {
   return url.replace(/\/+$/, "");
@@ -36,6 +37,21 @@ const cleanupPlugin = () => ({
   }
 });
 
+const runtimeConfigScriptPlugin = (): PluginOption => ({
+  name: "runtime-config-script",
+  transformIndexHtml() {
+    return [
+      {
+        tag: "script",
+        attrs: {
+          src: "%BASE_URL%runtime-config.js",
+        },
+        injectTo: "body",
+      },
+    ];
+  },
+});
+
 // https://vite.dev/config/
 export default defineConfig(({ mode }) => {
   const env = loadEnv(mode, __dirname, "");
@@ -43,7 +59,7 @@ export default defineConfig(({ mode }) => {
   const backendWebSocketOrigin = toWebSocketOrigin(backendOrigin);
 
   return {
-    plugins: [react(), cleanupPlugin()],
+    plugins: [react(), cleanupPlugin(), runtimeConfigScriptPlugin()],
     // Base path for production build (embedded in server at /ui/)
     base: "/ui/",
     resolve: {
@@ -90,6 +106,7 @@ export default defineConfig(({ mode }) => {
       outDir: "dist",
       sourcemap: false,
       target: "esnext",
+      chunkSizeWarningLimit: 700,
       rollupOptions: {
         output: {
           // Ensure WASM files have consistent naming