diff --git a/cpp/src/file/read_file.cc b/cpp/src/file/read_file.cc
index ce1f67197..c494de478 100644
--- a/cpp/src/file/read_file.cc
+++ b/cpp/src/file/read_file.cc
@@ -94,6 +94,7 @@ void ReadFile::close() {
         fd_ = -1;
     }
     file_size_ = -1;
+    file_version_ = 0;
 }
 
 int ReadFile::open(const std::string& file_path) {
@@ -153,6 +154,20 @@ int ReadFile::check_file_magic() {
                    0) {
             ret = E_TSFILE_CORRUPTED;
         }
+        if (IS_FAIL(ret)) {
+            return ret;
+        }
+
+        char version = 0;
+        if (RET_FAIL(read(MAGIC_STRING_TSFILE_LEN, &version, 1, read_len))) {
+        } else if (read_len != 1 || version != VERSION_NUM_BYTE) {
+            ret = E_TSFILE_CORRUPTED;
+        } else {
+            file_version_ = static_cast<unsigned char>(version);
+        }
+        if (IS_FAIL(ret)) {
+            return ret;
+        }
 
         // file footer magic
         memset(buf, 0, MAGIC_STRING_TSFILE_LEN);
diff --git a/cpp/src/file/read_file.h b/cpp/src/file/read_file.h
index fbfe50a8b..9e3e958b7 100644
--- a/cpp/src/file/read_file.h
+++ b/cpp/src/file/read_file.h
@@ -31,7 +31,7 @@ namespace storage {
 
 class ReadFile {
    public:
-    ReadFile() : file_path_(), fd_(-1), file_size_(-1) {}
+    ReadFile() : file_path_(), fd_(-1), file_size_(-1), file_version_(0) {}
     ~ReadFile() { destroy(); }
     void destroy() { close(); }
 
@@ -39,6 +39,7 @@ class ReadFile {
     FORCE_INLINE bool is_opened() const { return fd_ > 0; }
     FORCE_INLINE int64_t file_size() const { return file_size_; }
     FORCE_INLINE const std::string& file_path() const { return file_path_; }
+    FORCE_INLINE unsigned char file_version() const { return file_version_; }
 
     /** Return size and the Dataset Index v1 FNV fingerprint of size+mtime_ns.
      */
@@ -64,6 +65,7 @@ class ReadFile {
     std::string file_path_;
     int fd_;
     int64_t file_size_;
+    unsigned char file_version_;
 };
 
 }  // end namespace storage
diff --git a/cpp/src/reader/filter/tag_filter.cc b/cpp/src/reader/filter/tag_filter.cc
index 03b8ae785..94c0749c4 100644
--- a/cpp/src/reader/filter/tag_filter.cc
+++ b/cpp/src/reader/filter/tag_filter.cc
@@ -115,7 +115,7 @@ bool TagRegExp::satisfyRow(std::vector<std::string*> segments) const {
         !is_valid_pattern_)
         return false;
     try {
-        return std::regex_search(*segments[col_idx_], pattern_);
+        return std::regex_match(*segments[col_idx_], pattern_);
     } catch (const std::regex_error&) {
         return false;
     }
@@ -137,7 +137,7 @@ bool TagNotRegExp::satisfyRow(std::vector<std::string*> segments) const {
         !is_valid_pattern_)
         return false;
     try {
-        return !std::regex_search(*segments[col_idx_], pattern_);
+        return !std::regex_match(*segments[col_idx_], pattern_);
     } catch (const std::regex_error&) {
         return true;
     }
@@ -332,4 +332,4 @@ int TagFilterBuilder::get_tag_column_index(const std::string& columnName) {
     return idColumnOrder + 1;
 }
 
-}  // namespace storage
\ No newline at end of file
+}  // namespace storage
diff --git a/cpp/src/reader/tsfile_reader.cc b/cpp/src/reader/tsfile_reader.cc
index 6e20b2d63..983a9ae95 100644
--- a/cpp/src/reader/tsfile_reader.cc
+++ b/cpp/src/reader/tsfile_reader.cc
@@ -127,6 +127,10 @@ int TsFileReader::open(const std::string& file_path) {
     return ret;
 }
 
+unsigned char TsFileReader::get_file_version() const {
+    return read_file_ == nullptr ? 0 : read_file_->file_version();
+}
+
 int TsFileReader::ensure_table_query_executor(int batch_size) {
     if (table_query_executor_ != nullptr &&
         table_query_executor_batch_size_ == batch_size) {
diff --git a/cpp/src/reader/tsfile_reader.h b/cpp/src/reader/tsfile_reader.h
index 7b817a18c..f07ef3679 100644
--- a/cpp/src/reader/tsfile_reader.h
+++ b/cpp/src/reader/tsfile_reader.h
@@ -63,6 +63,7 @@ class TsFileReader {
      * @return Returns 0 on success, or a non-zero error code on failure.
      */
     int close();
+    unsigned char get_file_version() const;
     /**
      * @brief query the tsfile by the query expression,Users can construct
      * their own query expressions to query tsfile
diff --git a/cpp/test/CMakeLists.txt b/cpp/test/CMakeLists.txt
index f2d671998..3c3da441b 100644
--- a/cpp/test/CMakeLists.txt
+++ b/cpp/test/CMakeLists.txt
@@ -286,6 +286,8 @@ if (VENDORED_GTEST_INCLUDE_DIRS)
 endif ()
 if (BUILD_TOOLS)
     target_include_directories(TsFile_Test PRIVATE ${CMAKE_SOURCE_DIR}/tools)
+    target_compile_definitions(TsFile_Test PRIVATE
+            TSFILE_CPP_SOURCE_DIR="${CMAKE_SOURCE_DIR}")
 endif ()
 if (APPLE AND NOT MSVC)
     target_compile_options(TsFile_Test PRIVATE -std=c++14)
diff --git a/cpp/test/reader/filter/tag_filter_test.cc b/cpp/test/reader/filter/tag_filter_test.cc
index 02ce64b85..0a218b7a4 100644
--- a/cpp/test/reader/filter/tag_filter_test.cc
+++ b/cpp/test/reader/filter/tag_filter_test.cc
@@ -406,9 +406,13 @@ TEST_F(TagFilterTest, TagRegExpEdgeCases) {
         invalid_filter->satisfyRow(0, segments));  // handles gracefully
     cleanupSegments(segments);
 
-    // Empty pattern matches everything
+    // Full-value matching means an empty pattern only matches an empty value.
     auto empty_filter = builder_->reg_exp("name", "");
     segments = createSegments("any", "25", "engineering", "active", "95");
+    EXPECT_FALSE(empty_filter->satisfyRow(0, segments));
+    cleanupSegments(segments);
+
+    segments = createSegments("", "25", "engineering", "active", "95");
     EXPECT_TRUE(empty_filter->satisfyRow(0, segments));
     cleanupSegments(segments);
 
@@ -497,4 +501,4 @@ TEST_F(TagFilterTest, TagIsNotNullFilter) {
 
     delete filter;
     delete trailing;
-}
\ No newline at end of file
+}
diff --git a/cpp/test/tools/cli_args_test.cc b/cpp/test/tools/cli_args_test.cc
index 42b7eb650..bbb6e050f 100644
--- a/cpp/test/tools/cli_args_test.cc
+++ b/cpp/test/tools/cli_args_test.cc
@@ -34,6 +34,34 @@ TEST(RunCliTest, VersionFlagPrintsVersionAndReturnsOk) {
     EXPECT_TRUE(err.str().empty());
 }
 
+TEST(RunCliTest, VersionMustAppearByItself) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code =
+        tsfile_cli::run_cli({"cat", "--version", "data.tsfile"}, out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("--version"), std::string::npos) << err.str();
+}
+
+TEST(RunCliTest, TopLevelHelpMustAppearByItself) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"--help", "cat"}, out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("--help"), std::string::npos) << err.str();
+}
+
+TEST(RunCliTest, CommandHelpMustAppearByItself) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"cat", "--help", "data.tsfile"}, out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("--help"), std::string::npos) << err.str();
+}
+
 TEST(RunCliTest, NoArgsPrintsUsageToErrAndReturnsUsageError) {
     std::ostringstream out;
     std::ostringstream err;
@@ -54,7 +82,7 @@ TEST(RunCliTest, LeadingOptionBeforeCommandIsClearError) {
     std::ostringstream out;
     std::ostringstream err;
     int code =
-        tsfile_cli::run_cli({"-f", "json", "meta", "data.tsfile"}, out, err);
+        tsfile_cli::run_cli({"-f", "ndjson", "meta", "data.tsfile"}, out, err);
     EXPECT_EQ(code, 1);
     EXPECT_NE(err.str().find("command must come before options"),
               std::string::npos)
@@ -69,14 +97,15 @@ TEST(ParseArgsTest, CommandAndFilePositional) {
 }
 
 TEST(ParseArgsTest, FormatFlagParsed) {
-    auto p = tsfile_cli::parse_args({"cat", "-f", "json", "data.tsfile"});
+    auto p = tsfile_cli::parse_args({"cat", "-f", "ndjson", "data.tsfile"});
     EXPECT_TRUE(p.error.empty());
     EXPECT_EQ(p.format, tsfile_cli::ParsedArgs::Format::kJson);
 }
 
-TEST(ParseArgsTest, MeasurementsSplitOnComma) {
-    auto p = tsfile_cli::parse_args({"cat", "-m", "s1,s2,s3", "data.tsfile"});
-    ASSERT_EQ(p.measurements.size(), 3u);
+TEST(ParseArgsTest, MeasurementsRepeatOneNamePerOption) {
+    auto p =
+        tsfile_cli::parse_args({"cat", "-m", "s1", "-m", "s2", "data.tsfile"});
+    ASSERT_EQ(p.measurements.size(), 2u);
     EXPECT_EQ(p.measurements[1], "s2");
 }
 
@@ -97,27 +126,24 @@ TEST(ParseArgsTest, TagFilterParsed) {
         {"cat", "--tag-filter", "id1", "eq", "dev_a", "data.tsfile"});
     EXPECT_TRUE(p.error.empty());
     EXPECT_TRUE(p.has_tag_filter);
-    EXPECT_EQ(p.tag_filter_op, tsfile_cli::ParsedArgs::TagFilterOp::kEq);
-    EXPECT_EQ(p.tag_filter_column, "id1");
-    EXPECT_EQ(p.tag_filter_value, "dev_a");
+    ASSERT_EQ(p.tag_filters.size(), 1u);
+    EXPECT_EQ(p.tag_filters[0].op, tsfile_cli::ParsedArgs::TagFilterOp::kEq);
+    EXPECT_EQ(p.tag_filters[0].column, "id1");
+    EXPECT_EQ(p.tag_filters[0].value, "dev_a");
 }
 
-TEST(ParseArgsTest, TagBetweenParsed) {
+TEST(ParseArgsTest, TagBetweenIsNotSupported) {
     auto p = tsfile_cli::parse_args(
         {"cat", "--tag-between", "id1", "dev_a", "dev_c", "data.tsfile"});
-    EXPECT_TRUE(p.error.empty());
-    EXPECT_TRUE(p.has_tag_filter);
-    EXPECT_EQ(p.tag_filter_op, tsfile_cli::ParsedArgs::TagFilterOp::kBetween);
-    EXPECT_EQ(p.tag_filter_column, "id1");
-    EXPECT_EQ(p.tag_filter_value, "dev_a");
-    EXPECT_EQ(p.tag_filter_value2, "dev_c");
+    EXPECT_FALSE(p.error.empty());
 }
 
 TEST(ParseArgsTest, DuplicateTagFilterIsError) {
     auto p = tsfile_cli::parse_args({"cat", "--tag-filter", "id1", "eq",
-                                     "dev_a", "--tag-between", "id1", "a", "z",
+                                     "dev_a", "--tag-filter", "id1", "neq", "z",
                                      "data.tsfile"});
-    EXPECT_FALSE(p.error.empty());
+    EXPECT_TRUE(p.error.empty());
+    ASSERT_EQ(p.tag_filters.size(), 2u);
 }
 
 TEST(ParseArgsTest, UnknownFlagIsError) {
@@ -138,9 +164,9 @@ TEST(ParseArgsTest, MissingFileIsAllowedAtParseTime) {
 }
 
 TEST(ParseArgsTest, WriteFlagsParsed) {
-    auto p = tsfile_cli::parse_args({"write", "--table", "t1", "--columns",
-                                     "s1:INT64:field", "-o", "out.tsfile", "-v",
-                                     "--header-match", "in.csv"});
+    auto p = tsfile_cli::parse_args({"write", "--table", "t1", "--field", "s1",
+                                     "INT64", "-i", "in.csv", "-o",
+                                     "out.tsfile", "-v", "--header-match"});
     EXPECT_TRUE(p.error.empty());
     EXPECT_EQ(p.command, "write");
     EXPECT_EQ(p.table, "t1");
@@ -149,6 +175,7 @@ TEST(ParseArgsTest, WriteFlagsParsed) {
     EXPECT_TRUE(p.verbose);
     EXPECT_TRUE(p.header_match);
     EXPECT_EQ(p.file, "in.csv");
+    EXPECT_TRUE(p.input_set);
 }
 
 TEST(ParseArgsTest, OutputFlagNeedsValue) {
@@ -156,29 +183,12 @@ TEST(ParseArgsTest, OutputFlagNeedsValue) {
     EXPECT_FALSE(p.error.empty());
 }
 
-TEST(ParseArgsTest, DashIsStdinPositional) {
-    auto p =
-        tsfile_cli::parse_args({"write", "--table", "t1", "--columns",
-                                "s1:INT64:field", "-o", "out.tsfile", "-"});
+TEST(ParseArgsTest, StdinFlagParsed) {
+    auto p = tsfile_cli::parse_args({"write", "--table", "t1", "--field", "s1",
+                                     "INT64", "--stdin", "-o", "out.tsfile"});
     EXPECT_TRUE(p.error.empty());
     EXPECT_EQ(p.file, "-");
-}
-
-TEST(ParseArgsTest, SeedFlagParsed) {
-    auto p = tsfile_cli::parse_args(
-        {"sample", "-m", "s1", "-n", "3", "--seed", "42", "data.tsfile"});
-    EXPECT_TRUE(p.error.empty());
-    EXPECT_EQ(p.command, "sample");
-    EXPECT_EQ(p.limit, 3);
-    EXPECT_TRUE(p.has_seed);
-    EXPECT_EQ(p.seed, 42);
-}
-
-TEST(ParseArgsTest, BadSeedValueIsError) {
-    auto p = tsfile_cli::parse_args(
-        {"sample", "--seed", "not_a_number", "data.tsfile"});
-    EXPECT_FALSE(p.error.empty());
-    EXPECT_NE(p.error.find("Invalid --seed"), std::string::npos);
+    EXPECT_TRUE(p.input_set);
 }
 
 TEST(RunCliTest, SelectIsNoLongerKnownCommand) {
@@ -195,16 +205,14 @@ TEST(RunCliTest, SeedOnCatIsUsageError) {
     int code =
         tsfile_cli::run_cli({"cat", "--seed", "7", "x.tsfile"}, out, err);
     EXPECT_EQ(code, 1);
-    EXPECT_NE(err.str().find("--seed is only valid for sample"),
-              std::string::npos);
+    EXPECT_NE(err.str().find("--seed is not supported"), std::string::npos);
 }
 
-TEST(RunCliTest, OffsetOnSampleIsUsageError) {
+TEST(RunCliTest, SampleIsUnknownCommand) {
     std::ostringstream out;
     std::ostringstream err;
     int code =
         tsfile_cli::run_cli({"sample", "--offset", "2", "x.tsfile"}, out, err);
     EXPECT_EQ(code, 1);
-    EXPECT_NE(err.str().find("--offset is not valid for sample"),
-              std::string::npos);
+    EXPECT_NE(err.str().find("Unknown command"), std::string::npos);
 }
diff --git a/cpp/test/tools/cli_requirements_test.cc b/cpp/test/tools/cli_requirements_test.cc
new file mode 100644
index 000000000..adfb1c4f6
--- /dev/null
+++ b/cpp/test/tools/cli_requirements_test.cc
@@ -0,0 +1,977 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * License); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <gtest/gtest.h>
+
+#include <cstdio>
+#include <fstream>
+#include <sstream>
+#include <string>
+#ifndef _WIN32
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#include "cli/run_cli.h"
+#include "cli_test_util.h"
+#include "reader/tsfile_reader.h"
+
+#ifndef TSFILE_CPP_SOURCE_DIR
+#define TSFILE_CPP_SOURCE_DIR "."
+#endif
+
+namespace {
+
+struct TableFixture {
+    std::string path = tsfile_cli_test::write_table_fixture();
+    ~TableFixture() { std::remove(path.c_str()); }
+};
+
+struct MultiTableFixture {
+    std::string path = tsfile_cli_test::write_multi_table_fixture();
+    ~MultiTableFixture() { std::remove(path.c_str()); }
+};
+
+bool file_exists(const std::string& path) {
+    std::ifstream in(path.c_str());
+    return in.good();
+}
+
+std::string read_file(const std::string& path) {
+    std::ifstream in(path.c_str(), std::ios::binary);
+    std::ostringstream buf;
+    buf << in.rdbuf();
+    return buf.str();
+}
+
+}  // namespace
+
+TEST(CliRequirements, HelpListsExactlyCurrentCommandSurface) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"--help"}, out, err);
+    EXPECT_EQ(code, 0);
+    EXPECT_NE(out.str().find(
+                  "ls schema meta stats count sketch head cat export write"),
+              std::string::npos)
+        << out.str();
+    EXPECT_EQ(out.str().find("sample"), std::string::npos) << out.str();
+    EXPECT_TRUE(err.str().empty());
+}
+
+TEST(CliRequirements, CommandHelpIsSpecificAndDocumentsSyntaxFieldsExamples) {
+    const std::vector<std::string> commands = {
+        "ls",     "schema", "meta", "stats",  "count",
+        "sketch", "head",   "cat",  "export", "write"};
+    for (const auto& command : commands) {
+        std::ostringstream out;
+        std::ostringstream err;
+        EXPECT_EQ(tsfile_cli::run_cli({command, "--help"}, out, err), 0)
+            << command;
+        EXPECT_TRUE(err.str().empty()) << command << ": " << err.str();
+        EXPECT_NE(out.str().find("Usage: tsfile-cli " + command),
+                  std::string::npos)
+            << command << ": " << out.str();
+        EXPECT_NE(out.str().find("Result fields:"), std::string::npos)
+            << command << ": " << out.str();
+        EXPECT_NE(out.str().find("Examples:"), std::string::npos)
+            << command << ": " << out.str();
+        EXPECT_EQ(out.str().find("Commands:"), std::string::npos)
+            << command << ": " << out.str();
+    }
+
+    std::ostringstream meta_out;
+    std::ostringstream meta_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"meta", "--help"}, meta_out, meta_err), 0);
+    EXPECT_TRUE(meta_err.str().empty());
+    EXPECT_NE(meta_out.str().find("Usage: tsfile-cli meta"), std::string::npos)
+        << meta_out.str();
+    EXPECT_NE(meta_out.str().find("Result fields:"), std::string::npos)
+        << meta_out.str();
+    EXPECT_NE(meta_out.str().find("size_bytes,format_version,model"),
+              std::string::npos)
+        << meta_out.str();
+    EXPECT_NE(meta_out.str().find("Examples:"), std::string::npos)
+        << meta_out.str();
+    EXPECT_EQ(meta_out.str().find("Commands:"), std::string::npos)
+        << meta_out.str();
+
+    std::ostringstream write_out;
+    std::ostringstream write_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "-h"}, write_out, write_err), 0);
+    EXPECT_TRUE(write_err.str().empty());
+    EXPECT_NE(write_out.str().find("Usage: tsfile-cli write"),
+              std::string::npos)
+        << write_out.str();
+    EXPECT_NE(write_out.str().find("--field <name> <type>"), std::string::npos)
+        << write_out.str();
+    EXPECT_NE(write_out.str().find("Default: success is silent"),
+              std::string::npos)
+        << write_out.str();
+    EXPECT_NE(write_out.str().find("Examples:"), std::string::npos)
+        << write_out.str();
+    EXPECT_EQ(write_out.str().find("Commands:"), std::string::npos)
+        << write_out.str();
+}
+
+TEST(CliRequirements, SkillShipsRequiredReferenceFiles) {
+    const std::string root = std::string(TSFILE_CPP_SOURCE_DIR) +
+                             "/tools/skills/tsfile-cli/references/";
+    const std::vector<std::string> refs = {"commands.md", "errors.md",
+                                           "examples.md"};
+    for (const auto& ref : refs) {
+        std::ifstream in(root + ref);
+        ASSERT_TRUE(in.good()) << ref;
+        std::ostringstream body;
+        body << in.rdbuf();
+        EXPECT_NE(body.str().find("tsfile-cli"), std::string::npos)
+            << root + ref;
+    }
+}
+
+TEST(CliRequirements, SampleIsNotACommand) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"sample", "x.tsfile"}, out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("Unknown command"), std::string::npos)
+        << err.str();
+}
+
+TEST(CliRequirements, VersionIncludesConcreteBuildMetadata) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"--version"}, out, err);
+    EXPECT_EQ(code, 0);
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_NE(out.str().find("tsfile-cli "), std::string::npos) << out.str();
+    EXPECT_NE(out.str().find(" tsfile="), std::string::npos) << out.str();
+    EXPECT_NE(out.str().find(" commit="), std::string::npos) << out.str();
+    EXPECT_NE(out.str().find(" built="), std::string::npos) << out.str();
+    EXPECT_EQ(out.str().find("unknown"), std::string::npos) << out.str();
+}
+
+TEST(CliRequirements, FormatVocabularyIsTableNdjsonCsvOnly) {
+    TableFixture f;
+
+    std::ostringstream ndjson_out;
+    std::ostringstream ndjson_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--start", "0", "--end",
+                                   "0", "-f", "ndjson", f.path},
+                                  ndjson_out, ndjson_err),
+              0)
+        << ndjson_err.str();
+    EXPECT_EQ(ndjson_out.str(),
+              "{\"time\":\"0\",\"id1\":\"id1_field_1\",\"id2\":"
+              "\"id2_field_2\",\"s1\":\"0\"}\n");
+
+    std::ostringstream json_out;
+    std::ostringstream json_err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"cat", "-f", "json", f.path}, json_out, json_err),
+        1);
+    EXPECT_TRUE(json_out.str().empty());
+
+    std::ostringstream tsv_out;
+    std::ostringstream tsv_err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"cat", "-f", "tsv", f.path}, tsv_out, tsv_err), 1);
+    EXPECT_TRUE(tsv_out.str().empty());
+}
+
+TEST(CliRequirements, DuplicateSingletonOptionsAreUsageErrors) {
+    TableFixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"cat", "-f", "csv", "-f", "ndjson", f.path},
+                                   out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("--format specified more than once"),
+              std::string::npos)
+        << err.str();
+
+    const std::vector<std::vector<std::string>> duplicate_singletons = {
+        {"cat", "-n", "1", "--limit", "2", f.path},
+        {"cat", "--offset", "0", "--offset", "1", f.path},
+        {"cat", "--start", "0", "--start", "1", f.path},
+        {"cat", "--end", "1", "--end", "2", f.path},
+        {"export", "-t", "table1", "--type", "csv", "-o", "a.csv", "--output",
+         "b.csv", f.path},
+        {"export", "-t", "table1", "--type", "csv", "--output-dir", "a",
+         "--output-dir", "b", f.path},
+        {"export", "-t", "table1", "--type", "csv", "-o", "a.csv", "--force",
+         "--force", f.path},
+    };
+    for (const std::vector<std::string>& args : duplicate_singletons) {
+        std::ostringstream dup_out;
+        std::ostringstream dup_err;
+        EXPECT_EQ(tsfile_cli::run_cli(args, dup_out, dup_err), 1)
+            << dup_err.str();
+        EXPECT_TRUE(dup_out.str().empty());
+        EXPECT_NE(dup_err.str().find("specified more than once"),
+                  std::string::npos)
+            << dup_err.str();
+    }
+}
+
+TEST(CliRequirements, PositionalFileMustBeFinalUnlessAfterDoubleDash) {
+    TableFixture f;
+
+    std::ostringstream bad_out;
+    std::ostringstream bad_err;
+    int bad_code =
+        tsfile_cli::run_cli({"cat", f.path, "-f", "csv"}, bad_out, bad_err);
+    EXPECT_EQ(bad_code, 1);
+    EXPECT_TRUE(bad_out.str().empty());
+    EXPECT_NE(bad_err.str().find("Unexpected argument after file"),
+              std::string::npos)
+        << bad_err.str();
+
+    std::ostringstream ok_out;
+    std::ostringstream ok_err;
+    int ok_code =
+        tsfile_cli::run_cli({"cat", "-m", "s1", "--", f.path}, ok_out, ok_err);
+    EXPECT_EQ(ok_code, 0) << ok_err.str();
+    EXPECT_TRUE(ok_err.str().empty());
+}
+
+TEST(CliRequirements, MeasurementOptionRepeatsAndRejectsCommaLists) {
+    TableFixture f;
+    std::ostringstream comma_out;
+    std::ostringstream comma_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1,s2", f.path}, comma_out,
+                                  comma_err),
+              1);
+
+    std::ostringstream dup_out;
+    std::ostringstream dup_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "-m", "s1", f.path},
+                                  dup_out, dup_err),
+              1);
+    EXPECT_NE(dup_err.str().find("specified more than once"), std::string::npos)
+        << dup_err.str();
+}
+
+TEST(CliRequirements, MetaOnlyReturnsSizeFormatVersionAndModel) {
+    TableFixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"meta", "-f", "csv", f.path}, out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_EQ(out.str().substr(
+                  0, std::string("size_bytes,format_version,model\n").size()),
+              "size_bytes,format_version,model\n")
+        << out.str();
+    EXPECT_EQ(out.str().find("path"), std::string::npos) << out.str();
+    EXPECT_EQ(out.str().find("device_count"), std::string::npos) << out.str();
+}
+
+TEST(CliRequirements, LsReturnsModelAndObjectFields) {
+    TableFixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"ls", "-f", "csv", f.path}, out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_EQ(out.str(), "model,object\ntable,table1\n");
+}
+
+TEST(CliRequirements, SchemaReturnsFixedSevenFieldContract) {
+    TableFixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"schema", "-f", "csv", f.path}, out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_EQ(out.str().substr(
+                  0, std::string("model,object,column,category,data_type,"
+                                 "encoding,compression\n")
+                         .size()),
+              "model,object,column,category,data_type,encoding,compression\n")
+        << out.str();
+    EXPECT_NE(out.str().find("table,table1,id1,TAG,STRING"), std::string::npos)
+        << out.str();
+    EXPECT_NE(out.str().find("table,table1,s1,FIELD,INT64"), std::string::npos)
+        << out.str();
+}
+
+TEST(CliRequirements, HeadCatAndExportRejectOffsetWithZeroLimit) {
+    TableFixture f;
+    std::string out_path = tsfile_cli_test::unique_temp_path(
+        "tsfile_cli_zero_limit_export", ".csv");
+
+    std::ostringstream head_out;
+    std::ostringstream head_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"head", "-n", "0", "--offset", "1", f.path},
+                                  head_out, head_err),
+              1);
+    EXPECT_TRUE(head_out.str().empty());
+
+    std::ostringstream cat_out;
+    std::ostringstream cat_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-n", "0", "--offset", "1", f.path},
+                                  cat_out, cat_err),
+              1);
+    EXPECT_TRUE(cat_out.str().empty());
+
+    std::ostringstream export_out;
+    std::ostringstream export_err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"export", "-t", "table1", "--type", "csv", "-o",
+                             out_path, "-n", "0", "--offset", "1", f.path},
+                            export_out, export_err),
+        1);
+    EXPECT_TRUE(export_out.str().empty());
+    EXPECT_FALSE(file_exists(out_path));
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, HeadAndCatRequireScopeForMultiObjectFiles) {
+    MultiTableFixture f;
+
+    std::ostringstream cat_out;
+    std::ostringstream cat_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "csv", f.path},
+                                  cat_out, cat_err),
+              1);
+    EXPECT_TRUE(cat_out.str().empty());
+    EXPECT_NE(cat_err.str().find("requires -t/--table"), std::string::npos)
+        << cat_err.str();
+
+    std::ostringstream head_out;
+    std::ostringstream head_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"head", "-m", "s1", "-f", "csv", f.path},
+                                  head_out, head_err),
+              1);
+    EXPECT_TRUE(head_out.str().empty());
+    EXPECT_NE(head_err.str().find("requires -t/--table"), std::string::npos)
+        << head_err.str();
+}
+
+TEST(CliRequirements, WriteUsesExplicitTagAndFieldOptions) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_req_in", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,id1,s1\n0,dev,0\n1,dev,10\n";
+    }
+    std::string out_path =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_req_out", ".tsfile");
+
+    std::ostringstream wout;
+    std::ostringstream werr;
+    int wc = tsfile_cli::run_cli(
+        {"write", "--table", "t1", "--tag", "id1", "STRING", "--field", "s1",
+         "INT64", "-i", csv, "-o", out_path},
+        wout, werr);
+    EXPECT_EQ(wc, 0) << werr.str();
+    EXPECT_TRUE(file_exists(out_path));
+
+    std::ostringstream rout;
+    std::ostringstream rerr;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "csv", out_path},
+                                  rout, rerr),
+              0)
+        << rerr.str();
+    EXPECT_EQ(rout.str(), "time,id1,s1\n0,dev,0\n1,dev,10\n");
+
+    std::remove(csv.c_str());
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, WriteMapsInputByHeaderName) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_header_order", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "temp,time,site\n21.5,1000,beijing\n22.0,2000,shanghai\n";
+    }
+    std::string out_path = tsfile_cli_test::unique_temp_path(
+        "tsfile_cli_header_order_out", ".tsfile");
+
+    std::ostringstream wout;
+    std::ostringstream werr;
+    int wc = tsfile_cli::run_cli(
+        {"write", "--table", "sensors", "--tag", "site", "STRING", "--field",
+         "temp", "FLOAT", "-i", csv, "-o", out_path},
+        wout, werr);
+    EXPECT_EQ(wc, 0) << werr.str();
+
+    std::ostringstream rout;
+    std::ostringstream rerr;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-t", "sensors", "-f", "csv", out_path}, rout, rerr),
+              0)
+        << rerr.str();
+    EXPECT_EQ(rout.str(),
+              "time,site,temp\n1000,beijing,21.5\n2000,shanghai,22\n");
+
+    std::remove(csv.c_str());
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, WriteRejectsHeaderShapeErrorsBeforeCreatingOutput) {
+    struct Case {
+        const char* name;
+        const char* content;
+        const char* needle;
+    };
+    const Case cases[] = {
+        {"missing", "time,site\n1000,beijing\n", "missing required column"},
+        {"undeclared", "time,site,temp,status\n1000,beijing,21.5,true\n",
+         "undeclared column"},
+        {"duplicate", "time,site,temp,TEMP\n1000,beijing,21.5,22.0\n",
+         "conflict"},
+    };
+    for (const Case& c : cases) {
+        std::string csv = tsfile_cli_test::unique_temp_path(
+            std::string("tsfile_cli_header_") + c.name, ".csv");
+        {
+            std::ofstream o(csv.c_str());
+            o << c.content;
+        }
+        std::string out_path = tsfile_cli_test::unique_temp_path(
+            std::string("tsfile_cli_header_out_") + c.name, ".tsfile");
+
+        std::ostringstream out;
+        std::ostringstream err;
+        int code = tsfile_cli::run_cli(
+            {"write", "--table", "sensors", "--tag", "site", "STRING",
+             "--field", "temp", "FLOAT", "-i", csv, "-o", out_path},
+            out, err);
+        EXPECT_EQ(code, 2) << c.name << " " << err.str();
+        EXPECT_TRUE(out.str().empty());
+        EXPECT_NE(err.str().find(c.needle), std::string::npos)
+            << c.name << " " << err.str();
+        EXPECT_FALSE(file_exists(out_path));
+
+        std::remove(csv.c_str());
+        std::remove(out_path.c_str());
+    }
+}
+
+TEST(CliRequirements, WriteAppliesAndValidatesTypePhysicalOverrides) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_type_override", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,site,temp,humidity\n"
+             "1000,beijing,21.0,40.5\n"
+             "2000,beijing,21.5,41.0\n";
+    }
+    std::string out_path = tsfile_cli_test::unique_temp_path(
+        "tsfile_cli_type_override_out", ".tsfile");
+
+    std::ostringstream wout;
+    std::ostringstream werr;
+    int wc = tsfile_cli::run_cli(
+        {"write",      "--table",      "sensors",  "--tag",
+         "site",       "STRING",       "--field",  "temp",
+         "FLOAT",      "--field",      "humidity", "FLOAT",
+         "--encoding", "FLOAT",        "GORILLA",  "--compression",
+         "FLOAT",      "UNCOMPRESSED", "-i",       csv,
+         "-o",         out_path},
+        wout, werr);
+    EXPECT_EQ(wc, 0) << werr.str();
+
+    std::ostringstream schema_out;
+    std::ostringstream schema_err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"schema", "-t", "sensors", "-f", "csv", out_path},
+                            schema_out, schema_err),
+        0)
+        << schema_err.str();
+    EXPECT_NE(schema_out.str().find(
+                  "table,sensors,temp,FIELD,FLOAT,GORILLA,UNCOMPRESSED\n"),
+              std::string::npos)
+        << schema_out.str();
+    EXPECT_NE(schema_out.str().find(
+                  "table,sensors,humidity,FIELD,FLOAT,GORILLA,UNCOMPRESSED\n"),
+              std::string::npos)
+        << schema_out.str();
+
+    std::ostringstream dup_out;
+    std::ostringstream dup_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"write", "--table", "sensors", "--field", "temp", "FLOAT",
+                   "--encoding", "FLOAT", "GORILLA", "--encoding", "FLOAT",
+                   "PLAIN", "--stdin", "-o", "unused.tsfile"},
+                  dup_out, dup_err),
+              1);
+    EXPECT_NE(dup_err.str().find("specified more than once"), std::string::npos)
+        << dup_err.str();
+
+    std::ostringstream unused_out;
+    std::ostringstream unused_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "sensors", "--field",
+                                   "temp", "FLOAT", "--encoding", "DOUBLE",
+                                   "GORILLA", "--stdin", "-o", "unused.tsfile"},
+                                  unused_out, unused_err),
+              1);
+    EXPECT_NE(unused_err.str().find("not used"), std::string::npos)
+        << unused_err.str();
+
+    std::ostringstream bad_out;
+    std::ostringstream bad_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "binary_data", "--field",
+                                   "payload", "BLOB", "--encoding", "BLOB",
+                                   "GORILLA", "--stdin", "-o", "unused.tsfile"},
+                                  bad_out, bad_err),
+              1);
+    EXPECT_NE(bad_err.str().find("not supported"), std::string::npos)
+        << bad_err.str();
+
+    std::remove(csv.c_str());
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, WriteRejectsExistingOutputWithoutTruncating) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_existing_in", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,s1\n0,10\n";
+    }
+    std::string out_path =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_existing_out", ".tsfile");
+    {
+        std::ofstream o(out_path.c_str());
+        o << "keep-me";
+    }
+
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
+                                    "INT64", "-i", csv, "-o", out_path},
+                                   out, err);
+    EXPECT_EQ(code, 3);
+    EXPECT_EQ(read_file(out_path), "keep-me");
+
+    std::remove(csv.c_str());
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, WriteRejectsNonRegularInputBeforeCreatingOutput) {
+#ifndef _WIN32
+    std::string dir =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_input_dir", "");
+    ASSERT_EQ(mkdir(dir.c_str(), 0777), 0);
+    std::string out_path = tsfile_cli_test::unique_temp_path(
+        "tsfile_cli_input_dir_out", ".tsfile");
+
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
+                                    "INT64", "-i", dir, "-o", out_path},
+                                   out, err);
+    EXPECT_EQ(code, 2);
+    EXPECT_FALSE(file_exists(out_path));
+
+    rmdir(dir.c_str());
+#endif
+}
+
+TEST(CliRequirements, WriteRejectsNonCanonicalTimeLexemesAsInputErrors) {
+    const char* bad_times[] = {"+1", "01", "-0"};
+    for (const char* bad_time : bad_times) {
+        std::string csv =
+            tsfile_cli_test::unique_temp_path("tsfile_cli_bad_time", ".csv");
+        {
+            std::ofstream o(csv.c_str());
+            o << "time,s1\n" << bad_time << ",10\n";
+        }
+        std::string out_path = tsfile_cli_test::unique_temp_path(
+            "tsfile_cli_bad_time_out", ".tsfile");
+        std::ostringstream out;
+        std::ostringstream err;
+        int code =
+            tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
+                                 "INT64", "-i", csv, "-o", out_path},
+                                out, err);
+        EXPECT_EQ(code, 2) << bad_time << " " << err.str();
+        EXPECT_FALSE(file_exists(out_path)) << bad_time;
+        std::remove(csv.c_str());
+        std::remove(out_path.c_str());
+    }
+}
+
+TEST(CliRequirements, WriteTargetFailuresAreRuntimeErrors) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_target", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,s1\n0,1\n";
+    }
+
+    std::ostringstream same_out;
+    std::ostringstream same_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
+                                   "INT64", "-i", csv, "-o", csv},
+                                  same_out, same_err),
+              3);
+    EXPECT_TRUE(same_out.str().empty());
+    EXPECT_NE(same_err.str().find("same as the input"), std::string::npos)
+        << same_err.str();
+    EXPECT_EQ(read_file(csv), "time,s1\n0,1\n");
+
+    std::string parent =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_missing_parent", "");
+    std::string child = parent + "/out.tsfile";
+    std::ostringstream parent_out;
+    std::ostringstream parent_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
+                                   "INT64", "-i", csv, "-o", child},
+                                  parent_out, parent_err),
+              3);
+    EXPECT_TRUE(parent_out.str().empty());
+    EXPECT_NE(parent_err.str().find("cannot create output"), std::string::npos)
+        << parent_err.str();
+    EXPECT_FALSE(file_exists(child));
+
+    std::remove(csv.c_str());
+}
+
+TEST(CliRequirements, WriteCsvNullAndEmptyStringRemainDistinctTags) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_tag_null", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,site,temp\n1000,\\N,21.0\n1000,\"\",22.0\n";
+    }
+    std::string out_path =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_tag_null_out", ".tsfile");
+    std::ostringstream out;
+    std::ostringstream err;
+    ASSERT_EQ(tsfile_cli::run_cli(
+                  {"write", "--table", "sensors", "--tag", "site", "STRING",
+                   "--field", "temp", "FLOAT", "-i", csv, "-o", out_path},
+                  out, err),
+              0)
+        << err.str();
+
+    std::ostringstream cat_out;
+    std::ostringstream cat_err;
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"cat", "-t", "sensors", "-f", "ndjson", out_path},
+                            cat_out, cat_err),
+        0)
+        << cat_err.str();
+    EXPECT_NE(cat_out.str().find("\"site\":null"), std::string::npos)
+        << cat_out.str();
+    EXPECT_NE(cat_out.str().find("\"site\":\"\""), std::string::npos)
+        << cat_out.str();
+    EXPECT_NE(cat_out.str().find("\"temp\":21"), std::string::npos)
+        << cat_out.str();
+    EXPECT_NE(cat_out.str().find("\"temp\":22"), std::string::npos)
+        << cat_out.str();
+
+    std::ostringstream count_out;
+    std::ostringstream count_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"count", "-t", "sensors", "-m", "site", "-f",
+                                   "csv", out_path},
+                                  count_out, count_err),
+              0)
+        << count_err.str();
+    EXPECT_NE(count_out.str().find("table,sensors,site,TAG,2,2"),
+              std::string::npos)
+        << count_out.str();
+
+    std::remove(csv.c_str());
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, WriteRejectsUnterminatedQuotedCsvField) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_unclosed_quote", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,site,temp\n1000,\"beijing,21.0\n";
+    }
+    std::string out_path = tsfile_cli_test::unique_temp_path(
+        "tsfile_cli_unclosed_quote_out", ".tsfile");
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"write", "--table", "sensors", "--tag", "site", "STRING",
+                   "--field", "temp", "FLOAT", "-i", csv, "-o", out_path},
+                  out, err),
+              2);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("unterminated quoted CSV field"),
+              std::string::npos)
+        << err.str();
+    EXPECT_FALSE(file_exists(out_path));
+
+    std::remove(csv.c_str());
+    std::remove(out_path.c_str());
+}
+
+TEST(CliRequirements, LegacyColumnsOptionIsRejected) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code =
+        tsfile_cli::run_cli({"write", "--table", "t1", "--columns",
+                             "s1:INT64:field", "-o", "x.tsfile", "--stdin"},
+                            out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("Unknown flag: --columns"), std::string::npos)
+        << err.str();
+}
+
+TEST(CliRequirements, WriteRejectsImplicitInputAndFormatFlag) {
+    std::ostringstream implicit_out;
+    std::ostringstream implicit_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1",
+                                   "INT64", "-o", "x.tsfile", "in.csv"},
+                                  implicit_out, implicit_err),
+              1);
+    EXPECT_NE(
+        implicit_err.str().find("choose exactly one of --input or --stdin"),
+        std::string::npos)
+        << implicit_err.str();
+
+    std::ostringstream format_out;
+    std::ostringstream format_err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"write", "--table", "t1", "--field", "s1", "INT64",
+                             "-f", "csv", "--stdin", "-o", "x.tsfile"},
+                            format_out, format_err),
+        1);
+    EXPECT_NE(format_err.str().find("--format is not valid"), std::string::npos)
+        << format_err.str();
+}
+
+TEST(CliRequirements, ExportWritesSingleObjectAtomically) {
+    TableFixture f;
+    std::string out_path =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_export", ".csv");
+
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"export", "-t", "table1", "-o", out_path,
+                                    "--type", "csv", "-m", "s1", f.path},
+                                   out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_TRUE(out.str().empty());
+
+    std::ostringstream cat_out;
+    std::ostringstream cat_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-t", "table1", "-m", "s1", "-f", "csv", f.path},
+                  cat_out, cat_err),
+              0)
+        << cat_err.str();
+    EXPECT_EQ(read_file(out_path), cat_out.str());
+
+    std::remove(out_path.c_str());
+}
+
+#ifndef _WIN32
+TEST(CliRequirements, ExportForceRejectsSymlinkAndSpecialTargets) {
+    TableFixture f;
+    std::string sentinel =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_export_sentinel", ".txt");
+    std::string symlink_path =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_export_link", ".csv");
+    {
+        std::ofstream file(sentinel.c_str());
+        file << "sentinel";
+    }
+    ASSERT_EQ(symlink(sentinel.c_str(), symlink_path.c_str()), 0);
+
+    std::ostringstream link_out;
+    std::ostringstream link_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"export", "-t", "table1", "-o", symlink_path,
+                                   "--type", "csv", "--force", f.path},
+                                  link_out, link_err),
+              3);
+    EXPECT_EQ(read_file(sentinel), "sentinel");
+
+    std::string fifo_path =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_export_fifo", ".csv");
+    ASSERT_EQ(mkfifo(fifo_path.c_str(), 0600), 0);
+    std::ostringstream fifo_out;
+    std::ostringstream fifo_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"export", "-t", "table1", "-o", fifo_path,
+                                   "--type", "csv", "--force", f.path},
+                                  fifo_out, fifo_err),
+              3);
+
+    std::remove(symlink_path.c_str());
+    std::remove(sentinel.c_str());
+    std::remove(fifo_path.c_str());
+}
+#endif
+
+TEST(CliRequirements, ExportWritesMultiObjectManifestAndNumberedFiles) {
+    MultiTableFixture f;
+    std::string dir =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_multi_export", "");
+
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli(
+        {"export", "-t", "sensors_a", "-t", "sensors_b", "--output-dir", dir,
+         "--type", "csv", "-m", "s1", f.path},
+        out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_EQ(read_file(dir + "/0001.csv"),
+              "time,id1,s1\n0,sensors_a_tag,10\n");
+    EXPECT_EQ(read_file(dir + "/0002.csv"),
+              "time,id1,s1\n0,sensors_b_tag,20\n");
+    std::string manifest = read_file(dir + "/_manifest.json");
+    EXPECT_NE(manifest.find("\"complete\": true"), std::string::npos)
+        << manifest;
+    EXPECT_NE(manifest.find("\"file\":\"0001.csv\""), std::string::npos)
+        << manifest;
+    EXPECT_NE(manifest.find("\"object\":\"sensors_b\""), std::string::npos)
+        << manifest;
+    EXPECT_NE(manifest.find("\"rows\":\"1\""), std::string::npos) << manifest;
+
+    std::remove((dir + "/0001.csv").c_str());
+    std::remove((dir + "/0002.csv").c_str());
+    std::remove((dir + "/_manifest.json").c_str());
+#ifndef _WIN32
+    rmdir(dir.c_str());
+#endif
+}
+
+TEST(CliRequirements, MultipleTagFiltersRequireAndHonorTagMatch) {
+    std::string path = tsfile_cli_test::write_tag_filter_fixture();
+    std::ostringstream missing_out;
+    std::ostringstream missing_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-m", "s1", "--tag-filter", "id1", "eq", "dev_a",
+                   "--tag-filter", "id1", "eq", "dev_c", "-f", "csv", path},
+                  missing_out, missing_err),
+              1);
+
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1", "eq",
+                             "dev_a", "--tag-filter", "id1", "eq", "dev_c",
+                             "--tag-match", "any", "-f", "csv", path},
+                            out, err),
+        0)
+        << err.str();
+    EXPECT_EQ(out.str(), "time,id1,s1\n0,dev_a,10\n3,dev_c,40\n");
+    std::remove(path.c_str());
+}
+
+TEST(CliRequirements, SketchRejectsRegularResultFormat) {
+    TableFixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"sketch", "-f", "csv", f.path}, out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("sketch does not accept --format"),
+              std::string::npos)
+        << err.str();
+}
+
+TEST(CliRequirements, SketchWritesStdoutAndAtomicOutput) {
+    TableFixture f;
+    std::ostringstream stdout_out;
+    std::ostringstream stdout_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"sketch", f.path}, stdout_out, stdout_err),
+              0)
+        << stdout_err.str();
+    EXPECT_NE(stdout_out.str().find("TsFile Sketch"), std::string::npos)
+        << stdout_out.str();
+    EXPECT_NE(stdout_out.str().find("model: table"), std::string::npos)
+        << stdout_out.str();
+
+    std::string output =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_sketch", ".txt");
+    std::ostringstream file_out;
+    std::ostringstream file_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"sketch", "-o", output, f.path}, file_out,
+                                  file_err),
+              0)
+        << file_err.str();
+    EXPECT_TRUE(file_out.str().empty());
+    EXPECT_EQ(read_file(output), stdout_out.str());
+
+    const std::string sentinel = "do not replace";
+    {
+        std::ofstream existing(output.c_str(), std::ios::binary);
+        existing << sentinel;
+    }
+    std::ostringstream no_force_out;
+    std::ostringstream no_force_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"sketch", "-o", output, f.path},
+                                  no_force_out, no_force_err),
+              3);
+    EXPECT_EQ(read_file(output), sentinel);
+
+    std::ostringstream force_out;
+    std::ostringstream force_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"sketch", "-o", output, "--force", f.path},
+                                  force_out, force_err),
+              0)
+        << force_err.str();
+    EXPECT_EQ(read_file(output), stdout_out.str());
+
+    const std::string source_before = read_file(f.path);
+    std::ostringstream alias_out;
+    std::ostringstream alias_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"sketch", "-o", f.path, "--force", f.path},
+                                  alias_out, alias_err),
+              3);
+    EXPECT_EQ(read_file(f.path), source_before);
+    std::remove(output.c_str());
+}
+
+TEST(CliRequirements, ModelDetectionPrefersTableSchemaAndFallsBackToTree) {
+    TableFixture table;
+    storage::TsFileReader table_reader;
+    ASSERT_EQ(table_reader.open(table.path), common::E_OK);
+    EXPECT_FALSE(table_reader.get_all_table_schemas().empty());
+    EXPECT_FALSE(table_reader.get_all_device_ids().empty());
+    table_reader.close();
+
+    std::ostringstream table_out;
+    std::ostringstream table_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"ls", "-f", "csv", table.path}, table_out,
+                                  table_err),
+              0)
+        << table_err.str();
+    EXPECT_EQ(table_out.str(), "model,object\ntable,table1\n");
+
+    std::string tree_path = tsfile_cli_test::write_sparse_tree_fixture();
+    storage::TsFileReader tree_reader;
+    ASSERT_EQ(tree_reader.open(tree_path), common::E_OK);
+    EXPECT_TRUE(tree_reader.get_all_table_schemas().empty());
+    EXPECT_FALSE(tree_reader.get_all_device_ids().empty());
+    tree_reader.close();
+
+    std::ostringstream tree_out;
+    std::ostringstream tree_err;
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"ls", "-f", "csv", tree_path}, tree_out, tree_err),
+        0)
+        << tree_err.str();
+    EXPECT_EQ(tree_out.str(), "model,object\ntree,root.test.d1\n");
+    std::remove(tree_path.c_str());
+}
diff --git a/cpp/test/tools/cli_test_util.h b/cpp/test/tools/cli_test_util.h
index 5b4e532d9..1f88af8c5 100644
--- a/cpp/test/tools/cli_test_util.h
+++ b/cpp/test/tools/cli_test_util.h
@@ -27,13 +27,16 @@
 #include <unistd.h>
 #endif
 
+#include <memory>
 #include <sstream>
 #include <string>
+#include <vector>
 
 #include "common/schema.h"
 #include "common/tablet.h"
 #include "file/write_file.h"
 #include "writer/tsfile_table_writer.h"
+#include "writer/tsfile_tree_writer.h"
 
 namespace tsfile_cli_test {
 
@@ -142,6 +145,181 @@ inline std::string write_tag_filter_fixture() {
     return out_path;
 }
 
+inline std::string write_nullable_tag_filter_fixture() {
+    storage::libtsfile_init();
+    std::string out_path =
+        unique_temp_path("tsfile_cli_nullable_tag_filter_fixture", ".tsfile");
+    std::string table_name = "t1";
+
+    storage::WriteFile file;
+    int flags = O_WRONLY | O_CREAT | O_TRUNC;
+#ifdef _WIN32
+    flags |= O_BINARY;
+#endif
+    file.create(out_path, flags, 0666);
+
+    auto* schema = new storage::TableSchema(
+        table_name,
+        {
+            common::ColumnSchema("id1", common::STRING, common::UNCOMPRESSED,
+                                 common::PLAIN, common::ColumnCategory::TAG),
+            common::ColumnSchema("s1", common::INT64, common::UNCOMPRESSED,
+                                 common::PLAIN, common::ColumnCategory::FIELD),
+        });
+
+    auto* writer = new storage::TsFileTableWriter(&file, schema);
+    storage::Tablet tablet(
+        table_name, {"id1", "s1"}, {common::STRING, common::INT64},
+        {common::ColumnCategory::TAG, common::ColumnCategory::FIELD}, 5);
+    const char* tags[] = {nullptr, "", "null", "dev_a", "dev_b"};
+    for (int row = 0; row < 5; ++row) {
+        tablet.add_timestamp(row, static_cast<int64_t>(row));
+        if (tags[row] != nullptr) {
+            tablet.add_value(row, "id1", tags[row]);
+        }
+        tablet.add_value(row, "s1", static_cast<int64_t>((row + 1) * 10));
+    }
+
+    writer->write_table(tablet);
+    writer->flush();
+    writer->close();
+
+    delete writer;
+    delete schema;
+    return out_path;
+}
+
+inline void write_one_table_row(storage::TsFileTableWriter* writer,
+                                const std::string& table_name,
+                                const std::string& field_name, int64_t time,
+                                int64_t value) {
+    storage::Tablet tablet(
+        table_name, {"id1", field_name}, {common::STRING, common::INT64},
+        {common::ColumnCategory::TAG, common::ColumnCategory::FIELD}, 1);
+    tablet.add_timestamp(0, time);
+    tablet.add_value(0, "id1", table_name + "_tag");
+    tablet.add_value(0, field_name, value);
+    writer->write_table(tablet);
+}
+
+inline std::string write_two_table_fixture(const std::string& fixture_name,
+                                           const std::string& first_field,
+                                           const std::string& second_field) {
+    storage::libtsfile_init();
+    std::string out_path = unique_temp_path(fixture_name, ".tsfile");
+
+    storage::WriteFile file;
+    int flags = O_WRONLY | O_CREAT | O_TRUNC;
+#ifdef _WIN32
+    flags |= O_BINARY;
+#endif
+    file.create(out_path, flags, 0666);
+
+    auto* schema_a = new storage::TableSchema(
+        "sensors_a",
+        {
+            common::ColumnSchema("id1", common::STRING, common::UNCOMPRESSED,
+                                 common::PLAIN, common::ColumnCategory::TAG),
+            common::ColumnSchema(first_field, common::INT64,
+                                 common::UNCOMPRESSED, common::PLAIN,
+                                 common::ColumnCategory::FIELD),
+        });
+    auto* writer = new storage::TsFileTableWriter(&file, schema_a);
+    auto schema_b = std::make_shared<storage::TableSchema>(
+        "sensors_b",
+        std::vector<common::ColumnSchema>{
+            common::ColumnSchema("id1", common::STRING, common::UNCOMPRESSED,
+                                 common::PLAIN, common::ColumnCategory::TAG),
+            common::ColumnSchema(second_field, common::INT64,
+                                 common::UNCOMPRESSED, common::PLAIN,
+                                 common::ColumnCategory::FIELD),
+        });
+    writer->register_table(schema_b);
+
+    write_one_table_row(writer, "sensors_a", first_field, 0, 10);
+    write_one_table_row(writer, "sensors_b", second_field, 0, 20);
+
+    writer->flush();
+    writer->close();
+
+    delete writer;
+    delete schema_a;
+    return out_path;
+}
+
+inline std::string write_multi_table_fixture() {
+    return write_two_table_fixture("tsfile_cli_multi_table_fixture", "s1",
+                                   "s1");
+}
+
+inline std::string write_disjoint_table_fixture() {
+    return write_two_table_fixture("tsfile_cli_disjoint_table_fixture", "s1",
+                                   "s2");
+}
+
+inline std::string write_sparse_tree_fixture() {
+    storage::libtsfile_init();
+    std::string path = unique_temp_path("tsfile_cli_sparse_tree", ".tsfile");
+    storage::WriteFile file;
+    int flags = O_WRONLY | O_CREAT | O_TRUNC;
+#ifdef _WIN32
+    flags |= O_BINARY;
+#endif
+    file.create(path, flags, 0666);
+    storage::TsFileTreeWriter writer(&file);
+    std::string device = "root.test.d1";
+    auto* left = new storage::MeasurementSchema("left", common::INT32);
+    auto* right = new storage::MeasurementSchema("right", common::BOOLEAN);
+    writer.register_timeseries(device, left);
+    writer.register_timeseries(device, right);
+
+    storage::TsRecord first(device, 0);
+    first.add_point("left", static_cast<int32_t>(10));
+    writer.write(first);
+    storage::TsRecord second(device, 1);
+    second.add_point("right", true);
+    writer.write(second);
+    storage::TsRecord third(device, 2);
+    third.add_point("left", static_cast<int32_t>(20));
+    third.add_point("right", false);
+    writer.write(third);
+    writer.flush();
+    writer.close();
+    delete left;
+    delete right;
+    return path;
+}
+
+inline std::string write_disjoint_tree_fixture() {
+    storage::libtsfile_init();
+    std::string path = unique_temp_path("tsfile_cli_disjoint_tree", ".tsfile");
+    storage::WriteFile file;
+    int flags = O_WRONLY | O_CREAT | O_TRUNC;
+#ifdef _WIN32
+    flags |= O_BINARY;
+#endif
+    file.create(path, flags, 0666);
+    storage::TsFileTreeWriter writer(&file);
+    auto* left = new storage::MeasurementSchema("left", common::INT32);
+    auto* right = new storage::MeasurementSchema("right", common::BOOLEAN);
+    std::string first_device = "root.test.d1";
+    std::string second_device = "root.test.d2";
+    writer.register_timeseries(first_device, left);
+    writer.register_timeseries(second_device, right);
+
+    storage::TsRecord first(first_device, 0);
+    first.add_point("left", static_cast<int32_t>(10));
+    writer.write(first);
+    storage::TsRecord second(second_device, 1);
+    second.add_point("right", true);
+    writer.write(second);
+    writer.flush();
+    writer.close();
+    delete left;
+    delete right;
+    return path;
+}
+
 }  // namespace tsfile_cli_test
 
 #endif  // TSFILE_CLI_TEST_UTIL_H
diff --git a/cpp/test/tools/command_e2e_test.cc b/cpp/test/tools/command_e2e_test.cc
index a5c5b722c..16fe7694f 100644
--- a/cpp/test/tools/command_e2e_test.cc
+++ b/cpp/test/tools/command_e2e_test.cc
@@ -39,6 +39,31 @@ struct TagFilterFixture {
     ~TagFilterFixture() { std::remove(path.c_str()); }
 };
 
+struct MultiTableFixture {
+    std::string path = tsfile_cli_test::write_multi_table_fixture();
+    ~MultiTableFixture() { std::remove(path.c_str()); }
+};
+
+struct DisjointTableFixture {
+    std::string path = tsfile_cli_test::write_disjoint_table_fixture();
+    ~DisjointTableFixture() { std::remove(path.c_str()); }
+};
+
+struct SparseTreeFixture {
+    std::string path = tsfile_cli_test::write_sparse_tree_fixture();
+    ~SparseTreeFixture() { std::remove(path.c_str()); }
+};
+
+struct DisjointTreeFixture {
+    std::string path = tsfile_cli_test::write_disjoint_tree_fixture();
+    ~DisjointTreeFixture() { std::remove(path.c_str()); }
+};
+
+class FlushFailingStreamBuf : public std::stringbuf {
+   protected:
+    int sync() override { return -1; }
+};
+
 size_t count_lines(const std::string& s) {
     size_t n = 0;
     for (char c : s) {
@@ -55,20 +80,21 @@ TEST(CliE2E, LsListsTableNameTsv) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"ls", "-f", "tsv", f.path}, out, err);
+    int code = tsfile_cli::run_cli({"ls", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "name\ntable1\n");
+    EXPECT_EQ(out.str(), "model,object\ntable,table1\n");
     EXPECT_TRUE(err.str().empty());
 }
 
-TEST(CliE2E, LsNoHeaderJustName) {
+TEST(CliE2E, LsRejectsNoHeader) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"ls", "-f", "tsv", "--no-header", f.path},
+    int code = tsfile_cli::run_cli({"ls", "-f", "csv", "--no-header", f.path},
                                    out, err);
-    EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "table1\n");
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("--no-header"), std::string::npos) << err.str();
 }
 
 TEST(CliE2E, OpenMissingFileReturnsFileError) {
@@ -84,11 +110,11 @@ TEST(CliE2E, SchemaShowsFieldColumnAndType) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"schema", "-f", "tsv", f.path}, out, err);
+    int code = tsfile_cli::run_cli({"schema", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_NE(
-        out.str().find("target\tmeasurement\tdatatype\tencoding\tcompression"),
-        std::string::npos);
+    EXPECT_NE(out.str().find("model,object,column,category,data_type,encoding,"
+                             "compression"),
+              std::string::npos);
     EXPECT_NE(out.str().find("s1"), std::string::npos);
     EXPECT_NE(out.str().find("INT64"), std::string::npos);
 }
@@ -97,25 +123,51 @@ TEST(CliE2E, SchemaTableMeasurementFilterOnlyShowsRequestedColumn) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"schema", "-m", "s1", "-f", "tsv", f.path},
+    int code = tsfile_cli::run_cli({"schema", "-m", "s1", "-f", "csv", f.path},
                                    out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_NE(out.str().find("table1\ts1\tINT64"), std::string::npos);
-    EXPECT_EQ(out.str().find("table1\tid1"), std::string::npos);
-    EXPECT_EQ(out.str().find("table1\tid2"), std::string::npos);
+    EXPECT_NE(out.str().find("table,table1,s1,FIELD,INT64"), std::string::npos);
+    EXPECT_EQ(out.str().find("table1,id1"), std::string::npos);
+    EXPECT_EQ(out.str().find("table1,id2"), std::string::npos);
+}
+
+TEST(CliE2E, SchemaTableMeasurementFilterIsCaseInsensitive) {
+    Fixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"schema", "-m", "S1", "-f", "csv", f.path},
+                                   out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_NE(out.str().find("table,table1,s1,FIELD,INT64"), std::string::npos)
+        << out.str();
+}
+
+TEST(CliE2E, SchemaRejectsMissingTableBeforeWritingOutput) {
+    Fixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli(
+        {"schema", "-t", "missing", "-f", "csv", f.path}, out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("does not exist"), std::string::npos) << err.str();
 }
 
 TEST(CliE2E, StatsReportsCountAndTimeRange) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"stats", "-f", "tsv", f.path}, out, err);
+    int code = tsfile_cli::run_cli({"stats", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_NE(out.str().find("target\tmeasurement\tcount\tstart_time\tend_"
-                             "time\tmin\tmax\tfirst\tlast\tsum"),
-              std::string::npos);
-    EXPECT_NE(out.str().find("s1\t5\t0\t4\t0\t40\t0\t40\t100"),
-              std::string::npos);
+    EXPECT_NE(out.str().find("model,object,tag.id1,tag.id2,field,data_type,"
+                             "non_null_count,null_count,min_time,max_time,min,"
+                             "max,first,last,sum,stats_source"),
+              std::string::npos)
+        << out.str();
+    EXPECT_NE(out.str().find("table,table1,id1_field_1,id2_field_2,s1,INT64,"
+                             "5,\\N,0,4,0,40,0,40,\\N,statistics"),
+              std::string::npos)
+        << out.str();
 }
 
 TEST(CliE2E, HeadProjectsAndLimits) {
@@ -123,9 +175,11 @@ TEST(CliE2E, HeadProjectsAndLimits) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"head", "-m", "s1", "-n", "2", "-f", "tsv", f.path}, out, err);
+        {"head", "-m", "s1", "-n", "2", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "time\ts1\n0\t0\n1\t10\n");
+    EXPECT_EQ(out.str(),
+              "time,id1,id2,s1\n0,id1_field_1,id2_field_2,0\n1,id1_field_1,"
+              "id2_field_2,10\n");
 }
 
 TEST(CliE2E, CatReturnsAllRows) {
@@ -133,10 +187,37 @@ TEST(CliE2E, CatReturnsAllRows) {
     std::ostringstream out;
     std::ostringstream err;
     int code =
-        tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "tsv", f.path}, out, err);
+        tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
     EXPECT_EQ(count_lines(out.str()), 6u);
-    EXPECT_NE(out.str().find("time\ts1\n"), std::string::npos);
+    EXPECT_NE(out.str().find("time,id1,id2,s1\n"), std::string::npos);
+}
+
+TEST(CliE2E, CatRejectsMissingOrNonFieldProjectionBeforeQuery) {
+    Fixture f;
+    for (const char* measurement : {"missing", "id1"}) {
+        std::ostringstream out;
+        std::ostringstream err;
+        int code = tsfile_cli::run_cli(
+            {"cat", "-m", measurement, "-f", "csv", f.path}, out, err);
+        EXPECT_EQ(code, 1) << measurement << " " << err.str();
+        EXPECT_TRUE(out.str().empty()) << measurement;
+        EXPECT_NE(err.str().find("FIELD"), std::string::npos)
+            << measurement << " " << err.str();
+    }
+}
+
+TEST(CliE2E, CatTableProjectionIsCaseInsensitive) {
+    Fixture f;
+    std::ostringstream out;
+    std::ostringstream err;
+    int code =
+        tsfile_cli::run_cli({"cat", "-m", "S1", "-f", "csv", f.path}, out, err);
+    EXPECT_EQ(code, 0) << err.str();
+    EXPECT_EQ(out.str(),
+              "time,id1,id2,s1\n0,id1_field_1,id2_field_2,0\n1,id1_field_1,"
+              "id2_field_2,10\n2,id1_field_1,id2_field_2,20\n3,id1_field_1,"
+              "id2_field_2,30\n4,id1_field_1,id2_field_2,40\n");
 }
 
 TEST(CliE2E, CatPushesDownOffsetAndLimit) {
@@ -144,10 +225,12 @@ TEST(CliE2E, CatPushesDownOffsetAndLimit) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"cat", "-m", "s1", "--offset", "2", "-n", "2", "-f", "tsv", f.path},
+        {"cat", "-m", "s1", "--offset", "2", "-n", "2", "-f", "csv", f.path},
         out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "time\ts1\n2\t20\n3\t30\n");
+    EXPECT_EQ(out.str(),
+              "time,id1,id2,s1\n2,id1_field_1,id2_field_2,20\n3,id1_field_1,"
+              "id2_field_2,30\n");
 }
 
 TEST(CliE2E, HeadPushesDownOffsetAndLimit) {
@@ -155,10 +238,12 @@ TEST(CliE2E, HeadPushesDownOffsetAndLimit) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"head", "-m", "s1", "--offset", "1", "-n", "3", "-f", "tsv", f.path},
+        {"head", "-m", "s1", "--offset", "1", "-n", "3", "-f", "csv", f.path},
         out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "time\ts1\n1\t10\n2\t20\n3\t30\n");
+    EXPECT_EQ(out.str(),
+              "time,id1,id2,s1\n1,id1_field_1,id2_field_2,10\n2,id1_field_1,"
+              "id2_field_2,20\n3,id1_field_1,id2_field_2,30\n");
 }
 
 TEST(CliE2E, CatWithTimeRange) {
@@ -166,10 +251,12 @@ TEST(CliE2E, CatWithTimeRange) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"cat", "-m", "s1", "--start", "2", "--end", "3", "-f", "tsv", f.path},
+        {"cat", "-m", "s1", "--start", "2", "--end", "3", "-f", "csv", f.path},
         out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "time\ts1\n2\t20\n3\t30\n");
+    EXPECT_EQ(out.str(),
+              "time,id1,id2,s1\n2,id1_field_1,id2_field_2,20\n3,id1_field_1,"
+              "id2_field_2,30\n");
 }
 
 TEST(CliE2E, CatAppliesOffsetAfterTimeRange) {
@@ -178,10 +265,12 @@ TEST(CliE2E, CatAppliesOffsetAfterTimeRange) {
     std::ostringstream err;
     int code =
         tsfile_cli::run_cli({"cat", "-m", "s1", "--start", "1", "--end", "4",
-                             "--offset", "1", "-n", "2", "-f", "tsv", f.path},
+                             "--offset", "1", "-n", "2", "-f", "csv", f.path},
                             out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "time\ts1\n2\t20\n3\t30\n");
+    EXPECT_EQ(out.str(),
+              "time,id1,id2,s1\n2,id1_field_1,id2_field_2,20\n3,id1_field_1,"
+              "id2_field_2,30\n");
 }
 
 TEST(CliE2E, CatFiltersRowsByTagEq) {
@@ -189,34 +278,22 @@ TEST(CliE2E, CatFiltersRowsByTagEq) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1",
-                                    "eq", "dev_b", "-f", "tsv", f.path},
+                                    "eq", "dev_b", "-f", "csv", f.path},
                                    out, err);
     EXPECT_EQ(code, 0) << err.str();
-    EXPECT_EQ(out.str(), "time\ts1\n1\t20\n2\t30\n");
+    EXPECT_EQ(out.str(), "time,id1,s1\n1,dev_b,20\n2,dev_b,30\n");
 }
 
-TEST(CliE2E, HeadFiltersRowsByTagBetween) {
-    TagFilterFixture f;
-    std::ostringstream out;
-    std::ostringstream err;
-    int code =
-        tsfile_cli::run_cli({"head", "-m", "s1", "--tag-between", "id1",
-                             "dev_b", "dev_c", "-n", "10", "-f", "tsv", f.path},
-                            out, err);
-    EXPECT_EQ(code, 0) << err.str();
-    EXPECT_EQ(out.str(), "time\ts1\n1\t20\n2\t30\n3\t40\n");
-}
-
-TEST(CliE2E, SampleFiltersRowsByTagEq) {
+TEST(CliE2E, HeadFiltersRowsByTagRegexp) {
     TagFilterFixture f;
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"sample", "-m", "s1", "--tag-filter", "id1", "eq", "dev_b", "-n", "10",
-         "--seed", "1", "-f", "tsv", f.path},
+        {"head", "-m", "s1", "--tag-filter", "id1", "regexp", "dev_[bc]", "-n",
+         "10", "-f", "csv", f.path},
         out, err);
     EXPECT_EQ(code, 0) << err.str();
-    EXPECT_EQ(out.str(), "time\ts1\n1\t20\n2\t30\n");
+    EXPECT_EQ(out.str(), "time,id1,s1\n1,dev_b,20\n2,dev_b,30\n3,dev_c,40\n");
 }
 
 TEST(CliE2E, TagFilterRejectsFieldColumn) {
@@ -224,47 +301,363 @@ TEST(CliE2E, TagFilterRejectsFieldColumn) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "s1",
-                                    "eq", "20", "-f", "tsv", f.path},
+                                    "eq", "20", "-f", "csv", f.path},
                                    out, err);
     EXPECT_EQ(code, 1);
     EXPECT_NE(err.str().find("invalid tag filter column"), std::string::npos)
         << err.str();
 }
 
+TEST(CliE2E, TagFiltersDistinguishNullEmptyAndLiteralNull) {
+    std::string path = tsfile_cli_test::write_nullable_tag_filter_fixture();
+
+    struct Case {
+        std::vector<std::string> filter;
+        std::string expected_row;
+    };
+    const std::vector<Case> cases = {
+        {{"id1", "is-null"}, "0,\\N,10\n"},
+        {{"id1", "eq", ""}, "1,\"\",20\n"},
+        {{"id1", "eq", "null"}, "2,null,30\n"},
+    };
+    for (const Case& test_case : cases) {
+        std::vector<std::string> args = {"cat", "-m", "s1", "--tag-filter"};
+        args.insert(args.end(), test_case.filter.begin(),
+                    test_case.filter.end());
+        args.insert(args.end(), {"-f", "csv", path});
+        std::ostringstream out;
+        std::ostringstream err;
+        ASSERT_EQ(tsfile_cli::run_cli(args, out, err), 0) << err.str();
+        EXPECT_EQ(out.str(), "time,id1,s1\n" + test_case.expected_row);
+    }
+
+    std::ostringstream not_null_out;
+    std::ostringstream not_null_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1",
+                                   "not-null", "-f", "csv", path},
+                                  not_null_out, not_null_err),
+              0)
+        << not_null_err.str();
+    EXPECT_EQ(not_null_out.str().find("0,\\N,10"), std::string::npos)
+        << not_null_out.str();
+    EXPECT_NE(not_null_out.str().find("1,\"\",20"), std::string::npos)
+        << not_null_out.str();
+
+    std::ostringstream neq_out;
+    std::ostringstream neq_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1",
+                                   "neq", "dev_a", "-f", "csv", path},
+                                  neq_out, neq_err),
+              0)
+        << neq_err.str();
+    EXPECT_EQ(neq_out.str().find("0,\\N,10"), std::string::npos)
+        << neq_out.str();
+    EXPECT_EQ(neq_out.str().find("3,dev_a,40"), std::string::npos)
+        << neq_out.str();
+    EXPECT_NE(neq_out.str().find("4,dev_b,50"), std::string::npos)
+        << neq_out.str();
+
+    std::remove(path.c_str());
+}
+
+TEST(CliE2E, TagRegexpUsesFullValueAndRejectsInvalidPatterns) {
+    std::string path = tsfile_cli_test::write_nullable_tag_filter_fixture();
+
+    std::ostringstream substring_out;
+    std::ostringstream substring_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1",
+                                   "regexp", "dev", "-f", "csv", path},
+                                  substring_out, substring_err),
+              0)
+        << substring_err.str();
+    EXPECT_EQ(substring_out.str(), "time,id1,s1\n");
+
+    std::ostringstream full_out;
+    std::ostringstream full_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1",
+                                   "regexp", "dev_.*", "-f", "csv", path},
+                                  full_out, full_err),
+              0)
+        << full_err.str();
+    EXPECT_NE(full_out.str().find("3,dev_a,40"), std::string::npos)
+        << full_out.str();
+    EXPECT_NE(full_out.str().find("4,dev_b,50"), std::string::npos)
+        << full_out.str();
+
+    std::ostringstream invalid_out;
+    std::ostringstream invalid_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1",
+                                   "regexp", "[", "-f", "csv", path},
+                                  invalid_out, invalid_err),
+              1);
+    EXPECT_TRUE(invalid_out.str().empty());
+    EXPECT_NE(invalid_err.str().find("invalid regular expression"),
+              std::string::npos)
+        << invalid_err.str();
+
+    std::remove(path.c_str());
+}
+
+TEST(CliE2E, MultipleTagFiltersHonorAll) {
+    std::string path = tsfile_cli_test::write_nullable_tag_filter_fixture();
+    std::ostringstream out;
+    std::ostringstream err;
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"cat", "-m", "s1", "--tag-filter", "id1", "neq",
+                             "dev_a", "--tag-filter", "id1", "regexp", "dev_.*",
+                             "--tag-match", "all", "-f", "csv", path},
+                            out, err),
+        0)
+        << err.str();
+    EXPECT_EQ(out.str(), "time,id1,s1\n4,dev_b,50\n");
+    std::remove(path.c_str());
+}
+
+TEST(CliE2E, RowWindowDistinguishesExactAndExcessiveOffset) {
+    Fixture f;
+    std::ostringstream exact_out;
+    std::ostringstream exact_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-m", "s1", "--offset", "5", "-f", "csv", f.path},
+                  exact_out, exact_err),
+              0)
+        << exact_err.str();
+    EXPECT_EQ(exact_out.str(), "time,id1,id2,s1\n");
+
+    std::ostringstream excessive_out;
+    std::ostringstream excessive_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-m", "s1", "--offset", "6", "-f", "csv", f.path},
+                  excessive_out, excessive_err),
+              1);
+    EXPECT_TRUE(excessive_out.str().empty());
+    EXPECT_NE(excessive_err.str().find("offset exceeds matched row count"),
+              std::string::npos)
+        << excessive_err.str();
+}
+
+TEST(CliE2E, ZeroLimitUsesEachFormatsZeroRowContract) {
+    Fixture f;
+    std::ostringstream csv_out;
+    std::ostringstream csv_err;
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"cat", "-m", "s1", "-n", "0", "-f", "csv", f.path},
+                            csv_out, csv_err),
+        0)
+        << csv_err.str();
+    EXPECT_EQ(csv_out.str(), "time,id1,id2,s1\n");
+
+    std::ostringstream ndjson_out;
+    std::ostringstream ndjson_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-m", "s1", "-n", "0", "-f", "ndjson", f.path},
+                  ndjson_out, ndjson_err),
+              0)
+        << ndjson_err.str();
+    EXPECT_TRUE(ndjson_out.str().empty());
+
+    std::ostringstream table_out;
+    std::ostringstream table_err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"cat", "-m", "s1", "-n", "0", "-f", "table", f.path},
+                  table_out, table_err),
+              0)
+        << table_err.str();
+    EXPECT_NE(table_out.str().find("time"), std::string::npos)
+        << table_out.str();
+    EXPECT_NE(table_out.str().find("s1"), std::string::npos) << table_out.str();
+    EXPECT_EQ(table_out.str().find("id1_field_1"), std::string::npos)
+        << table_out.str();
+}
+
 TEST(CliE2E, CatJsonIsNdjson) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli(
-        {"cat", "-m", "s1", "--start", "0", "--end", "0", "-f", "json", f.path},
-        out, err);
+    int code = tsfile_cli::run_cli({"cat", "-m", "s1", "--start", "0", "--end",
+                                    "0", "-f", "ndjson", f.path},
+                                   out, err);
     EXPECT_EQ(code, 0);
-    EXPECT_EQ(out.str(), "{\"time\":0,\"s1\":0}\n");
+    EXPECT_EQ(out.str(),
+              "{\"time\":\"0\",\"id1\":\"id1_field_1\",\"id2\":"
+              "\"id2_field_2\",\"s1\":\"0\"}\n");
+}
+
+TEST(CliE2E, StdoutFlushFailureReturnsRuntimeError) {
+    Fixture f;
+    FlushFailingStreamBuf buffer;
+    std::ostream out(&buffer);
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli({"cat", "-f", "csv", f.path}, out, err), 3);
+    EXPECT_NE(err.str().find("failed to read rows"), std::string::npos)
+        << err.str();
 }
 
 TEST(CliE2E, MetaReportsFileSummary) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"meta", "-f", "tsv", f.path}, out, err);
+    int code = tsfile_cli::run_cli({"meta", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
     EXPECT_TRUE(err.str().empty());
-    EXPECT_NE(out.str().find("file\tmodel\tdevice_count\ttable_count\tseries_"
-                             "count\tstart_time\tend_time\tfile_size_bytes"),
-              std::string::npos);
-    EXPECT_NE(out.str().find("\ttable\t"), std::string::npos);
+    EXPECT_NE(out.str().find("size_bytes,format_version,model\n"),
+              std::string::npos)
+        << out.str();
+    EXPECT_NE(out.str().find(",4,table\n"), std::string::npos) << out.str();
+}
+
+TEST(CliE2E, MetaRejectsUnsupportedFileHeaderVersion) {
+    Fixture f;
+    std::fstream file(f.path.c_str(),
+                      std::ios::in | std::ios::out | std::ios::binary);
+    ASSERT_TRUE(file.good());
+    file.seekp(storage::MAGIC_STRING_TSFILE_LEN);
+    file.put(static_cast<char>(storage::VERSION_NUM_BYTE + 1));
+    file.close();
+
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli({"meta", "-f", "csv", f.path}, out, err), 2);
+    EXPECT_TRUE(out.str().empty());
 }
 
-TEST(CliE2E, CountReportsSeriesCountsAndTotal) {
+TEST(CliE2E, CountReportsColumnCountsWithoutSummaryRows) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"count", "-f", "tsv", f.path}, out, err);
+    int code = tsfile_cli::run_cli({"count", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
     EXPECT_TRUE(err.str().empty());
-    EXPECT_NE(out.str().find("target\tmeasurement\tcount"), std::string::npos);
-    EXPECT_NE(out.str().find("\ts1\t5"), std::string::npos);
-    EXPECT_NE(out.str().find("total\t\t"), std::string::npos);
+    EXPECT_NE(out.str().find("model,object,column,category,row_count,entity_"
+                             "count,non_null_count,null_count,min_time,"
+                             "max_time,time_source"),
+              std::string::npos)
+        << out.str();
+    EXPECT_NE(out.str().find("table,table1,id1,TAG,5,1,5,0,0,4,scan"),
+              std::string::npos)
+        << out.str();
+    EXPECT_NE(out.str().find("table,table1,s1,FIELD,5,1,5,0,0,4,scan"),
+              std::string::npos)
+        << out.str();
+    EXPECT_EQ(out.str().find("total"), std::string::npos) << out.str();
+}
+
+TEST(CliE2E, CountAndStatsDefaultToAllTables) {
+    MultiTableFixture f;
+    std::ostringstream count_out;
+    std::ostringstream count_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"count", "-f", "csv", f.path}, count_out,
+                                  count_err),
+              0)
+        << count_err.str();
+    EXPECT_NE(count_out.str().find("table,sensors_a,s1,FIELD,1,1,1,0,0,0,scan"),
+              std::string::npos)
+        << count_out.str();
+    EXPECT_NE(count_out.str().find("table,sensors_b,s1,FIELD,1,1,1,0,0,0,scan"),
+              std::string::npos)
+        << count_out.str();
+
+    std::ostringstream stats_out;
+    std::ostringstream stats_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"stats", "-f", "csv", f.path}, stats_out,
+                                  stats_err),
+              0)
+        << stats_err.str();
+    EXPECT_NE(stats_out.str().find("table,sensors_a,sensors_a_tag,s1,INT64"),
+              std::string::npos)
+        << stats_out.str();
+    EXPECT_NE(stats_out.str().find("table,sensors_b,sensors_b_tag,s1,INT64"),
+              std::string::npos)
+        << stats_out.str();
+}
+
+TEST(CliE2E, CountAndStatsProjectionMayMatchOnlySomeTables) {
+    DisjointTableFixture f;
+    std::ostringstream count_out;
+    std::ostringstream count_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"count", "-m", "S1", "-f", "csv", f.path},
+                                  count_out, count_err),
+              0)
+        << count_err.str();
+    EXPECT_NE(count_out.str().find("table,sensors_a,s1,FIELD"),
+              std::string::npos)
+        << count_out.str();
+    EXPECT_EQ(count_out.str().find("table,sensors_b"), std::string::npos)
+        << count_out.str();
+
+    std::ostringstream stats_out;
+    std::ostringstream stats_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"stats", "-m", "S1", "-f", "csv", f.path},
+                                  stats_out, stats_err),
+              0)
+        << stats_err.str();
+    EXPECT_NE(stats_out.str().find("table,sensors_a,sensors_a_tag,s1,INT64"),
+              std::string::npos)
+        << stats_out.str();
+    EXPECT_EQ(stats_out.str().find("table,sensors_b"), std::string::npos)
+        << stats_out.str();
+}
+
+TEST(CliE2E, CountAndStatsProjectionMayMatchOnlySomeTreeDevices) {
+    DisjointTreeFixture f;
+    std::ostringstream count_out;
+    std::ostringstream count_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"count", "-m", "left", "-f", "csv", f.path},
+                                  count_out, count_err),
+              0)
+        << count_err.str();
+    EXPECT_NE(count_out.str().find("tree,root.test.d1,left,FIELD"),
+              std::string::npos)
+        << count_out.str();
+    EXPECT_EQ(count_out.str().find("tree,root.test.d2"), std::string::npos)
+        << count_out.str();
+
+    std::ostringstream stats_out;
+    std::ostringstream stats_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"stats", "-m", "left", "-f", "csv", f.path},
+                                  stats_out, stats_err),
+              0)
+        << stats_err.str();
+    EXPECT_NE(stats_out.str().find("tree,root.test.d1,left,INT32"),
+              std::string::npos)
+        << stats_out.str();
+    EXPECT_EQ(stats_out.str().find("tree,root.test.d2"), std::string::npos)
+        << stats_out.str();
+}
+
+TEST(CliE2E, TreeCountAndStatsUseDeviceTimestampUnion) {
+    SparseTreeFixture f;
+    std::ostringstream count_out;
+    std::ostringstream count_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"count", "-f", "csv", f.path}, count_out,
+                                  count_err),
+              0)
+        << count_err.str();
+    EXPECT_NE(count_out.str().find(
+                  "tree,root.test.d1,left,FIELD,3,\\N,2,1,0,2,statistics"),
+              std::string::npos)
+        << count_out.str();
+    EXPECT_NE(count_out.str().find(
+                  "tree,root.test.d1,right,FIELD,3,\\N,2,1,1,2,statistics"),
+              std::string::npos)
+        << count_out.str();
+
+    std::ostringstream stats_out;
+    std::ostringstream stats_err;
+    ASSERT_EQ(tsfile_cli::run_cli({"stats", "-f", "csv", f.path}, stats_out,
+                                  stats_err),
+              0)
+        << stats_err.str();
+    EXPECT_NE(stats_out.str().find(
+                  "tree,root.test.d1,left,INT32,2,1,0,2,10,20,10,20,30,"
+                  "statistics"),
+              std::string::npos)
+        << stats_out.str();
+    EXPECT_NE(stats_out.str().find(
+                  "tree,root.test.d1,right,BOOLEAN,2,1,1,2,\\N,\\N,true,false,"
+                  "1,statistics"),
+              std::string::npos)
+        << stats_out.str();
 }
 
 TEST(CliE2E, MetadataTableFilterIsCaseInsensitive) {
@@ -273,56 +666,35 @@ TEST(CliE2E, MetadataTableFilterIsCaseInsensitive) {
     std::ostringstream schema_out;
     std::ostringstream schema_err;
     EXPECT_EQ(
-        tsfile_cli::run_cli({"schema", "-t", "TABLE1", "-f", "tsv", f.path},
+        tsfile_cli::run_cli({"schema", "-t", "TABLE1", "-f", "csv", f.path},
                             schema_out, schema_err),
         0);
-    EXPECT_NE(schema_out.str().find("table1\ts1\tINT64"), std::string::npos)
+    EXPECT_NE(schema_out.str().find("table,table1,s1,FIELD,INT64"),
+              std::string::npos)
         << schema_out.str();
 
     std::ostringstream count_out;
     std::ostringstream count_err;
     EXPECT_EQ(
-        tsfile_cli::run_cli({"count", "-t", "TABLE1", "-f", "tsv", f.path},
+        tsfile_cli::run_cli({"count", "-t", "TABLE1", "-f", "csv", f.path},
                             count_out, count_err),
         0);
-    EXPECT_NE(count_out.str().find("table1.id1_field_1.id2_field_2\ts1\t5"),
+    EXPECT_NE(count_out.str().find("table,table1,s1,FIELD,5,1,5,0,0,4,scan"),
               std::string::npos)
         << count_out.str();
 
     std::ostringstream stats_out;
     std::ostringstream stats_err;
     EXPECT_EQ(
-        tsfile_cli::run_cli({"stats", "-t", "TABLE1", "-f", "tsv", f.path},
+        tsfile_cli::run_cli({"stats", "-t", "TABLE1", "-f", "csv", f.path},
                             stats_out, stats_err),
         0);
-    EXPECT_NE(stats_out.str().find("table1.id1_field_1.id2_field_2\ts1\t5"),
+    EXPECT_NE(stats_out.str().find("table,table1,id1_field_1,id2_field_2,s1,"
+                                   "INT64,5,\\N,0,4,0,40,0,40,\\N,statistics"),
               std::string::npos)
         << stats_out.str();
 }
 
-TEST(CliE2E, SampleIsReproducibleWithSeed) {
-    Fixture f;
-    std::ostringstream out1;
-    std::ostringstream err1;
-    std::ostringstream out2;
-    std::ostringstream err2;
-
-    int code1 = tsfile_cli::run_cli(
-        {"sample", "-m", "s1", "-n", "3", "--seed", "7", "-f", "tsv", f.path},
-        out1, err1);
-    int code2 = tsfile_cli::run_cli(
-        {"sample", "-m", "s1", "-n", "3", "--seed", "7", "-f", "tsv", f.path},
-        out2, err2);
-
-    EXPECT_EQ(code1, 0);
-    EXPECT_EQ(code2, 0);
-    EXPECT_TRUE(err1.str().empty());
-    EXPECT_TRUE(err2.str().empty());
-    EXPECT_EQ(out1.str(), out2.str());
-    EXPECT_EQ(count_lines(out1.str()), 4u);
-    EXPECT_NE(out1.str().find("time\ts1\n"), std::string::npos);
-}
-
 TEST(CliE2E, WriteThenReadRoundTrip) {
     std::string csv_path =
         tsfile_cli_test::unique_temp_path("tsfile_cli_write_in", ".csv");
@@ -336,24 +708,26 @@ TEST(CliE2E, WriteThenReadRoundTrip) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t1", "--columns", "id1:STRING:tag,s1:INT64:field",
-         "-o", out_path, csv_path},
+        {"write", "--table", "t1", "--tag", "id1", "STRING", "--field", "s1",
+         "INT64", "-i", csv_path, "-o", out_path},
         wout, werr);
     EXPECT_EQ(wc, 0) << werr.str();
 
     std::ostringstream cout_;
     std::ostringstream cerr_;
     int cc =
-        tsfile_cli::run_cli({"count", "-f", "tsv", out_path}, cout_, cerr_);
+        tsfile_cli::run_cli({"count", "-f", "csv", out_path}, cout_, cerr_);
     EXPECT_EQ(cc, 0);
-    EXPECT_NE(cout_.str().find("\ts1\t3"), std::string::npos) << cout_.str();
+    EXPECT_NE(cout_.str().find("table,t1,s1,FIELD,3,1,3,0,0,2,scan"),
+              std::string::npos)
+        << cout_.str();
 
     std::ostringstream rout;
     std::ostringstream rerr;
-    int rc = tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "tsv", out_path},
+    int rc = tsfile_cli::run_cli({"cat", "-m", "s1", "-f", "csv", out_path},
                                  rout, rerr);
     EXPECT_EQ(rc, 0);
-    EXPECT_EQ(rout.str(), "time\ts1\n0\t0\n1\t10\n2\t20\n");
+    EXPECT_EQ(rout.str(), "time,id1,s1\n0,dev,0\n1,dev,10\n2,dev,20\n");
 
     std::remove(csv_path.c_str());
     std::remove(out_path.c_str());
@@ -372,16 +746,15 @@ TEST(CliE2E, WriteThenReadFloatDoubleRoundTripLossless) {
 
     std::ostringstream wout;
     std::ostringstream werr;
-    int wc =
-        tsfile_cli::run_cli({"write", "--table", "t1", "--columns",
-                             "id1:STRING:tag,f1:FLOAT:field,d1:DOUBLE:field",
-                             "-o", out_path, csv_path},
-                            wout, werr);
+    int wc = tsfile_cli::run_cli(
+        {"write", "--table", "t1", "--tag", "id1", "STRING", "--field", "f1",
+         "FLOAT", "--field", "d1", "DOUBLE", "-i", csv_path, "-o", out_path},
+        wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     std::ostringstream rout;
     std::ostringstream rerr;
-    int rc = tsfile_cli::run_cli({"cat", "-f", "json", out_path}, rout, rerr);
+    int rc = tsfile_cli::run_cli({"cat", "-f", "ndjson", out_path}, rout, rerr);
     ASSERT_EQ(rc, 0) << rerr.str();
     // Default ostream precision (6 sig digits) would print 0.1 / 3.40282 and
     // lose bits; max_digits10 keeps every digit needed to round-trip.
@@ -409,21 +782,23 @@ TEST(CliE2E, WriteImportsQuotedFieldWithEmbeddedNewline) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t1", "--columns",
-         "id1:STRING:tag,note:TEXT:field", "-o", out_path, csv_path},
+        {"write", "--table", "t1", "--tag", "id1", "STRING", "--field", "note",
+         "TEXT", "-i", csv_path, "-o", out_path},
         wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     std::ostringstream cout_;
     std::ostringstream cerr_;
     ASSERT_EQ(
-        tsfile_cli::run_cli({"count", "-f", "tsv", out_path}, cout_, cerr_), 0);
-    EXPECT_NE(cout_.str().find("\tnote\t2"), std::string::npos) << cout_.str();
+        tsfile_cli::run_cli({"count", "-f", "csv", out_path}, cout_, cerr_), 0);
+    EXPECT_NE(cout_.str().find("table,t1,note,FIELD,2,1,2,0,0,1,scan"),
+              std::string::npos)
+        << cout_.str();
 
     std::ostringstream rout;
     std::ostringstream rerr;
-    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-f", "json", out_path}, rout, rerr),
-              0);
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"cat", "-f", "ndjson", out_path}, rout, rerr), 0);
     EXPECT_NE(rout.str().find("line one\\nline two"), std::string::npos)
         << rout.str();
 
@@ -437,7 +812,7 @@ TEST(CliE2E, WriteMissingColumnsIsUsageError) {
     int code = tsfile_cli::run_cli(
         {"write", "--table", "t1", "-o", "x.tsfile", "in.csv"}, out, err);
     EXPECT_EQ(code, 1);
-    EXPECT_NE(err.str().find("--columns"), std::string::npos);
+    EXPECT_NE(err.str().find("--field"), std::string::npos);
 }
 
 namespace {
@@ -459,10 +834,10 @@ TEST(CliE2E, WriteRejectsOutOfOrderTimestampsAndLeavesNoOutput) {
 
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"write", "--table", "t", "--columns",
-                                    "s1:INT64:field", "-o", out_path, csv},
+    int code = tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                    "INT64", "-i", csv, "-o", out_path},
                                    out, err);
-    EXPECT_EQ(code, 3);
+    EXPECT_EQ(code, 2);
     EXPECT_NE(err.str().find("strictly increasing"), std::string::npos)
         << err.str();
     EXPECT_NE(err.str().find("line 3"), std::string::npos) << err.str();
@@ -485,15 +860,17 @@ TEST(CliE2E, WriteAllowsSameTimestampAcrossDevices) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns", "id:STRING:tag,s1:INT64:field",
-         "-o", out_path, csv},
+        {"write", "--table", "t", "--tag", "id", "STRING", "--field", "s1",
+         "INT64", "-i", csv, "-o", out_path},
         out, err);
     EXPECT_EQ(code, 0) << err.str();
 
     std::ostringstream cout_;
     std::ostringstream cerr_;
-    tsfile_cli::run_cli({"count", "-f", "tsv", out_path}, cout_, cerr_);
-    EXPECT_NE(cout_.str().find("total\t\t3"), std::string::npos) << cout_.str();
+    tsfile_cli::run_cli({"count", "-f", "csv", out_path}, cout_, cerr_);
+    EXPECT_NE(cout_.str().find("table,t,s1,FIELD,3,2,3,0,1,2,scan"),
+              std::string::npos)
+        << cout_.str();
 
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
@@ -508,10 +885,10 @@ TEST(CliE2E, WriteRejectsOutputEqualsInput) {
     }
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"write", "--table", "t", "--columns",
-                                    "s1:INT64:field", "-o", csv, csv},
+    int code = tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                    "INT64", "-i", csv, "-o", csv},
                                    out, err);
-    EXPECT_EQ(code, 1);
+    EXPECT_EQ(code, 3);
     EXPECT_NE(err.str().find("same as the input"), std::string::npos)
         << err.str();
     // The input file must be untouched.
@@ -535,10 +912,10 @@ TEST(CliE2E, WriteFailureOnBadValueLeavesNoOutput) {
 
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"write", "--table", "t", "--columns",
-                                    "s1:INT64:field", "-o", out_path, csv},
+    int code = tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                    "INT64", "-i", csv, "-o", out_path},
                                    out, err);
-    EXPECT_EQ(code, 3);
+    EXPECT_EQ(code, 2);
     EXPECT_FALSE(path_exists(out_path));
 
     std::remove(csv.c_str());
@@ -549,20 +926,70 @@ TEST(CliE2E, WriteRejectsDuplicateColumnNames) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns", "s1:INT64:field,s1:INT64:field",
-         "-o", "x.tsfile", "-"},
+        {"write", "--table", "t", "--field", "s1", "INT64", "--field", "s1",
+         "INT64", "--stdin", "-o", "x.tsfile"},
         out, err);
     EXPECT_EQ(code, 1);
     EXPECT_NE(err.str().find("duplicate column"), std::string::npos)
         << err.str();
 }
 
+TEST(CliE2E, WriteRejectsTagOnlySchema) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli({"write", "--table", "t", "--tag", "id",
+                                    "STRING", "--stdin", "-o", "x.tsfile"},
+                                   out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_NE(err.str().find("--field"), std::string::npos) << err.str();
+}
+
+TEST(CliE2E, WriteRejectsNonStringTag) {
+    std::ostringstream out;
+    std::ostringstream err;
+    int code = tsfile_cli::run_cli(
+        {"write", "--table", "t", "--tag", "id", "INT64", "--field", "s1",
+         "INT64", "--stdin", "-o", "x.tsfile"},
+        out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_NE(err.str().find("must use STRING"), std::string::npos)
+        << err.str();
+}
+
+TEST(CliE2E, WriteNormalizesNamesAndHeaderCase) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_case", ".csv");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,ID,S1\n0,a,1\n";
+    }
+    std::string output =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_case_out", ".tsfile");
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli(
+                  {"write", "--table", "Mixed", "--tag", "Id", "STRING",
+                   "--field", "s1", "INT64", "-i", csv, "-o", output},
+                  out, err),
+              0)
+        << err.str();
+    std::ostringstream schema_out;
+    std::ostringstream schema_err;
+    EXPECT_EQ(tsfile_cli::run_cli({"schema", "-f", "csv", output}, schema_out,
+                                  schema_err),
+              0);
+    EXPECT_NE(schema_out.str().find("table,mixed,id,TAG,STRING"),
+              std::string::npos);
+    std::remove(csv.c_str());
+    std::remove(output.c_str());
+}
+
 TEST(CliE2E, WriteRejectsHeaderMatchWithNoHeader) {
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns", "s1:INT64:field", "-o",
-         "x.tsfile", "--no-header", "--header-match", "-"},
+        {"write", "--table", "t", "--field", "s1", "INT64", "-o", "x.tsfile",
+         "--stdin", "--no-header", "--header-match"},
         out, err);
     EXPECT_EQ(code, 1);
     EXPECT_NE(err.str().find("--header-match"), std::string::npos) << err.str();
@@ -592,11 +1019,11 @@ TEST(CliE2E, SchemaTableShowsEncodingAndCompression) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"schema", "-f", "tsv", f.path}, out, err);
+    int code = tsfile_cli::run_cli({"schema", "-f", "csv", f.path}, out, err);
     EXPECT_EQ(code, 0);
     // Table-model schema must report the fixture's configured encoding and
     // compression rather than blanks.
-    EXPECT_NE(out.str().find("\ts1\tINT64\tPLAIN\tUNCOMPRESSED\n"),
+    EXPECT_NE(out.str().find(",s1,FIELD,INT64,PLAIN,UNCOMPRESSED\n"),
               std::string::npos)
         << out.str();
 }
@@ -616,10 +1043,9 @@ int write_one_value(const std::string& type, const std::string& value,
         tsfile_cli_test::unique_temp_path("tsfile_cli_ovf_out", ".tsfile");
     std::ostringstream out;
     std::ostringstream err;
-    int code =
-        tsfile_cli::run_cli({"write", "--table", "t", "--columns",
-                             "s1:" + type + ":field", "-o", out_path, csv},
-                            out, err);
+    int code = tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                    type, "-i", csv, "-o", out_path},
+                                   out, err);
     err_out = err.str();
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
@@ -629,7 +1055,7 @@ int write_one_value(const std::string& type, const std::string& value,
 
 TEST(CliE2E, WriteRejectsInt32Overflow) {
     std::string err;
-    EXPECT_EQ(write_one_value("INT32", "3000000000", err), 3);
+    EXPECT_EQ(write_one_value("INT32", "3000000000", err), 2);
     EXPECT_NE(err.find("INT32 out of range"), std::string::npos) << err;
 }
 
@@ -640,22 +1066,130 @@ TEST(CliE2E, WriteAcceptsInt32Boundary) {
 
 TEST(CliE2E, WriteRejectsInt64Overflow) {
     std::string err;
-    EXPECT_EQ(write_one_value("INT64", "99999999999999999999999999", err), 3);
+    EXPECT_EQ(write_one_value("INT64", "99999999999999999999999999", err), 2);
     EXPECT_NE(err.find("INT64 out of range"), std::string::npos) << err;
 }
 
 TEST(CliE2E, WriteRejectsDoubleOverflow) {
     std::string err;
-    EXPECT_EQ(write_one_value("DOUBLE", "1e400", err), 3);
+    EXPECT_EQ(write_one_value("DOUBLE", "1e400", err), 2);
     EXPECT_NE(err.find("DOUBLE out of range"), std::string::npos) << err;
 }
 
 TEST(CliE2E, WriteRejectsNonNumericInt64) {
     std::string err;
-    EXPECT_EQ(write_one_value("INT64", "12abc", err), 3);
+    EXPECT_EQ(write_one_value("INT64", "12abc", err), 2);
     EXPECT_NE(err.find("bad INT64"), std::string::npos) << err;
 }
 
+TEST(CliE2E, WriteDateRequiresStrictIsoLexicalForm) {
+    std::string err;
+    EXPECT_EQ(write_one_value("DATE", "2024-1-1", err), 2);
+    EXPECT_NE(err.find("want YYYY-MM-DD"), std::string::npos) << err;
+    EXPECT_EQ(write_one_value("DATE", "2024-02-30", err), 2);
+    EXPECT_EQ(write_one_value("DATE", "2024-02-29", err), 0) << err;
+}
+
+TEST(CliE2E, WriteAcceptsOneLeadingUtf8Bom) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_bom", ".csv");
+    {
+        std::ofstream o(csv.c_str(), std::ios::binary);
+        o << "\xEF\xBB\xBFtime,s1\n0,1\n";
+    }
+    std::string output =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_bom_out", ".tsfile");
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                   "INT64", "-i", csv, "-o", output},
+                                  out, err),
+              0)
+        << err.str();
+    std::remove(csv.c_str());
+    std::remove(output.c_str());
+}
+
+TEST(CliE2E, WriteRejectsInvalidUtf8AndMisplacedBomWithoutOutput) {
+    const std::string invalid_utf8 =
+        std::string("time,s1\n0,") + static_cast<char>(0xC3) + "(\n";
+    const std::string misplaced_bom =
+        "time,s1\n0,\xEF\xBB\xBF"
+        "1\n";
+    const std::string inputs[] = {invalid_utf8, misplaced_bom};
+
+    for (size_t i = 0; i < 2; ++i) {
+        std::string csv =
+            tsfile_cli_test::unique_temp_path("tsfile_cli_bad_utf8", ".csv");
+        std::string output = tsfile_cli_test::unique_temp_path(
+            "tsfile_cli_bad_utf8_out", ".tsfile");
+        {
+            std::ofstream file(csv.c_str(), std::ios::binary);
+            file.write(inputs[i].data(),
+                       static_cast<std::streamsize>(inputs[i].size()));
+        }
+        std::ostringstream out;
+        std::ostringstream err;
+        EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                       "INT64", "-i", csv, "-o", output},
+                                      out, err),
+                  2)
+            << err.str();
+        std::ifstream target(output.c_str(), std::ios::binary);
+        EXPECT_FALSE(target.good());
+        std::remove(csv.c_str());
+        std::remove(output.c_str());
+    }
+}
+
+TEST(CliE2E, WriteRejectsReservedAndControlCharacterNames) {
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t", "--field", "time",
+                                   "INT64", "--stdin", "-o", "unused.tsfile"},
+                                  out, err),
+              1);
+    EXPECT_NE(err.str().find("reserved"), std::string::npos) << err.str();
+
+    out.str("");
+    out.clear();
+    err.str("");
+    err.clear();
+    EXPECT_EQ(
+        tsfile_cli::run_cli({"write", "--table", "bad\nname", "--field", "s1",
+                             "INT64", "--stdin", "-o", "unused.tsfile"},
+                            out, err),
+        1);
+    EXPECT_NE(err.str().find("control"), std::string::npos) << err.str();
+}
+
+TEST(CliE2E, WriteFailurePreservesExistingTarget) {
+    std::string csv =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_existing", ".csv");
+    std::string output =
+        tsfile_cli_test::unique_temp_path("tsfile_cli_existing_out", ".tsfile");
+    {
+        std::ofstream o(csv.c_str());
+        o << "time,s1\n0,1\n";
+    }
+    {
+        std::ofstream o(output.c_str());
+        o << "sentinel";
+    }
+    std::ostringstream out;
+    std::ostringstream err;
+    EXPECT_EQ(tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                   "INT64", "-i", csv, "-o", output},
+                                  out, err),
+              3);
+    std::ifstream existing(output.c_str());
+    std::stringstream content;
+    content << existing.rdbuf();
+    EXPECT_EQ(content.str(), "sentinel");
+    std::remove(csv.c_str());
+    std::remove(output.c_str());
+}
+
 TEST(CliE2E, WriteRejectsOutOfOrderAcrossBatches) {
     // More than one 1024-row batch of ascending rows, then a violating
     // timestamp. The first batch is already flushed by the time the bad row is
@@ -676,10 +1210,10 @@ TEST(CliE2E, WriteRejectsOutOfOrderAcrossBatches) {
 
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"write", "--table", "t", "--columns",
-                                    "s1:INT64:field", "-o", out_path, csv},
+    int code = tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1",
+                                    "INT64", "-i", csv, "-o", out_path},
                                    out, err);
-    EXPECT_EQ(code, 3);
+    EXPECT_EQ(code, 2);
     EXPECT_NE(err.str().find("strictly increasing"), std::string::npos)
         << err.str();
     EXPECT_FALSE(path_exists(out_path));
@@ -703,27 +1237,30 @@ TEST(CliE2E, WriteStreamsLargeInputRoundTrips) {
 
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli({"write", "--table", "big", "--columns",
-                                    "s1:INT64:field", "-o", out_path, csv},
+    int code = tsfile_cli::run_cli({"write", "--table", "big", "--field", "s1",
+                                    "INT64", "-i", csv, "-o", out_path},
                                    out, err);
     EXPECT_EQ(code, 0) << err.str();
 
     std::ostringstream cout_;
     std::ostringstream cerr_;
-    tsfile_cli::run_cli({"count", "-f", "tsv", out_path}, cout_, cerr_);
-    EXPECT_NE(cout_.str().find("\ts1\t3000"), std::string::npos) << cout_.str();
+    tsfile_cli::run_cli({"count", "-f", "csv", out_path}, cout_, cerr_);
+    EXPECT_NE(cout_.str().find("table,big,s1,FIELD,3000,1,3000,0,1,3000,scan"),
+              std::string::npos)
+        << cout_.str();
 
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
 }
 
-TEST(CliE2E, HelpWithPositionalFilePrintsUsage) {
+TEST(CliE2E, HelpWithPositionalFileIsUsageError) {
     Fixture f;
     std::ostringstream out;
     std::ostringstream err;
     int code = tsfile_cli::run_cli({"cat", "--help", f.path}, out, err);
-    EXPECT_EQ(code, 0);
-    EXPECT_NE(out.str().find("Usage:"), std::string::npos) << out.str();
+    EXPECT_EQ(code, 1);
+    EXPECT_TRUE(out.str().empty());
+    EXPECT_NE(err.str().find("--help"), std::string::npos) << err.str();
 }
 
 TEST(CliE2E, StatsRejectsRowOnlyFlag) {
@@ -732,8 +1269,7 @@ TEST(CliE2E, StatsRejectsRowOnlyFlag) {
     std::ostringstream err;
     int code = tsfile_cli::run_cli({"stats", "--start", "1", f.path}, out, err);
     EXPECT_EQ(code, 1);
-    EXPECT_NE(err.str().find("only valid for head/cat/sample"),
-              std::string::npos)
+    EXPECT_NE(err.str().find("only valid for head/cat"), std::string::npos)
         << err.str();
 }
 
@@ -762,24 +1298,25 @@ TEST(CliE2E, WriteRoundTripsTimestampDateBlob) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t1", "--columns",
-         "id1:STRING:tag,ts1:TIMESTAMP:field,d1:DATE:field,b1:BLOB:field", "-o",
-         out_path, csv},
+        {"write", "--table", "t1", "--tag", "id1", "STRING", "--field", "ts1",
+         "TIMESTAMP", "--field", "d1", "DATE", "--field", "b1", "BLOB", "-o",
+         out_path, "-i", csv},
         wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     std::ostringstream rout;
     std::ostringstream rerr;
-    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-f", "tsv", out_path}, rout, rerr),
+    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-f", "csv", out_path}, rout, rerr),
               0)
         << rerr.str();
-    // TIMESTAMP prints as raw epoch ms, DATE as YYYY-MM-DD, BLOB as its bytes.
+    // TIMESTAMP stays a decimal string, DATE uses YYYY-MM-DD, and BLOB uses
+    // the external 0x-prefixed lowercase hex lexeme.
     EXPECT_NE(rout.str().find("1700000000000"), std::string::npos)
         << rout.str();
     EXPECT_NE(rout.str().find("2024-01-15"), std::string::npos) << rout.str();
     EXPECT_NE(rout.str().find("2024-12-31"), std::string::npos) << rout.str();
-    EXPECT_NE(rout.str().find("hello"), std::string::npos) << rout.str();
-    EXPECT_NE(rout.str().find("world"), std::string::npos) << rout.str();
+    EXPECT_NE(rout.str().find("0x68656c6c6f"), std::string::npos) << rout.str();
+    EXPECT_NE(rout.str().find("0x776f726c64"), std::string::npos) << rout.str();
 
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
@@ -787,7 +1324,7 @@ TEST(CliE2E, WriteRoundTripsTimestampDateBlob) {
 
 TEST(CliE2E, WriteRejectsBadDate) {
     std::string err;
-    EXPECT_EQ(write_one_value("DATE", "not-a-date", err), 3);
+    EXPECT_EQ(write_one_value("DATE", "not-a-date", err), 2);
     EXPECT_NE(err.find("bad DATE"), std::string::npos) << err;
 }
 
@@ -803,21 +1340,23 @@ TEST(CliE2E, WriteVerboseEchoesConfig) {
 
     std::ostringstream out;
     std::ostringstream err;
-    int code =
-        tsfile_cli::run_cli({"write", "--table", "vt", "--columns",
-                             "s1:INT64:field", "-v", "-o", out_path, csv},
-                            out, err);
+    int code = tsfile_cli::run_cli({"write", "--table", "vt", "--field", "s1",
+                                    "INT64", "-v", "-i", csv, "-o", out_path},
+                                   out, err);
     EXPECT_EQ(code, 0) << err.str();
-    EXPECT_NE(err.str().find("table=vt"), std::string::npos) << err.str();
-    EXPECT_NE(err.str().find("column s1:INT64:field"), std::string::npos)
+    EXPECT_NE(err.str().find("created model=table object=vt rows=1 output="),
+              std::string::npos)
+        << err.str();
+    EXPECT_NE(err.str().find("column=s1 category=FIELD data_type=INT64"),
+              std::string::npos)
         << err.str();
-    EXPECT_NE(err.str().find("wrote 1 rows"), std::string::npos) << err.str();
+    EXPECT_NE(err.str().find("source=default"), std::string::npos) << err.str();
 
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
 }
 
-TEST(CliE2E, WriteHeaderMatchReportsMismatchPosition) {
+TEST(CliE2E, WriteRejectsHeaderMatch) {
     std::string csv =
         tsfile_cli_test::unique_temp_path("tsfile_cli_hm", ".csv");
     {
@@ -829,14 +1368,12 @@ TEST(CliE2E, WriteHeaderMatchReportsMismatchPosition) {
 
     std::ostringstream out;
     std::ostringstream err;
-    int code = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns", "s1:INT64:field",
-         "--header-match", "-o", out_path, csv},
-        out, err);
-    EXPECT_EQ(code, 3);
-    EXPECT_NE(err.str().find("header column 2 is 'wrong'"), std::string::npos)
-        << err.str();
-    EXPECT_NE(err.str().find("expected 's1'"), std::string::npos) << err.str();
+    int code =
+        tsfile_cli::run_cli({"write", "--table", "t", "--field", "s1", "INT64",
+                             "--header-match", "-i", csv, "-o", out_path},
+                            out, err);
+    EXPECT_EQ(code, 1);
+    EXPECT_NE(err.str().find("--header-match"), std::string::npos) << err.str();
 
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
@@ -860,27 +1397,28 @@ TEST(CliE2E, WriteMapsEachColumnToItsOwnValue) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t1", "--columns",
-         "a_bool:BOOLEAN:field,b_int:INT32:field,c_long:INT64:field,"
-         "d_float:FLOAT:field,e_double:DOUBLE:field,f_str:STRING:field,"
-         "g_ts:TIMESTAMP:field,h_date:DATE:field",
-         "-o", out_path, csv},
+        {"write",   "--table", "t1",     "--field", "a_bool",   "BOOLEAN",
+         "--field", "b_int",   "INT32",  "--field", "c_long",   "INT64",
+         "--field", "d_float", "FLOAT",  "--field", "e_double", "DOUBLE",
+         "--field", "f_str",   "STRING", "--field", "g_ts",     "TIMESTAMP",
+         "--field", "h_date",  "DATE",   "-i",      csv,        "-o",
+         out_path},
         wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     std::ostringstream rout;
     std::ostringstream rerr;
-    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-f", "json", out_path}, rout, rerr),
-              0)
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"cat", "-f", "ndjson", out_path}, rout, rerr), 0)
         << rerr.str();
     const std::string& j = rout.str();
     EXPECT_NE(j.find("\"a_bool\":true"), std::string::npos) << j;
     EXPECT_NE(j.find("\"b_int\":42"), std::string::npos) << j;
-    EXPECT_NE(j.find("\"c_long\":9000000000"), std::string::npos) << j;
+    EXPECT_NE(j.find("\"c_long\":\"9000000000\""), std::string::npos) << j;
     EXPECT_NE(j.find("\"d_float\":1.5"), std::string::npos) << j;
     EXPECT_NE(j.find("\"e_double\":3.25"), std::string::npos) << j;
     EXPECT_NE(j.find("\"f_str\":\"hello\""), std::string::npos) << j;
-    EXPECT_NE(j.find("\"g_ts\":1700000000000"), std::string::npos) << j;
+    EXPECT_NE(j.find("\"g_ts\":\"1700000000000\""), std::string::npos) << j;
     EXPECT_NE(j.find("\"h_date\":\"2024-06-15\""), std::string::npos) << j;
 
     std::remove(csv.c_str());
@@ -906,26 +1444,29 @@ TEST(CliE2E, WriteMultiTypeAcrossBatchesRoundTrips) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns",
-         "id:STRING:tag,n:INT64:field,note:TEXT:field", "-o", out_path, csv},
+        {"write", "--table", "t", "--tag", "id", "STRING", "--field", "n",
+         "INT64", "--field", "note", "TEXT", "-i", csv, "-o", out_path},
         wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     std::ostringstream cout_;
     std::ostringstream cerr_;
     ASSERT_EQ(
-        tsfile_cli::run_cli({"count", "-f", "tsv", out_path}, cout_, cerr_), 0);
-    EXPECT_NE(cout_.str().find("\tn\t2500"), std::string::npos) << cout_.str();
+        tsfile_cli::run_cli({"count", "-f", "csv", out_path}, cout_, cerr_), 0);
+    EXPECT_NE(cout_.str().find("table,t,n,FIELD,2500,1,2500,0,0,2499,scan"),
+              std::string::npos)
+        << cout_.str();
 
     // Spot-check a row from the last batch keeps n and note paired correctly.
     std::ostringstream rout;
     std::ostringstream rerr;
     ASSERT_EQ(tsfile_cli::run_cli({"cat", "--start", "2400", "--end", "2400",
-                                   "-f", "json", out_path},
+                                   "-f", "ndjson", out_path},
                                   rout, rerr),
               0)
         << rerr.str();
-    EXPECT_NE(rout.str().find("\"n\":7200"), std::string::npos) << rout.str();
+    EXPECT_NE(rout.str().find("\"n\":\"7200\""), std::string::npos)
+        << rout.str();
     EXPECT_NE(rout.str().find("\"note\":\"row2400\""), std::string::npos)
         << rout.str();
 
@@ -950,16 +1491,16 @@ TEST(CliE2E, WriteRoundTripsQuotedSpecialChars) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns",
-         "id:STRING:tag,note:STRING:field", "-o", out_path, csv},
+        {"write", "--table", "t", "--tag", "id", "STRING", "--field", "note",
+         "STRING", "-i", csv, "-o", out_path},
         wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     // JSON escapes the embedded quotes; the comma is preserved verbatim.
     std::ostringstream rout;
     std::ostringstream rerr;
-    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-f", "json", out_path}, rout, rerr),
-              0)
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"cat", "-f", "ndjson", out_path}, rout, rerr), 0)
         << rerr.str();
     EXPECT_NE(rout.str().find("\"note\":\"a,b \\\"q\\\" c\""),
               std::string::npos)
@@ -972,20 +1513,20 @@ TEST(CliE2E, WriteRoundTripsQuotedSpecialChars) {
 TEST(CliE2E, WriteRejectsTimestampOverflow) {
     std::string err;
     EXPECT_EQ(write_one_value("TIMESTAMP", "99999999999999999999999999", err),
-              3);
+              2);
     EXPECT_NE(err.find("TIMESTAMP out of range"), std::string::npos) << err;
 }
 
 TEST(CliE2E, WriteRejectsNonNumericTimestampColumn) {
     std::string err;
-    EXPECT_EQ(write_one_value("TIMESTAMP", "not-a-number", err), 3);
+    EXPECT_EQ(write_one_value("TIMESTAMP", "not-a-number", err), 2);
     EXPECT_NE(err.find("bad TIMESTAMP"), std::string::npos) << err;
 }
 
 TEST(CliE2E, WriteRejectsImpossibleDate) {
     // Syntactically YYYY-MM-DD but not a real calendar date.
     std::string err;
-    EXPECT_EQ(write_one_value("DATE", "2024-13-40", err), 3);
+    EXPECT_EQ(write_one_value("DATE", "2024-13-40", err), 2);
     EXPECT_NE(err.find("bad DATE"), std::string::npos) << err;
 }
 
@@ -995,14 +1536,13 @@ TEST(CliE2E, WriteAcceptsDateBoundary) {
         << err;  // leap day
 }
 
-// An empty cell writes a null, which JSON renders as null (not the type's
-// zero).
-TEST(CliE2E, WriteEmptyCellBecomesNull) {
+// CSV nulls use unquoted \N; quoted empty strings stay distinct from null.
+TEST(CliE2E, WriteDistinguishesCsvNullAndEmptyString) {
     std::string csv =
         tsfile_cli_test::unique_temp_path("tsfile_cli_null", ".csv");
     {
         std::ofstream o(csv.c_str());
-        o << "time,id,n\n0,dev,\n";  // n is empty -> null
+        o << "time,id,n\n0,dev,\\N\n1,\"\",7\n";
     }
     std::string out_path =
         tsfile_cli_test::unique_temp_path("tsfile_cli_null_out", ".tsfile");
@@ -1010,17 +1550,18 @@ TEST(CliE2E, WriteEmptyCellBecomesNull) {
     std::ostringstream wout;
     std::ostringstream werr;
     int wc = tsfile_cli::run_cli(
-        {"write", "--table", "t", "--columns", "id:STRING:tag,n:INT64:field",
-         "-o", out_path, csv},
+        {"write", "--table", "t", "--tag", "id", "STRING", "--field", "n",
+         "INT64", "-i", csv, "-o", out_path},
         wout, werr);
     ASSERT_EQ(wc, 0) << werr.str();
 
     std::ostringstream rout;
     std::ostringstream rerr;
-    ASSERT_EQ(tsfile_cli::run_cli({"cat", "-f", "json", out_path}, rout, rerr),
-              0)
+    ASSERT_EQ(
+        tsfile_cli::run_cli({"cat", "-f", "ndjson", out_path}, rout, rerr), 0)
         << rerr.str();
     EXPECT_NE(rout.str().find("\"n\":null"), std::string::npos) << rout.str();
+    EXPECT_NE(rout.str().find("\"id\":\"\""), std::string::npos) << rout.str();
 
     std::remove(csv.c_str());
     std::remove(out_path.c_str());
diff --git a/cpp/test/tools/output_format_test.cc b/cpp/test/tools/output_format_test.cc
index 926772166..844d49464 100644
--- a/cpp/test/tools/output_format_test.cc
+++ b/cpp/test/tools/output_format_test.cc
@@ -22,6 +22,7 @@
 #include <gtest/gtest.h>
 
 #include <sstream>
+#include <streambuf>
 #include <vector>
 
 #include "common/db_common.h"
@@ -31,6 +32,21 @@ using tsfile_cli::OutputFormat;
 using tsfile_cli::ParsedArgs;
 using tsfile_cli::RowWriter;
 
+namespace {
+
+class FailingStreamBuf : public std::streambuf {
+   protected:
+    std::streamsize xsputn(const char*, std::streamsize) override { return 0; }
+    int_type overflow(int_type) override { return traits_type::eof(); }
+};
+
+class FlushFailingStreamBuf : public std::stringbuf {
+   protected:
+    int sync() override { return -1; }
+};
+
+}  // namespace
+
 TEST(ErrorCodeMessageTest, KnownCodesMapToReadablePhrases) {
     EXPECT_STREQ(tsfile_cli::error_code_message(common::E_TABLE_NOT_EXIST),
                  "table does not exist");
@@ -53,11 +69,11 @@ TEST(ErrorCodeMessageTest, UnknownCodeFallsBackToInternalError) {
     EXPECT_GT(std::string(tsfile_cli::error_code_message(-1)).size(), 0u);
 }
 
-TEST(ResolveFormatTest, AutoUsesTableOnTtyTsvOtherwise) {
+TEST(ResolveFormatTest, AutoAlwaysUsesTable) {
     EXPECT_EQ(tsfile_cli::resolve_format(ParsedArgs::Format::kAuto, true),
               OutputFormat::kTable);
     EXPECT_EQ(tsfile_cli::resolve_format(ParsedArgs::Format::kAuto, false),
-              OutputFormat::kTsv);
+              OutputFormat::kTable);
     EXPECT_EQ(tsfile_cli::resolve_format(ParsedArgs::Format::kJson, true),
               OutputFormat::kJson);
 }
@@ -119,22 +135,42 @@ TEST(RowWriterTest, NoHeaderSuppressesHeader) {
 
 TEST(RowWriterTest, CsvEscapesCells) {
     std::ostringstream out;
-    RowWriter w(out, OutputFormat::kCsv, {"name"}, {common::STRING}, false);
-    w.write({"a,b"}, {false});
+    RowWriter w(out, OutputFormat::kCsv, {"name", "note"},
+                {common::STRING, common::STRING}, false);
+    w.write({"a,b", ""}, {false, true});
+    w.write({"", ""}, {false, false});
     w.finish();
-    EXPECT_EQ(out.str(), "name\n\"a,b\"\n");
+    EXPECT_EQ(out.str(), "name,note\n\"a,b\",\\N\n\"\",\"\"\n");
 }
 
-TEST(RowWriterTest, JsonNumbersUnquotedStringsQuotedNullEmitted) {
+TEST(RowWriterTest, JsonQuotesInt64TimestampAndLeavesSmallNumbersBare) {
     std::ostringstream out;
-    RowWriter w(out, OutputFormat::kJson, {"time", "name"},
-                {common::INT64, common::STRING}, false);
-    w.write({"5", "dev1"}, {false, false});
-    w.write({"6", ""}, {false, true});
+    RowWriter w(
+        out, OutputFormat::kJson, {"time", "small", "ts", "name"},
+        {common::INT64, common::INT32, common::TIMESTAMP, common::STRING},
+        false);
+    w.write({"5", "10", "1700000000000", "dev1"}, {false, false, false, false});
+    w.write({"6", "11", "1700000000001", ""}, {false, false, false, true});
     w.finish();
     EXPECT_EQ(out.str(),
-              "{\"time\":5,\"name\":\"dev1\"}\n"
-              "{\"time\":6,\"name\":null}\n");
+              "{\"time\":\"5\",\"small\":10,\"ts\":\"1700000000000\","
+              "\"name\":\"dev1\"}\n"
+              "{\"time\":\"6\",\"small\":11,\"ts\":\"1700000000001\","
+              "\"name\":null}\n");
+}
+
+TEST(RowWriterTest, BlobCellsUseLowercaseHexLexeme) {
+    std::ostringstream json;
+    RowWriter jw(json, OutputFormat::kJson, {"payload"}, {common::BLOB}, false);
+    jw.write({std::string("A\0z", 3)}, {false});
+    jw.finish();
+    EXPECT_EQ(json.str(), "{\"payload\":\"0x41007a\"}\n");
+
+    std::ostringstream csv;
+    RowWriter cw(csv, OutputFormat::kCsv, {"payload"}, {common::BLOB}, false);
+    cw.write({"hello"}, {false});
+    cw.finish();
+    EXPECT_EQ(csv.str(), "payload\n0x68656c6c6f\n");
 }
 
 TEST(RowWriterTest, TableAlignsColumns) {
@@ -149,3 +185,21 @@ TEST(RowWriterTest, TableAlignsColumns) {
               "s1        INT64\n"
               "longname  BOOLEAN\n");
 }
+
+TEST(RowWriterTest, ReportsStreamWriteFailure) {
+    FailingStreamBuf buffer;
+    std::ostream out(&buffer);
+    RowWriter writer(out, OutputFormat::kCsv, {"name"}, {common::STRING},
+                     false);
+    EXPECT_FALSE(writer.write({"value"}, {false}));
+    EXPECT_FALSE(writer.finish());
+}
+
+TEST(RowWriterTest, ReportsFlushFailure) {
+    FlushFailingStreamBuf buffer;
+    std::ostream out(&buffer);
+    RowWriter writer(out, OutputFormat::kCsv, {"name"}, {common::STRING},
+                     false);
+    ASSERT_TRUE(writer.write({"value"}, {false}));
+    EXPECT_FALSE(writer.finish());
+}
diff --git a/cpp/test/tools/statistics_test.cc b/cpp/test/tools/statistics_test.cc
index a151fdc3c..c6c7d8738 100644
--- a/cpp/test/tools/statistics_test.cc
+++ b/cpp/test/tools/statistics_test.cc
@@ -23,7 +23,18 @@
 
 #include "common/statistic.h"
 
-TEST(StatisticsTest, Int64StatisticCellsContainValueSummaries) {
+TEST(StatisticsTest, Int32StatisticSupportsAllValueSummaries) {
+    storage::Int32Statistic st;
+    st.update(1, static_cast<int32_t>(10));
+    st.update(3, static_cast<int32_t>(30));
+    tsfile_cli::StatisticCells cells = tsfile_cli::statistic_value_cells(&st);
+    EXPECT_EQ(cells.values,
+              std::vector<std::string>({"10", "30", "10", "30", "40"}));
+    EXPECT_EQ(cells.is_null,
+              std::vector<bool>({false, false, false, false, false}));
+}
+
+TEST(StatisticsTest, Int64StatisticLeavesSumNull) {
     storage::Int64Statistic st;
     st.update(1, static_cast<int64_t>(10));
     st.update(3, static_cast<int64_t>(30));
@@ -32,9 +43,27 @@ TEST(StatisticsTest, Int64StatisticCellsContainValueSummaries) {
     EXPECT_EQ(cells.values[1], "30");
     EXPECT_EQ(cells.values[2], "10");
     EXPECT_EQ(cells.values[3], "30");
-    EXPECT_EQ(cells.values[4], "40");
+    EXPECT_TRUE(cells.values[4].empty());
     EXPECT_EQ(cells.is_null,
-              std::vector<bool>({false, false, false, false, false}));
+              std::vector<bool>({false, false, false, false, true}));
+}
+
+TEST(StatisticsTest, DateAndTimestampStatisticsLeaveSumNull) {
+    storage::DateStatistic date;
+    date.update(1, static_cast<int32_t>(19700101));
+    tsfile_cli::StatisticCells date_cells =
+        tsfile_cli::statistic_value_cells(&date);
+    EXPECT_EQ(date_cells.values[0], "1970-01-01");
+    EXPECT_EQ(date_cells.values[3], "1970-01-01");
+    EXPECT_TRUE(date_cells.is_null[4]);
+
+    storage::TimestampStatistics timestamp;
+    timestamp.update(1, static_cast<int64_t>(1700000000000));
+    tsfile_cli::StatisticCells timestamp_cells =
+        tsfile_cli::statistic_value_cells(&timestamp);
+    EXPECT_EQ(timestamp_cells.values[0], "1700000000000");
+    EXPECT_EQ(timestamp_cells.values[3], "1700000000000");
+    EXPECT_TRUE(timestamp_cells.is_null[4]);
 }
 
 TEST(StatisticsTest, BooleanStatisticLeavesMinMaxNull) {
@@ -48,3 +77,53 @@ TEST(StatisticsTest, BooleanStatisticLeavesMinMaxNull) {
     EXPECT_EQ(cells.values[3], "false");
     EXPECT_EQ(cells.values[4], "1");
 }
+
+TEST(StatisticsTest, DoubleStatisticPreservesRoundTripPrecision) {
+    storage::DoubleStatistic st;
+    st.update(1, 1.2345678901234567);
+    tsfile_cli::StatisticCells cells = tsfile_cli::statistic_value_cells(&st);
+    EXPECT_EQ(cells.values[0], "1.2345678901234567");
+    EXPECT_EQ(cells.values[4], "1.2345678901234567");
+}
+
+TEST(StatisticsTest, FloatStatisticSupportsAllValueSummaries) {
+    storage::FloatStatistic st;
+    st.update(1, 1.25F);
+    st.update(2, 2.5F);
+    tsfile_cli::StatisticCells cells = tsfile_cli::statistic_value_cells(&st);
+    EXPECT_EQ(cells.values,
+              std::vector<std::string>({"1.25", "2.5", "1.25", "2.5", "3.75"}));
+    EXPECT_EQ(cells.is_null,
+              std::vector<bool>({false, false, false, false, false}));
+}
+
+TEST(StatisticsTest, StringStatisticOmitsOnlySum) {
+    storage::StringStatistic st;
+    st.update(1, common::String("beta"));
+    st.update(2, common::String("alpha"));
+    tsfile_cli::StatisticCells cells = tsfile_cli::statistic_value_cells(&st);
+    EXPECT_EQ(cells.values[0], "alpha");
+    EXPECT_EQ(cells.values[1], "beta");
+    EXPECT_EQ(cells.values[2], "beta");
+    EXPECT_EQ(cells.values[3], "alpha");
+    EXPECT_EQ(cells.is_null,
+              std::vector<bool>({false, false, false, false, true}));
+}
+
+TEST(StatisticsTest, TextStatisticOnlyProvidesFirstAndLast) {
+    storage::TextStatistic st;
+    st.update(1, common::String("first"));
+    st.update(2, common::String("last"));
+    tsfile_cli::StatisticCells cells = tsfile_cli::statistic_value_cells(&st);
+    EXPECT_EQ(cells.values[2], "first");
+    EXPECT_EQ(cells.values[3], "last");
+    EXPECT_EQ(cells.is_null,
+              std::vector<bool>({true, true, false, false, true}));
+}
+
+TEST(StatisticsTest, BlobStatisticProvidesNoValueSummaries) {
+    storage::BlobStatistic st;
+    st.update(1, common::String("blob"));
+    tsfile_cli::StatisticCells cells = tsfile_cli::statistic_value_cells(&st);
+    EXPECT_EQ(cells.is_null, std::vector<bool>({true, true, true, true, true}));
+}
diff --git a/cpp/tools/CMakeLists.txt b/cpp/tools/CMakeLists.txt
index 4448feab2..00bc20ea0 100644
--- a/cpp/tools/CMakeLists.txt
+++ b/cpp/tools/CMakeLists.txt
@@ -36,8 +36,21 @@ target_include_directories(tsfile_cli_obj PUBLIC
 # can compile these sources before the headers exist.
 add_dependencies(tsfile_cli_obj tsfile)
 
+execute_process(
+        COMMAND git rev-parse HEAD
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        OUTPUT_VARIABLE TSFILE_CLI_GIT_COMMIT
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET)
+if (NOT TSFILE_CLI_GIT_COMMIT)
+    set(TSFILE_CLI_GIT_COMMIT "unknown")
+endif ()
+string(TIMESTAMP TSFILE_CLI_BUILD_TIME "%Y-%m-%dT%H:%M:%SZ" UTC)
+
 target_compile_definitions(tsfile_cli_obj PRIVATE
-        TSFILE_CLI_VERSION="${TsFile_CPP_VERSION}")
+        TSFILE_CLI_VERSION="${TsFile_CPP_VERSION}"
+        TSFILE_CLI_COMMIT="${TSFILE_CLI_GIT_COMMIT}"
+        TSFILE_CLI_BUILT="${TSFILE_CLI_BUILD_TIME}")
 
 add_executable(tsfile_cli tools_main.cc $<TARGET_OBJECTS:tsfile_cli_obj>)
 target_include_directories(tsfile_cli PRIVATE ${CMAKE_SOURCE_DIR}/tools)
diff --git a/cpp/tools/README.md b/cpp/tools/README.md
index 60f7acc07..37f704896 100644
--- a/cpp/tools/README.md
+++ b/cpp/tools/README.md
@@ -25,7 +25,7 @@
 importing Apache TsFile (`.tsfile`) files from the shell — the TsFile analogue of
 `parquet-cli` / `pqrs`. Read commands print data to **stdout** and diagnostics to
 **stderr**, so they compose with `awk`, `jq`, `sort`, and friends; the `write` command
-imports CSV/TSV into a new `.tsfile`. It is built on the public `storage::TsFileReader`
+imports CSV into a new `.tsfile`. It is built on the public `storage::TsFileReader`
 and `storage::TsFileTableWriter` APIs and does not modify the storage engine.
 
 ## Building from source
@@ -89,14 +89,15 @@ Exit codes: `0` success, `1` usage/argument error, `2` file open/corrupt,
 
 | Command | Description |
 |---|---|
-| `ls` | List devices (tree model) or tables (table model), one name per line |
-| `schema` | Per-series `target, measurement, datatype, encoding, compression` |
-| `meta` | File summary: model, device/table/series counts, time range, file size |
-| `stats` | Per-series `count, start_time, end_time, min, max, first, last, sum` |
-| `count` | Per-series row counts plus a `total` row (from statistics, no page scan) |
+| `ls` | List selected-model objects as `model, object` rows |
+| `schema` | List schema rows for devices or tables |
+| `meta` | File summary: `size_bytes`, `format_version`, and `model` |
+| `stats` | FIELD statistics with counts, null counts, time range, values, and source |
+| `count` | Object/column counts; no synthetic summary row |
+| `sketch` | Print the physical file sketch, optionally to `-o` |
 | `head` | First N rows (default 10; use `-n`) |
 | `cat` | All matching rows, streamed (`table` format buffers to align columns) |
-| `sample` | Reproducible reservoir sample (default 10; `-n`, `--seed`) |
+| `export` | Export one object to `-o`, or multiple objects to `--output-dir`, using `--type` |
 
 The metadata commands (`ls` / `schema` / `meta` / `stats` / `count`) answer most questions
 without decoding data pages.
@@ -105,73 +106,82 @@ Shared options:
 
 | Option | Meaning |
 |---|---|
-| `-f, --format csv\|tsv\|json\|table` | Output format; defaults to `table` on a TTY, `tsv` when piped |
+| `-f, --format table\|ndjson\|csv` | Output format; defaults to `table` |
 | `-d, --device <id>` / `-t, --table <name>` | Scope to one device / table (mutually exclusive) |
-| `-m, --measurements a,b,c` | Column projection (`schema`, `stats`, `count`, `head`, `cat`, `sample`) |
-| `-n, --limit N` / `--offset N` | Max rows / rows to skip (`head`, `cat`; `--offset` not valid for `sample`) |
-| `--start <ms>` / `--end <ms>` | Inclusive epoch-millisecond time range (`head`, `cat`, `sample`) |
-| `--seed N` | Reproducible sampling seed (`sample` only) |
-| `--tag-filter C OP V` / `--tag-between C L U` / `--tag-not-between C L U` | Table TAG predicate for `head`, `cat`, `sample`; `OP` is `eq`, `neq`, `lt`, `lteq`, `gt`, `gteq`, `regexp`, or `not-regexp` |
-| `--no-header` | Omit the header row |
-| `--model tree\|table` | Force the model (otherwise auto-detected) |
-
-`json` output is NDJSON (one object per line; numbers/booleans bare, other values quoted,
-nulls as `null`; non-finite floats — NaN/Inf — become `null`). CSV output follows RFC 4180.
-Timestamps are raw epoch milliseconds. The `table` format buffers all rows in memory to
-align columns, so prefer `csv`/`tsv`/`json` when dumping large files.
+| `-m, --measurements <name>` | Column projection; repeat once per column. For `stats`, only FIELD columns are valid |
+| `-n, --limit N` / `--offset N` | Max rows / rows to skip (`head`, `cat`, `export`) |
+| `--start <time>` / `--end <time>` | Inclusive raw int64 timestamp range (`head`, `cat`, `export`) |
+| `--tag-filter C OP [V]` | Table TAG predicate for row reads; `OP` is `eq`, `neq`, `regexp`, `is-null`, or `not-null` |
+| `--tag-match all\|any` | Required when more than one `--tag-filter` is supplied |
+
+`ndjson` output emits one JSON object per line; numbers/booleans are bare, other values are
+quoted, nulls are `null`, and non-finite floats become `null`. CSV output follows RFC 4180.
+CSV nulls are unquoted `\N`; empty strings are quoted as `""`. Timestamps are raw int64
+values. The `table` format uses a temporary spool to align columns with bounded
+memory; prefer `csv`/`ndjson` when temporary disk use is undesirable. `sketch`
+does not accept `--format`.
 
 ```bash
 BIN=cpp/build/Debug/bin/tsfile-cli
-$BIN ls -f tsv data.tsfile                          # list tables / devices
+$BIN ls -f csv data.tsfile                          # list tables / devices
 $BIN meta data.tsfile                               # quick file overview
-$BIN count -t table1 -f tsv data.tsfile             # row counts, no page scan
-$BIN cat -t table1 --tag-filter device eq dev_1 -m temp -f tsv data.tsfile
-$BIN cat -m temp,humidity --start 1700000000000 -f csv data.tsfile | head
-$BIN sample -m temp -n 20 --seed 42 -f json data.tsfile | jq .
+$BIN count -t table1 -f csv data.tsfile             # exact row/column counts
+$BIN cat -t table1 --tag-filter device eq dev_1 -m temp -f csv data.tsfile
+$BIN cat -m temp -m humidity --start 1700000000000 -f csv data.tsfile | head
+$BIN export -t table1 --type csv -o table1.csv data.tsfile
 ```
 
 ### Writing (import)
 
-`tsfile-cli write` imports CSV/TSV rows into a **new table-model** `.tsfile` (the output is
-overwritten). The first input column is the timestamp (epoch milliseconds); the remaining
-columns are declared explicitly with `--columns` — there is no type inference.
+`tsfile-cli write` imports strict CSV rows into a **new table-model** `.tsfile`.
+It never creates a tree-model file. The CSV must contain a unique header with the
+reserved `time` column plus exactly the TAG and FIELD names declared on the command line.
+Data rows are mapped by header name, not by physical column order. There is no type
+inference.
 
 Timestamps must be **strictly increasing per device**, where a device is identified by its
 `tag` column values (rows that share the same tags form one device's timeline). Rows for
 different tag combinations may freely interleave and reuse timestamps. Out-of-order input is
 rejected with the offending line number, and a failed import leaves no output file behind.
-`--output` must differ from the input file.
+`--output` must not already exist and must differ from the input file.
 
 ```
-tsfile-cli write --table <name> --columns <spec> -o <out.tsfile> \
-                 [-f csv|tsv] [--no-header] [--header-match] [-v] [<input> | -]
+tsfile-cli write --table <name> [--tag <name> STRING]... --field <name> <TYPE>... \
+                 -o <out.tsfile> (--input <csv> | --stdin) \
+                 [--encoding <TYPE> <ENC>]... [--compression <TYPE> <COMP>]... [-v]
 ```
 
-`--columns` is a comma-separated list of `name:TYPE:category`, where `category` (case-insensitive)
-is `tag` or `field` and `TYPE` (case-insensitive) is one of `BOOLEAN, INT32, INT64, FLOAT, DOUBLE,
-STRING, TEXT, TIMESTAMP, DATE, BLOB` — for example `--columns "id1:STRING:tag,s1:INT64:field"`.
-`DATE` cells are written as `YYYY-MM-DD`; `TIMESTAMP` cells as epoch milliseconds. Each column is
-stored with the engine's default encoding and compression for its type.
+`TYPE` is one of `BOOLEAN, INT32, INT64, FLOAT, DOUBLE, STRING, TEXT, TIMESTAMP, DATE, BLOB`.
+`DATE` cells are written as `YYYY-MM-DD`; `TIMESTAMP` cells as raw int64 timestamps.
+By default each column uses the engine's default encoding and compression for its type.
+`--encoding` and `--compression` override by canonical data type, applying to every declared
+TAG/FIELD of that type; they do not target individual columns and do not affect `time`.
 
 | Option | Meaning |
 |---|---|
 | `--table <name>` | Output table name (lower-cased) |
-| `--columns <spec>` | Ordered data columns (excludes the leading timestamp column) |
-| `-o, --output <path>` | Output `.tsfile` (required; overwritten) |
-| `<input>` / `-` | Input file, or `-` / omitted for stdin |
-| `-f csv\|tsv` | Input delimiter (default csv; `json` / `table` are rejected) |
-| `--no-header` | Input has no header row (default: first line is a header and is skipped) |
-| `--header-match` | Validate header names against `--columns` |
-| `-v, --verbose` | Print `wrote N rows to <out>` to stderr (otherwise silent on success) |
-
-An empty cell is written as null. The command is silent on success (Unix-style); pass `-v`
-for a one-line summary.
+| `--tag <name> STRING` | Ordered TAG column; may be repeated |
+| `--field <name> <TYPE>` | Ordered FIELD column; may be repeated |
+| `--encoding <TYPE> <ENC>` | Override encoding for all declared columns of the data type |
+| `--compression <TYPE> <COMP>` | Override compression for all declared columns of the data type |
+| `-o, --output <path>` | Output `.tsfile` (required; must not already exist) |
+| `-i, --input <path>` / `--stdin` | Choose exactly one CSV input source |
+| `-v, --verbose` | Print a creation summary to stderr after commit (otherwise silent on success) |
+
+CSV input uses RFC 4180 quoting with comma separators. A null value is unquoted `\N`;
+an empty string is `""`. Header errors, unused or duplicate physical overrides, unknown
+types, and incompatible encodings fail before data rows are read. Target-file problems
+such as an existing output, a missing parent directory, or output equal to input return
+exit code `3`.
+
+The command is silent on success (Unix-style). With `-v`, it prints a post-commit summary
+and the effective physical settings for each declared column.
 
 ```bash
 # round-trip through a pipe
 printf 'time,id1,s1\n0,dev,0\n1,dev,10\n' \
-  | tsfile-cli write --table t1 --columns "id1:STRING:tag,s1:INT64:field" -o out.tsfile -
-tsfile-cli count -f tsv out.tsfile          # -> t1.dev  s1  2
+  | tsfile-cli write --table t1 --tag id1 STRING --field s1 INT64 -o out.tsfile --stdin
+tsfile-cli count -f csv out.tsfile          # -> model,object,column,category,...
 ```
 
 For tree-model writes, JSON input, or programmatic use, use the C++ SDK directly — see
@@ -209,7 +219,7 @@ tsfile-cli skill").
 cpp/tools/
 ├── tools_main.cc          # main(): forwards argv to run_cli
 ├── cli/                   # argument parsing, top-level dispatch, exit codes
-├── format/                # csv/tsv/json/table output + CSV/TSV input parsing
+├── format/                # csv/ndjson/table output + CSV input parsing
 ├── commands/              # one file per command + shared row-query / statistics helpers
 └── skills/tsfile-cli/     # model-facing skill reference (for AI assistants)
 ```
diff --git a/cpp/tools/cli/cli_args.cc b/cpp/tools/cli/cli_args.cc
index 731db6ff6..9fb811bba 100644
--- a/cpp/tools/cli/cli_args.cc
+++ b/cpp/tools/cli/cli_args.cc
@@ -19,29 +19,39 @@
 
 #include "cli/cli_args.h"
 
+#include <algorithm>
 #include <cerrno>
 #include <cstdlib>
-#include <sstream>
 
 namespace tsfile_cli {
 namespace {
 
-std::vector<std::string> split_csv(const std::string& s) {
-    std::vector<std::string> out;
-    std::string item;
-    std::istringstream iss(s);
-    while (std::getline(iss, item, ',')) {
-        if (!item.empty()) {
-            out.push_back(item);
+bool has_strict_decimal_body(const std::string& s, size_t start) {
+    if (start >= s.size()) {
+        return false;
+    }
+    if (s[start] == '0' && start + 1 != s.size()) {
+        return false;
+    }
+    for (size_t i = start; i < s.size(); ++i) {
+        if (s[i] < '0' || s[i] > '9') {
+            return false;
         }
     }
-    return out;
+    return true;
 }
 
-bool parse_ll(const std::string& s, long long& out) {
+bool parse_strict_i64(const std::string& s, long long& out) {
     if (s.empty()) {
         return false;
     }
+    size_t start = (s[0] == '-') ? 1 : 0;
+    if (s[0] == '-' && start + 1 == s.size() && s[start] == '0') {
+        return false;
+    }
+    if (!has_strict_decimal_body(s, start)) {
+        return false;
+    }
     char* endp = nullptr;
     errno = 0;
     long long v = std::strtoll(s.c_str(), &endp, 10);
@@ -52,12 +62,27 @@ bool parse_ll(const std::string& s, long long& out) {
     return true;
 }
 
+bool parse_strict_non_negative(const std::string& s, long long& out) {
+    if (s.empty()) {
+        return false;
+    }
+    if (!has_strict_decimal_body(s, 0)) {
+        return false;
+    }
+    char* endp = nullptr;
+    errno = 0;
+    long long v = std::strtoll(s.c_str(), &endp, 10);
+    if (endp == nullptr || *endp != '\0' || errno == ERANGE || v < 0) {
+        return false;
+    }
+    out = v;
+    return true;
+}
+
 bool parse_format(const std::string& s, ParsedArgs::Format& out) {
     if (s == "csv") {
         out = ParsedArgs::Format::kCsv;
-    } else if (s == "tsv") {
-        out = ParsedArgs::Format::kTsv;
-    } else if (s == "json") {
+    } else if (s == "ndjson") {
         out = ParsedArgs::Format::kJson;
     } else if (s == "table") {
         out = ParsedArgs::Format::kTable;
@@ -68,28 +93,28 @@ bool parse_format(const std::string& s, ParsedArgs::Format& out) {
 }
 
 bool parse_tag_filter_op(const std::string& s, ParsedArgs::TagFilterOp& out) {
-    if (s == "eq" || s == "=" || s == "==") {
+    if (s == "eq") {
         out = ParsedArgs::TagFilterOp::kEq;
-    } else if (s == "neq" || s == "ne" || s == "!=") {
+    } else if (s == "neq") {
         out = ParsedArgs::TagFilterOp::kNeq;
-    } else if (s == "lt" || s == "<") {
-        out = ParsedArgs::TagFilterOp::kLt;
-    } else if (s == "lteq" || s == "lte" || s == "le" || s == "<=") {
-        out = ParsedArgs::TagFilterOp::kLteq;
-    } else if (s == "gt" || s == ">") {
-        out = ParsedArgs::TagFilterOp::kGt;
-    } else if (s == "gteq" || s == "gte" || s == "ge" || s == ">=") {
-        out = ParsedArgs::TagFilterOp::kGteq;
-    } else if (s == "regexp" || s == "regex" || s == "=~") {
+    } else if (s == "regexp") {
         out = ParsedArgs::TagFilterOp::kRegexp;
-    } else if (s == "not-regexp" || s == "not-regex" || s == "!~") {
-        out = ParsedArgs::TagFilterOp::kNotRegexp;
+    } else if (s == "is-null") {
+        out = ParsedArgs::TagFilterOp::kIsNull;
+    } else if (s == "not-null") {
+        out = ParsedArgs::TagFilterOp::kNotNull;
     } else {
         return false;
     }
     return true;
 }
 
+bool tag_filter_op_needs_value(ParsedArgs::TagFilterOp op) {
+    return op == ParsedArgs::TagFilterOp::kEq ||
+           op == ParsedArgs::TagFilterOp::kNeq ||
+           op == ParsedArgs::TagFilterOp::kRegexp;
+}
+
 }  // namespace
 
 ParsedArgs parse_args(const std::vector<std::string>& args) {
@@ -122,73 +147,128 @@ ParsedArgs parse_args(const std::vector<std::string>& args) {
         dst = args[++i];
         return true;
     };
-    auto need_tag_filter_slot = [&](const std::string& flag) -> bool {
-        if (p.has_tag_filter) {
-            p.error = "Only one tag filter predicate is supported";
-            return false;
-        }
-        if (i + 3 >= args.size()) {
-            p.error = "Missing value for " + flag;
-            return false;
+    auto append_column = [&](const std::string& name, const std::string& type,
+                             const std::string& category) {
+        if (!p.columns.empty()) {
+            p.columns += ",";
         }
-        return true;
+        p.columns += name + ":" + type + ":" + category;
     };
-
+    bool positional_file_set = false;
+    bool limit_set = false;
+    bool offset_set = false;
+    bool output_set = false;
+    bool output_dir_set = false;
+    bool force_set = false;
     for (; i < args.size(); ++i) {
         const std::string& a = args[i];
         std::string val;
+        if (positional_file_set) {
+            p.error = "Unexpected argument after file: " + a;
+            return p;
+        }
+        if (a == "--") {
+            if (i + 1 >= args.size()) {
+                p.error = "Missing value after --";
+                return p;
+            }
+            if (!p.file.empty() || i + 2 != args.size()) {
+                p.error = "Unexpected argument after file: " + args[i + 1];
+                return p;
+            }
+            p.file = args[++i];
+            positional_file_set = true;
+            continue;
+        }
         if (a == "-f" || a == "--format") {
+            if (p.format_set) {
+                p.error = "--format specified more than once";
+                return p;
+            }
             if (!need_value(a, val)) {
                 return p;
             }
             if (!parse_format(val, p.format)) {
-                p.error =
-                    "Invalid format: " + val + " (use csv|tsv|json|table)";
+                p.error = "unsupported format '" + val +
+                          "'; expected table, ndjson, or csv";
                 return p;
             }
+            p.format_set = true;
         } else if (a == "-d" || a == "--device") {
-            if (!need_value(a, p.device)) {
+            if (!need_value(a, val)) {
                 return p;
             }
+            p.device = val;
+            p.devices.push_back(val);
         } else if (a == "-t" || a == "--table") {
-            if (!need_value(a, p.table)) {
+            if (!need_value(a, val)) {
                 return p;
             }
+            p.table = val;
+            p.tables.push_back(val);
         } else if (a == "-m" || a == "--measurements") {
             if (!need_value(a, val)) {
                 return p;
             }
-            p.measurements = split_csv(val);
+            if (val.find(',') != std::string::npos) {
+                p.error =
+                    "--measurements accepts one column per option; repeat -m";
+                return p;
+            }
+            if (std::find(p.measurements.begin(), p.measurements.end(), val) !=
+                p.measurements.end()) {
+                p.error = "measurement '" + val + "' specified more than once";
+                return p;
+            }
+            p.measurements.push_back(val);
         } else if (a == "-n" || a == "--limit") {
+            if (limit_set) {
+                p.error = "--limit specified more than once";
+                return p;
+            }
             if (!need_value(a, val)) {
                 return p;
             }
-            if (!parse_ll(val, p.limit)) {
+            if (!parse_strict_non_negative(val, p.limit)) {
                 p.error = "Invalid -n/--limit: " + val;
                 return p;
             }
+            limit_set = true;
         } else if (a == "--offset") {
+            if (offset_set) {
+                p.error = "--offset specified more than once";
+                return p;
+            }
             if (!need_value(a, val)) {
                 return p;
             }
-            if (!parse_ll(val, p.offset)) {
+            if (!parse_strict_non_negative(val, p.offset)) {
                 p.error = "Invalid --offset: " + val;
                 return p;
             }
+            offset_set = true;
         } else if (a == "--start") {
+            if (p.has_start) {
+                p.error = "--start specified more than once";
+                return p;
+            }
             if (!need_value(a, val)) {
                 return p;
             }
-            if (!parse_ll(val, p.start)) {
+            if (!parse_strict_i64(val, p.start)) {
                 p.error = "Invalid --start: " + val;
                 return p;
             }
             p.has_start = true;
         } else if (a == "--end") {
+            if (p.has_end) {
+                p.error = "--end specified more than once";
+                return p;
+            }
             if (!need_value(a, val)) {
                 return p;
             }
-            if (!parse_ll(val, p.end)) {
+            if (!parse_strict_i64(val, p.end)) {
                 p.error = "Invalid --end: " + val;
                 return p;
             }
@@ -197,70 +277,153 @@ ParsedArgs parse_args(const std::vector<std::string>& args) {
             if (!need_value(a, val)) {
                 return p;
             }
-            if (!parse_ll(val, p.seed)) {
+            if (!parse_strict_i64(val, p.seed)) {
                 p.error = "Invalid --seed: " + val;
                 return p;
             }
             p.has_seed = true;
+        } else if (a == "--type") {
+            if (p.export_format_set) {
+                p.error = "--type specified more than once";
+                return p;
+            }
+            if (!need_value(a, val)) {
+                return p;
+            }
+            if (!parse_format(val, p.export_format)) {
+                p.error = "unsupported export type '" + val +
+                          "'; expected table, ndjson, or csv";
+                return p;
+            }
+            p.export_format_set = true;
         } else if (a == "-o" || a == "--output") {
+            if (output_set) {
+                p.error = "--output specified more than once";
+                return p;
+            }
             if (!need_value(a, p.output)) {
                 return p;
             }
+            output_set = true;
+        } else if (a == "--output-dir") {
+            if (output_dir_set) {
+                p.error = "--output-dir specified more than once";
+                return p;
+            }
+            if (!need_value(a, p.output_dir)) {
+                return p;
+            }
+            output_dir_set = true;
         } else if (a == "--columns") {
-            if (!need_value(a, p.columns)) {
+            p.error = "Unknown flag: --columns";
+            return p;
+        } else if (a == "--field" || a == "--tag") {
+            if (i + 2 >= args.size()) {
+                p.error = "Missing value for " + a;
+                return p;
+            }
+            std::string name = args[++i];
+            std::string type = args[++i];
+            append_column(name, type, a == "--tag" ? "tag" : "field");
+        } else if (a == "-i" || a == "--input") {
+            if (p.input_set) {
+                p.error = "choose exactly one of --input or --stdin";
+                return p;
+            }
+            if (!need_value(a, p.file)) {
+                return p;
+            }
+            p.input_set = true;
+        } else if (a == "--stdin") {
+            if (p.input_set) {
+                p.error = "choose exactly one of --input or --stdin";
+                return p;
+            }
+            p.file = "-";
+            p.input_set = true;
+        } else if (a == "--encoding" || a == "--compression") {
+            if (i + 2 >= args.size()) {
+                p.error = "Missing value for " + a;
                 return p;
             }
+            ParsedArgs::PhysicalOverride override;
+            override.kind =
+                a == "--encoding"
+                    ? ParsedArgs::PhysicalOverride::Kind::kEncoding
+                    : ParsedArgs::PhysicalOverride::Kind::kCompression;
+            override.data_type = args[++i];
+            override.value = args[++i];
+            p.physical_overrides.push_back(override);
+        } else if (a == "--force") {
+            if (force_set) {
+                p.error = "--force specified more than once";
+                return p;
+            }
+            p.force = true;
+            force_set = true;
         } else if (a == "-v" || a == "--verbose") {
             p.verbose = true;
         } else if (a == "--header-match") {
             p.header_match = true;
         } else if (a == "--tag-filter") {
-            if (!need_tag_filter_slot(a)) {
+            if (i + 2 >= args.size()) {
+                p.error = "Missing value for " + a;
                 return p;
             }
-            p.has_tag_filter = true;
-            p.tag_filter_column = args[++i];
+            ParsedArgs::TagFilterSpec spec;
+            spec.column = args[++i];
             std::string op = args[++i];
-            if (!parse_tag_filter_op(op, p.tag_filter_op)) {
+            if (!parse_tag_filter_op(op, spec.op)) {
                 p.error = "Invalid --tag-filter operator: " + op +
-                          " (use eq|neq|lt|lteq|gt|gteq|regexp|not-regexp)";
+                          " (use eq|neq|regexp|is-null|not-null)";
                 return p;
             }
-            p.tag_filter_value = args[++i];
-        } else if (a == "--tag-between" || a == "--tag-not-between") {
-            if (!need_tag_filter_slot(a)) {
-                return p;
+            if (tag_filter_op_needs_value(spec.op)) {
+                if (i + 1 >= args.size()) {
+                    p.error = "Missing value for " + a;
+                    return p;
+                }
+                spec.value = args[++i];
             }
             p.has_tag_filter = true;
-            p.tag_filter_op = (a == "--tag-between")
-                                  ? ParsedArgs::TagFilterOp::kBetween
-                                  : ParsedArgs::TagFilterOp::kNotBetween;
-            p.tag_filter_column = args[++i];
-            p.tag_filter_value = args[++i];
-            p.tag_filter_value2 = args[++i];
-        } else if (a == "--model") {
+            p.tag_filters.push_back(spec);
+        } else if (a == "--tag-match") {
             if (!need_value(a, val)) {
                 return p;
             }
-            if (val != "tree" && val != "table") {
-                p.error = "Invalid --model: " + val + " (use tree|table)";
+            if (val != "all" && val != "any") {
+                p.error = "Invalid --tag-match: " + val + " (use all or any)";
+                return p;
+            }
+            if (!p.tag_match.empty()) {
+                p.error = "--tag-match specified more than once";
                 return p;
             }
-            p.model = val;
+            p.tag_match = val;
+        } else if (a == "--model") {
+            p.error = "Unknown flag: --model";
+            return p;
         } else if (a == "--no-header") {
             p.no_header = true;
         } else if (a == "-h" || a == "--help") {
+            if (i != 1 || args.size() != 2) {
+                p.error =
+                    "--help must appear by itself or immediately after a "
+                    "command";
+                return p;
+            }
             p.help = true;
-            return p;  // help wins; stop parsing the rest
+            return p;
         } else if (a == "--version") {
-            p.version = true;
-            return p;  // version wins; stop parsing the rest
+            p.error = "--version must appear by itself";
+            return p;
         } else if (a.size() > 1 && a[0] == '-') {
             p.error = "Unknown flag: " + a;
             return p;
         } else {
             if (p.file.empty()) {
                 p.file = a;
+                positional_file_set = true;
             } else {
                 p.error = "Unexpected argument: " + a;
                 return p;
diff --git a/cpp/tools/cli/cli_args.h b/cpp/tools/cli/cli_args.h
index 56199997a..88d505df4 100644
--- a/cpp/tools/cli/cli_args.h
+++ b/cpp/tools/cli/cli_args.h
@@ -32,14 +32,22 @@ struct ParsedArgs {
         kNone,
         kEq,
         kNeq,
-        kLt,
-        kLteq,
-        kGt,
-        kGteq,
         kRegexp,
-        kNotRegexp,
-        kBetween,
-        kNotBetween,
+        kIsNull,
+        kNotNull,
+    };
+
+    struct TagFilterSpec {
+        std::string column;
+        TagFilterOp op = TagFilterOp::kNone;
+        std::string value;
+    };
+
+    struct PhysicalOverride {
+        enum class Kind { kEncoding, kCompression };
+        Kind kind;
+        std::string data_type;
+        std::string value;
     };
 
     std::string command;  // subcommand, e.g. "ls"/"write" (args[0])
@@ -47,30 +55,37 @@ struct ParsedArgs {
                           // input ("" or "-" means read stdin)
     std::string device;   // -d/--device filter (tree model)
     std::string table;    // -t/--table filter (table model); write target table
+    std::vector<std::string> devices;       // all -d/--device values, in order
+    std::vector<std::string> tables;        // all -t/--table values, in order
     std::vector<std::string> measurements;  // -m/--measurements projection
-    long long limit = -1;          // -n/--limit; -1 means unlimited
-    long long offset = 0;          // --offset; rows to skip before emitting
-    long long start = LLONG_MIN;   // --start; inclusive lower time bound
-    long long end = LLONG_MAX;     // --end; inclusive upper time bound
-    bool has_start = false;        // whether --start was supplied
-    bool has_end = false;          // whether --end was supplied
-    long long seed = 0;            // --seed for the reservoir sampler
-    bool has_seed = false;         // whether --seed was supplied
-    Format format = Format::kAuto;  // -f/--format; kAuto resolves by TTY
-    bool no_header = false;        // --no-header; suppress header row
-    std::string model;             // --model tree|table override ("" = auto)
-    std::string output;            // -o/--output; write destination .tsfile
-    std::string columns;           // --columns spec for write (name:TYPE:cat,..)
-    bool verbose = false;          // -v/--verbose; write progress to stderr
-    bool header_match = false;     // --header-match; validate write header row
-    bool has_tag_filter = false;   // --tag-filter/--tag-between was supplied
-    TagFilterOp tag_filter_op = TagFilterOp::kNone;
-    std::string tag_filter_column;  // TAG column name for table row queries
-    std::string tag_filter_value;   // comparison value or BETWEEN lower bound
-    std::string tag_filter_value2;  // BETWEEN upper bound
-    bool help = false;             // -h/--help requested
-    bool version = false;          // --version requested
-    std::string error;             // non-empty if parsing failed (the message)
+    long long limit = -1;                   // -n/--limit; -1 means unlimited
+    long long offset = 0;           // --offset; rows to skip before emitting
+    long long start = LLONG_MIN;    // --start; inclusive lower time bound
+    long long end = LLONG_MAX;      // --end; inclusive upper time bound
+    bool has_start = false;         // whether --start was supplied
+    bool has_end = false;           // whether --end was supplied
+    long long seed = 0;             // parsed only to reject obsolete --seed
+    bool has_seed = false;          // whether --seed was supplied
+    Format format = Format::kAuto;  // -f/--format; kAuto resolves to table
+    bool format_set = false;        // whether -f/--format was supplied
+    bool no_header = false;       // parsed only to reject obsolete --no-header
+    std::string model;            // reserved; model is always auto-detected
+    std::string output;           // -o/--output; write destination .tsfile
+    std::string columns;          // normalized --tag/--field spec
+    bool verbose = false;         // -v/--verbose; write progress to stderr
+    bool header_match = false;    // --header-match; validate write header row
+    bool input_set = false;       // write input was explicitly set
+    bool has_tag_filter = false;  // one or more --tag-filter was supplied
+    std::vector<TagFilterSpec> tag_filters;
+    std::string tag_match;                 // empty, all, or any
+    bool help = false;                     // -h/--help requested
+    bool version = false;                  // --version requested
+    Format export_format = Format::kAuto;  // --type for export
+    bool export_format_set = false;        // whether --type was supplied
+    bool force = false;                    // --force for export/sketch
+    std::string output_dir;  // --output-dir for multi-object export
+    std::vector<PhysicalOverride> physical_overrides;
+    std::string error;  // non-empty if parsing failed (the message)
 };
 
 ParsedArgs parse_args(const std::vector<std::string>& args);
diff --git a/cpp/tools/cli/run_cli.cc b/cpp/tools/cli/run_cli.cc
index 27ca751f0..18a9a42e1 100644
--- a/cpp/tools/cli/run_cli.cc
+++ b/cpp/tools/cli/run_cli.cc
@@ -41,70 +41,188 @@
 #ifndef TSFILE_CLI_VERSION
 #define TSFILE_CLI_VERSION "unknown"
 #endif
+#ifndef TSFILE_CLI_COMMIT
+#define TSFILE_CLI_COMMIT "unknown"
+#endif
+#ifndef TSFILE_CLI_BUILT
+#define TSFILE_CLI_BUILT "unknown"
+#endif
 
 namespace tsfile_cli {
 namespace {
 
 void print_usage(std::ostream& os) {
-    os << "Usage: tsfile-cli <command> [options] <file.tsfile>\n"
-          "Commands:\n"
-          "  ls       list devices (tree) or tables (table)\n"
-          "  schema   per-measurement data type/encoding/compression\n"
-          "  meta     file metadata summary\n"
-          "  stats    per-series count, time range, "
-          "min/max/first/last/sum\n"
-          "  head     first N rows (use -n)\n"
-          "  cat      all rows of a device/table\n"
-          "  count    number of rows (per series, plus a total)\n"
-          "  sample   deterministic sample rows (use -n and --seed)\n"
-          "  write    import CSV/TSV rows into a new table tsfile "
-          "(--table, --columns, -o)\n"
-          "Options:\n"
-          "  -f, --format csv|tsv|json|table  output format "
-          "(default: table on a TTY, tsv when piped)\n"
-          "  -d, --device <name>      restrict to one device (tree model)\n"
-          "  -t, --table <name>       restrict to one table (table model)\n"
-          "  -m, --measurements a,b   project only these measurements\n"
-          "  -n, --limit N            max rows (head/cat/sample)\n"
-          "      --offset N           skip N rows before emitting\n"
-          "      --start <ms>         inclusive lower time bound\n"
-          "      --end <ms>           inclusive upper time bound\n"
-          "      --seed N             RNG seed for sample\n"
-          "      --tag-filter C OP V   table TAG predicate; OP is "
-          "eq|neq|lt|lteq|gt|gteq|regexp|not-regexp\n"
-          "      --tag-between C L U   table TAG predicate: L <= C <= U\n"
-          "      --tag-not-between C L U  table TAG predicate outside [L,U]\n"
-          "      --no-header          omit the header row\n"
-          "      --model tree|table   force the data model (else auto)\n"
-          "  -h, --help               print this help\n"
-          "      --version            print version\n"
+    os << "Usage: tsfile-cli <command> [options]\n"
+          "Commands: ls schema meta stats count sketch head cat export write\n"
+          "Formats: table ndjson csv\n"
+          "Common read options:\n"
+          "  -f, --format table|ndjson|csv  output format (default: table)\n"
+          "  -d, --device <name>            select one tree-model device\n"
+          "  -t, --table <name>             select one table-model table\n"
+          "  -m, --measurements <name>      repeat for FIELD projection\n"
+          "  -n, --limit N                  max rows for head/cat\n"
+          "      --offset N                 skip N matching rows\n"
+          "      --start <int64>            inclusive lower time bound\n"
+          "      --end <int64>              inclusive upper time bound\n"
+          "Export options:\n"
+          "  -o, --output <file>            single-object export target\n"
+          "      --type table|ndjson|csv    export file type\n"
+          "      --force                    replace a regular output file\n"
           "Write options:\n"
-          "      --table <name>       target table name (required)\n"
-          "      --columns SPEC       column spec name:TYPE:tag|field,... "
-          "(required)\n"
-          "  -o, --output <file>      destination .tsfile (required)\n"
-          "      --header-match       require the input header to match "
-          "--columns\n"
-          "  -v, --verbose            report rows written to stderr\n";
+          "      --table <name>             target table name\n"
+          "      --tag <name> STRING        declare a TAG column\n"
+          "      --field <name> <type>      declare a FIELD column\n"
+          "  -i, --input <file.csv>         input CSV file\n"
+          "      --stdin                    read CSV from stdin\n"
+          "  -o, --output <file>            destination .tsfile\n"
+          "  -v, --verbose                  report write details to stderr\n"
+          "  -h, --help                     print help\n"
+          "      --version                  print version\n";
+}
+
+void print_command_usage(const std::string& command, std::ostream& os) {
+    if (command == "ls") {
+        os << "Usage: tsfile-cli ls [-f|--format table|ndjson|csv] "
+              "<file.tsfile>\n"
+              "Lists every object in the selected tree or table model.\n"
+              "Result fields: model,object\n"
+              "Default: --format table\n"
+              "Examples:\n"
+              "  tsfile-cli ls data.tsfile\n"
+              "  tsfile-cli ls -f ndjson data.tsfile\n";
+    } else if (command == "schema") {
+        os << "Usage: tsfile-cli schema [-d|--device <device> | "
+              "-t|--table <table>] [-m|--measurements <column>]... "
+              "[-f|--format table|ndjson|csv] <file.tsfile>\n"
+              "Shows TIME/TAG/ATTRIBUTE/FIELD structure and physical "
+              "settings.\n"
+              "Result fields: model,object,column,category,data_type,encoding,"
+              "compression\n"
+              "Default: --format table; omitted scope visits every object in "
+              "file order.\n"
+              "Examples:\n"
+              "  tsfile-cli schema -t sensors -f csv data.tsfile\n"
+              "  tsfile-cli schema -d root.sg.d1 -m temperature data.tsfile\n";
+    } else if (command == "meta") {
+        os << "Usage: tsfile-cli meta [-f|--format table|ndjson|csv] "
+              "<file.tsfile>\n"
+              "Shows file-level metadata and the selected data model.\n"
+              "Result fields: size_bytes,format_version,model\n"
+              "Default: --format table\n"
+              "Examples:\n"
+              "  tsfile-cli meta data.tsfile\n"
+              "  tsfile-cli meta -f ndjson data.tsfile\n";
+    } else if (command == "stats") {
+        os << "Usage: tsfile-cli stats [-d|--device <device> | "
+              "-t|--table <table>] [-m|--measurements <field>]... "
+              "[-f|--format table|ndjson|csv] <file.tsfile>\n"
+              "Shows FIELD value statistics and null counts.\n"
+              "Result fields: tree uses model,object,field,data_type,"
+              "non_null_count,null_count,min_time,max_time,min,max,first,last,"
+              "sum,stats_source; table inserts tag.<name> fields after "
+              "object.\n"
+              "Default: --format table; omitted scope visits every object in "
+              "file order.\n"
+              "Examples:\n"
+              "  tsfile-cli stats -t sensors -m temperature -f csv "
+              "data.tsfile\n";
+    } else if (command == "count") {
+        os << "Usage: tsfile-cli count [-d|--device <device> | "
+              "-t|--table <table>] [-m|--measurements <column>]... "
+              "[-f|--format table|ndjson|csv] <file.tsfile>\n"
+              "Shows logical row, entity, and column counts.\n"
+              "Result fields: model,object,column,category,row_count,"
+              "entity_count,non_null_count,null_count,min_time,max_time,"
+              "time_source\n"
+              "Default: --format table; omitted scope visits every object in "
+              "file order.\n"
+              "Examples:\n"
+              "  tsfile-cli count -t sensors -m site -f csv data.tsfile\n";
+    } else if (command == "sketch") {
+        os << "Usage: tsfile-cli sketch [-o|--output <file>] [--force] "
+              "<file.tsfile>\n"
+              "Writes the physical layout text from the bound printSketch "
+              "behavior.\n"
+              "Result fields: printSketch text; --format is not supported.\n"
+              "Default: stdout; --force requires --output and replaces only a "
+              "regular file.\n"
+              "Examples:\n"
+              "  tsfile-cli sketch data.tsfile\n"
+              "  tsfile-cli sketch -o layout.txt data.tsfile\n";
+    } else if (command == "head") {
+        os << "Usage: tsfile-cli head [-d|--device <device> | "
+              "-t|--table <table>] [-m|--measurements <field>]... "
+              "[--start <int64>] [--end <int64>] [--offset N] [-n|--limit N] "
+              "[--tag-filter <tag> <op> [value]] [--tag-match all|any] "
+              "[-f|--format table|ndjson|csv] <file.tsfile>\n"
+              "Reads the first matching rows from one object.\n"
+              "Result fields: time, all table TAG columns, selected FIELD "
+              "columns.\n"
+              "Default: --limit 10, --offset 0, --format table.\n"
+              "Examples:\n"
+              "  tsfile-cli head -t sensors -m temperature -n 5 data.tsfile\n";
+    } else if (command == "cat") {
+        os << "Usage: tsfile-cli cat [-d|--device <device> | "
+              "-t|--table <table>] [-m|--measurements <field>]... "
+              "[--start <int64>] [--end <int64>] [--offset N] [-n|--limit N] "
+              "[--tag-filter <tag> <op> [value]] [--tag-match all|any] "
+              "[-f|--format table|ndjson|csv] <file.tsfile>\n"
+              "Reads all matching rows from one object unless --limit is set.\n"
+              "Result fields: time, all table TAG columns, selected FIELD "
+              "columns.\n"
+              "Default: no row limit, --offset 0, --format table.\n"
+              "Examples:\n"
+              "  tsfile-cli cat -t sensors --tag-filter site eq a -f ndjson "
+              "data.tsfile\n";
+    } else if (command == "export") {
+        os << "Usage: tsfile-cli export (-d|--device <device> | "
+              "-t|--table <table>) -o|--output <file> "
+              "--type table|ndjson|csv [query options] [--force] "
+              "<file.tsfile>\n"
+              "       tsfile-cli export (-d <device>... | -t <table>...) "
+              "--output-dir <dir> --type table|ndjson|csv [query options] "
+              "<file.tsfile>\n"
+              "Writes one object atomically, or a numbered multi-object "
+              "directory with _manifest.json.\n"
+              "Result fields: same bytes as cat for the same scope and type; "
+              "multi-object manifest records file,model,object,type,rows.\n"
+              "Default: no row limit, --offset 0; --type is required.\n"
+              "Examples:\n"
+              "  tsfile-cli export -t sensors --type csv -o sensors.csv "
+              "data.tsfile\n";
+    } else if (command == "write") {
+        os << "Usage: tsfile-cli write --table <name> "
+              "(--tag <name> STRING)* (--field <name> <type>)+ "
+              "[--encoding <type> <encoding>] [--compression <type> "
+              "<compression>] (-i|--input <input.csv> | --stdin) "
+              "-o|--output <out.tsfile> [-v|--verbose]\n"
+              "Creates a new single-table, table-model TsFile from strict "
+              "CSV.\n"
+              "Result fields: none on stdout; -v writes a post-commit summary "
+              "and resolved column physical settings to stderr.\n"
+              "Default: success is silent; target must not exist; CSV header "
+              "must contain time and declared TAG/FIELD names.\n"
+              "Examples:\n"
+              "  tsfile-cli write --table sensors --tag site STRING "
+              "--field temperature DOUBLE -i input.csv -o out.tsfile\n";
+    } else {
+        print_usage(os);
+    }
 }
 
 bool is_known_command(const std::string& c) {
-    static const std::set<std::string> kCmds = {"ls",    "schema", "meta",
-                                                "stats", "head",   "cat",
-                                                "count", "sample", "write"};
+    static const std::set<std::string> kCmds = {
+        "ls",     "schema", "meta", "stats",  "count",
+        "sketch", "head",   "cat",  "export", "write"};
     return kCmds.find(c) != kCmds.end();
 }
 
 bool validate_command_flags(const ParsedArgs& p, std::ostream& err) {
-    if (p.has_seed && p.command != "sample") {
-        err << "Error: --seed is only valid for sample\n";
-        return false;
-    }
-    if (p.command == "sample" && p.offset != 0) {
-        err << "Error: --offset is not valid for sample\n";
+    if (p.has_seed) {
+        err << "Error: --seed is not supported by tsfile-cli\n";
         return false;
     }
-    if (!p.device.empty() && !p.table.empty()) {
+    if (!p.devices.empty() && !p.tables.empty()) {
         err << "Error: -d/--device and -t/--table cannot be used together\n";
         return false;
     }
@@ -116,6 +234,11 @@ bool validate_command_flags(const ParsedArgs& p, std::ostream& err) {
         err << "Error: --offset must be >= 0\n";
         return false;
     }
+    if ((p.command == "head" || p.command == "cat" || p.command == "export") &&
+        p.limit == 0 && p.offset > 0) {
+        err << "Error: --offset requires a positive --limit\n";
+        return false;
+    }
     if (p.has_start && p.has_end && p.start > p.end) {
         err << "Error: --start must be <= --end\n";
         return false;
@@ -124,31 +247,39 @@ bool validate_command_flags(const ParsedArgs& p, std::ostream& err) {
 }
 
 bool validate_write_flags(const ParsedArgs& p, std::ostream& err) {
+    if (p.tables.size() > 1) {
+        err << "Error: --table specified more than once\n";
+        return false;
+    }
     if (p.table.empty()) {
         err << "Error: write requires -t/--table\n";
         return false;
     }
     if (p.columns.empty()) {
-        err << "Error: write requires --columns\n";
+        err << "Error: write requires at least one --field column\n";
         return false;
     }
     if (p.output.empty()) {
         err << "Error: write requires -o/--output\n";
         return false;
     }
-    if (p.format == ParsedArgs::Format::kJson ||
-        p.format == ParsedArgs::Format::kTable) {
-        err << "Error: write input format must be csv or tsv\n";
+    if (p.format_set) {
+        err << "Error: write input format is fixed CSV; --format is not "
+               "valid\n";
         return false;
     }
-    if (p.no_header && p.header_match) {
-        err << "Error: --header-match cannot be combined with --no-header\n";
+    if (!p.input_set) {
+        err << "Error: choose exactly one of --input or --stdin\n";
         return false;
     }
     if (p.has_tag_filter) {
         err << "Error: tag filter flags are not valid for write\n";
         return false;
     }
+    if (!p.tag_match.empty()) {
+        err << "Error: --tag-match is not valid for write\n";
+        return false;
+    }
     // Name the offending flag so the user does not have to guess which of
     // the read-only options triggered the rejection.
     if (!p.measurements.empty()) {
@@ -163,6 +294,10 @@ bool validate_write_flags(const ParsedArgs& p, std::ostream& err) {
         err << "Error: --start/--end are not valid for write\n";
         return false;
     }
+    if (p.no_header || p.header_match) {
+        err << "Error: --no-header/--header-match are not valid for write\n";
+        return false;
+    }
     if (p.has_seed) {
         err << "Error: --seed is not valid for write\n";
         return false;
@@ -182,16 +317,103 @@ bool validate_write_flags(const ParsedArgs& p, std::ostream& err) {
     return true;
 }
 
+bool validate_export_flags(const ParsedArgs& p, std::ostream& err) {
+    if (!p.export_format_set) {
+        err << "Error: export requires --type table|ndjson|csv\n";
+        return false;
+    }
+    if (p.format_set) {
+        err << "Error: export uses --type, not --format\n";
+        return false;
+    }
+    if (p.no_header) {
+        err << "Error: --no-header is not supported\n";
+        return false;
+    }
+    if (p.has_tag_filter && !p.devices.empty()) {
+        err << "Error: tag filter flags are only valid for table export\n";
+        return false;
+    }
+    if (!p.tag_match.empty()) {
+        if (p.tag_filters.size() == 0) {
+            err << "Error: --tag-match requires tag filters\n";
+            return false;
+        }
+        if (p.tag_filters.size() == 1) {
+            err << "Error: --tag-match requires at least two tag filters\n";
+            return false;
+        }
+    }
+    if (p.tag_filters.size() >= 2 && p.tag_match.empty()) {
+        err << "Error: two or more tag filters require --tag-match all or "
+               "any\n";
+        return false;
+    }
+    const size_t scope_count = p.devices.size() + p.tables.size();
+    if (scope_count == 0) {
+        err << "Error: export requires -d/--device or -t/--table\n";
+        return false;
+    }
+    if (scope_count == 1) {
+        if (p.output.empty()) {
+            err << "Error: export requires -o/--output\n";
+            return false;
+        }
+        if (!p.output_dir.empty()) {
+            err << "Error: --output-dir is only valid for multi-object "
+                   "export\n";
+            return false;
+        }
+        return true;
+    }
+    if (!p.output.empty()) {
+        err << "Error: -o/--output is only valid for single-object export\n";
+        return false;
+    }
+    if (p.output_dir.empty()) {
+        err << "Error: multi-object export requires --output-dir\n";
+        return false;
+    }
+    if (p.force) {
+        err << "Error: --force is only valid for single-object export\n";
+        return false;
+    }
+    return true;
+}
+
 // Reject flags that have no effect for the given read command, instead of
 // silently ignoring them, so misuse is caught rather than producing surprising
 // output. Only called for non-write commands; write has its own validation.
 bool validate_read_flag_applicability(const ParsedArgs& p, std::ostream& err) {
     const std::string& c = p.command;
-    const bool is_row = (c == "head" || c == "cat" || c == "sample");
-    const bool scoped =
-        is_row || c == "schema" || c == "stats" || c == "count";
+    const bool is_row = (c == "head" || c == "cat");
+    const bool scoped = is_row || c == "schema" || c == "stats" || c == "count";
 
-    if (!p.output.empty()) {
+    if (c == "sketch") {
+        if (p.format_set) {
+            err << "Error: sketch does not accept --format; its output follows "
+                   "printSketch\n";
+            return false;
+        }
+        if (p.force && p.output.empty()) {
+            err << "Error: --force requires --output\n";
+            return false;
+        }
+        if (!p.device.empty() || !p.table.empty() || !p.measurements.empty() ||
+            p.limit != -1 || p.offset != 0 || p.has_start || p.has_end ||
+            p.has_tag_filter) {
+            err << "Error: sketch does not accept scope or query options\n";
+            return false;
+        }
+        return true;
+    }
+
+    if (p.no_header) {
+        err << "Error: --no-header is not supported\n";
+        return false;
+    }
+    if (!p.output.empty() || !p.output_dir.empty() || p.force ||
+        p.export_format_set) {
         err << "Error: -o/--output is only valid for write\n";
         return false;
     }
@@ -208,7 +430,7 @@ bool validate_read_flag_applicability(const ParsedArgs& p, std::ostream& err) {
         return false;
     }
     if (!is_row && p.limit != -1) {
-        err << "Error: -n/--limit is only valid for head/cat/sample\n";
+        err << "Error: -n/--limit is only valid for head/cat\n";
         return false;
     }
     if (!is_row && p.offset != 0) {
@@ -216,11 +438,30 @@ bool validate_read_flag_applicability(const ParsedArgs& p, std::ostream& err) {
         return false;
     }
     if (!is_row && (p.has_start || p.has_end)) {
-        err << "Error: --start/--end are only valid for head/cat/sample\n";
+        err << "Error: --start/--end are only valid for head/cat\n";
         return false;
     }
     if (p.has_tag_filter && !is_row) {
-        err << "Error: tag filter flags are only valid for head/cat/sample\n";
+        err << "Error: tag filter flags are only valid for head/cat\n";
+        return false;
+    }
+    if (!p.tag_match.empty() && !is_row) {
+        err << "Error: --tag-match is only valid for head/cat\n";
+        return false;
+    }
+    if (!p.tag_match.empty()) {
+        if (p.tag_filters.size() == 0) {
+            err << "Error: --tag-match requires tag filters\n";
+            return false;
+        }
+        if (p.tag_filters.size() == 1) {
+            err << "Error: --tag-match requires at least two tag filters\n";
+            return false;
+        }
+    }
+    if (p.tag_filters.size() >= 2 && p.tag_match.empty()) {
+        err << "Error: two or more tag filters require --tag-match all or "
+               "any\n";
         return false;
     }
     if (p.has_tag_filter && p.model == "tree") {
@@ -243,6 +484,10 @@ bool validate_read_flag_applicability(const ParsedArgs& p, std::ostream& err) {
         err << "Error: -m/--measurements is not valid for " << c << "\n";
         return false;
     }
+    if (c != "export" && (p.devices.size() > 1 || p.tables.size() > 1)) {
+        err << "Error: scope option specified more than once\n";
+        return false;
+    }
     return true;
 }
 
@@ -252,29 +497,45 @@ int run_cli(const std::vector<std::string>& args, std::ostream& out,
             std::ostream& err) {
     ParsedArgs p = parse_args(args);
 
-    if (p.version) {
-        out << "tsfile-cli (Apache TsFile C++) " << TSFILE_CLI_VERSION << "\n";
-        return kExitOk;
-    }
     if (args.empty()) {
         print_usage(err);
         return kExitUsage;
     }
-    if (p.command == "help" || p.command == "--help" || p.command == "-h" ||
-        p.help) {
-        print_usage(out);
-        return kExitOk;
-    }
     if (!p.error.empty()) {
         err << "Error: " << p.error << "\n";
         print_usage(err);
         return kExitUsage;
     }
+    if (p.command == "--version") {
+        if (args.size() != 1) {
+            err << "Error: --version must appear by itself\n";
+            print_usage(err);
+            return kExitUsage;
+        }
+        out << "tsfile-cli " << TSFILE_CLI_VERSION
+            << " tsfile=" << TSFILE_CLI_VERSION
+            << " commit=" << TSFILE_CLI_COMMIT << " built=" << TSFILE_CLI_BUILT
+            << "\n";
+        return kExitOk;
+    }
+    if (p.command == "help" || p.command == "--help" || p.command == "-h") {
+        if (args.size() != 1) {
+            err << "Error: " << p.command << " must appear by itself\n";
+            print_usage(err);
+            return kExitUsage;
+        }
+        print_usage(out);
+        return kExitOk;
+    }
     if (!is_known_command(p.command)) {
         err << "Unknown command: " << p.command << "\n";
         print_usage(err);
         return kExitUsage;
     }
+    if (p.help) {
+        print_command_usage(p.command, out);
+        return kExitOk;
+    }
     if (p.command != "write" && p.file.empty()) {
         err << "Error: missing <file.tsfile> argument\n";
         return kExitUsage;
@@ -293,7 +554,14 @@ int run_cli(const std::vector<std::string>& args, std::ostream& out,
         return cmd_write(p, out, err);
     }
 
-    if (!validate_read_flag_applicability(p, err)) {
+    if (p.command == "export") {
+        if (!validate_export_flags(p, err)) {
+            print_usage(err);
+            return kExitUsage;
+        }
+    }
+
+    if (p.command != "export" && !validate_read_flag_applicability(p, err)) {
         print_usage(err);
         return kExitUsage;
     }
@@ -307,9 +575,9 @@ int run_cli(const std::vector<std::string>& args, std::ostream& out,
         return kExitFile;
     }
 
-    // head/cat/sample/schema dispatch on the data model and would silently
+    // head/cat/export/schema dispatch on the data model and would silently
     // ignore the scope flag of the other model; reject that instead.
-    if (p.command == "head" || p.command == "cat" || p.command == "sample" ||
+    if (p.command == "head" || p.command == "cat" || p.command == "export" ||
         p.command == "schema") {
         const bool table_model = is_table_model(p, reader);
         if (table_model && !p.device.empty()) {
@@ -327,7 +595,9 @@ int run_cli(const std::vector<std::string>& args, std::ostream& out,
     }
 
     bool stdout_tty = TSFILE_ISATTY(TSFILE_FILENO(stdout)) != 0;
-    OutputFormat fmt = resolve_format(p.format, stdout_tty);
+    OutputFormat fmt = p.command == "export"
+                           ? resolve_format(p.export_format, stdout_tty)
+                           : resolve_format(p.format, stdout_tty);
 
     int code;
     if (p.command == "ls") {
@@ -344,8 +614,10 @@ int run_cli(const std::vector<std::string>& args, std::ostream& out,
         code = cmd_cat(p, reader, fmt, out, err);
     } else if (p.command == "count") {
         code = cmd_count(p, reader, fmt, out, err);
-    } else if (p.command == "sample") {
-        code = cmd_sample(p, reader, fmt, out, err);
+    } else if (p.command == "export") {
+        code = cmd_export(p, reader, fmt, out, err);
+    } else if (p.command == "sketch") {
+        code = cmd_sketch(p, reader, out, err);
     } else {
         err << "Unknown command: " << p.command << "\n";
         code = kExitUsage;
diff --git a/cpp/tools/commands/cmd_count.cc b/cpp/tools/commands/cmd_count.cc
index 9480744c6..908e9ffb7 100644
--- a/cpp/tools/commands/cmd_count.cc
+++ b/cpp/tools/commands/cmd_count.cc
@@ -17,30 +17,337 @@
  * under the License.
  */
 
+#include <algorithm>
+#include <limits>
+#include <map>
+#include <set>
+#include <sstream>
 #include <string>
 #include <vector>
 
 #include "cli/exit_codes.h"
 #include "commands/commands.h"
 #include "commands/statistics.h"
+#include "common/schema.h"
+#include "format/result_set_format.h"
+#include "reader/tsfile_reader.h"
+#include "utils/storage_utils.h"
 
 namespace tsfile_cli {
+namespace {
+
+const char* count_column_category_name(common::ColumnCategory category) {
+    switch (category) {
+        case common::ColumnCategory::TAG:
+            return "TAG";
+        case common::ColumnCategory::ATTRIBUTE:
+            return "ATTRIBUTE";
+        case common::ColumnCategory::TIME:
+            return "TIME";
+        case common::ColumnCategory::FIELD:
+        default:
+            return "FIELD";
+    }
+}
+
+struct CountColumn {
+    std::string name;
+    common::TSDataType type;
+    common::ColumnCategory category;
+    long long non_null_count = 0;
+};
+
+struct TableCountSummary {
+    std::string table_name;
+    std::vector<CountColumn> columns;
+    long long row_count = 0;
+    long long min_time = 0;
+    long long max_time = 0;
+    bool has_time = false;
+    std::set<std::string> entity_keys;
+};
+
+bool selected_for_count(const ParsedArgs& args, const std::string& name) {
+    if (args.measurements.empty()) {
+        return true;
+    }
+    for (const std::string& requested : args.measurements) {
+        if (storage::to_lower(requested) == name) {
+            return true;
+        }
+    }
+    return false;
+}
+
+std::string entity_part(bool is_null, const std::string& value) {
+    std::ostringstream ss;
+    if (is_null) {
+        ss << "N:";
+    } else {
+        ss << "V:" << value.size() << ":" << value;
+    }
+    return ss.str();
+}
+
+int collect_table_count(const ParsedArgs& args, storage::TsFileReader& reader,
+                        TableCountSummary& summary, std::ostream& err,
+                        bool require_all_measurements) {
+    std::string table_name = storage::to_lower(args.table);
+    std::shared_ptr<storage::TableSchema> schema =
+        reader.get_table_schema(table_name);
+    if (!schema) {
+        err << "Error: table '" << args.table << "' does not exist\n";
+        return kExitUsage;
+    }
+    summary.table_name = schema->get_table_name();
+
+    auto categories = schema->get_column_categories();
+    auto measurements = schema->get_measurement_schemas();
+    std::vector<std::string> query_columns;
+    std::set<std::string> known_columns;
+    std::set<std::string> count_columns;
+    std::map<std::string, uint32_t> result_column_indexes;
+    std::vector<uint32_t> tag_result_indexes;
+    for (size_t i = 0; i < measurements.size(); ++i) {
+        if (!measurements[i]) {
+            continue;
+        }
+        CountColumn c;
+        c.name = measurements[i]->measurement_name_;
+        c.type = measurements[i]->data_type_;
+        c.category = i < categories.size() ? categories[i]
+                                           : common::ColumnCategory::FIELD;
+        known_columns.insert(c.name);
+        if (c.category == common::ColumnCategory::TAG ||
+            c.category == common::ColumnCategory::FIELD) {
+            count_columns.insert(c.name);
+            query_columns.push_back(c.name);
+            const uint32_t result_index =
+                static_cast<uint32_t>(query_columns.size() + 1);
+            result_column_indexes[c.name] = result_index;
+            if (c.category == common::ColumnCategory::TAG) {
+                tag_result_indexes.push_back(result_index);
+            }
+        }
+        if (count_columns.find(c.name) != count_columns.end() &&
+            selected_for_count(args, c.name)) {
+            summary.columns.push_back(c);
+        }
+    }
+    if (require_all_measurements) {
+        for (const std::string& requested : args.measurements) {
+            if (known_columns.find(storage::to_lower(requested)) ==
+                known_columns.end()) {
+                err << "Error: column '" << requested
+                    << "' does not exist in table " << summary.table_name
+                    << "\n";
+                return kExitUsage;
+            }
+            if (count_columns.find(storage::to_lower(requested)) ==
+                count_columns.end()) {
+                err << "Error: count accepts TAG or FIELD columns only; '"
+                    << requested << "' has another category\n";
+                return kExitUsage;
+            }
+        }
+    }
+
+    storage::ResultSet* rs = nullptr;
+    int qret = reader.query(summary.table_name, query_columns,
+                            std::numeric_limits<int64_t>::min(),
+                            std::numeric_limits<int64_t>::max(), rs);
+    if (qret != 0 || rs == nullptr) {
+        err << "Error: count query failed: " << error_code_message(qret)
+            << "\n";
+        if (rs != nullptr) {
+            reader.destroy_query_data_set(rs);
+        }
+        return kExitFile;
+    }
+
+    auto meta = rs->get_metadata();
+    std::vector<common::TSDataType> result_types;
+    for (uint32_t i = 1; i <= meta->get_column_count(); ++i) {
+        result_types.push_back(meta->get_column_type(i));
+    }
+
+    bool has_next = false;
+    int code = common::E_OK;
+    while ((code = rs->next(has_next)) == common::E_OK && has_next) {
+        int64_t time = rs->get_value<int64_t>(1);
+        if (!summary.has_time) {
+            summary.min_time = time;
+            summary.max_time = time;
+            summary.has_time = true;
+        } else {
+            summary.min_time = std::min<long long>(summary.min_time, time);
+            summary.max_time = std::max<long long>(summary.max_time, time);
+        }
+        ++summary.row_count;
+
+        std::string entity_key;
+        if (tag_result_indexes.empty()) {
+            entity_key = "zero-tag";
+        } else {
+            for (uint32_t col : tag_result_indexes) {
+                bool null = rs->is_null(col);
+                entity_key += entity_part(
+                    null, null
+                              ? std::string()
+                              : cell_to_string(rs, col, result_types[col - 1]));
+                entity_key += "|";
+            }
+        }
+        summary.entity_keys.insert(entity_key);
+
+        for (CountColumn& out_col : summary.columns) {
+            auto result_index = result_column_indexes.find(out_col.name);
+            if (result_index != result_column_indexes.end() &&
+                !rs->is_null(result_index->second)) {
+                ++out_col.non_null_count;
+            }
+        }
+    }
+    reader.destroy_query_data_set(rs);
+    if (code != common::E_OK) {
+        err << "Error: failed to scan count rows: " << error_code_message(code)
+            << "\n";
+        return kExitFile;
+    }
+    return kExitOk;
+}
+
+}  // namespace
 
 int cmd_count(const ParsedArgs& args, storage::TsFileReader& reader,
-              OutputFormat fmt, std::ostream& out, std::ostream& /*err*/) {
-    RowWriter w(out, fmt, {"target", "measurement", "count"},
-                {common::STRING, common::STRING, common::INT64},
-                args.no_header);
+              OutputFormat fmt, std::ostream& out, std::ostream& err) {
+    RowWriter w(
+        out, fmt,
+        {"model", "object", "column", "category", "row_count", "entity_count",
+         "non_null_count", "null_count", "min_time", "max_time", "time_source"},
+        {common::STRING, common::STRING, common::STRING, common::STRING,
+         common::INT64, common::INT64, common::INT64, common::INT64,
+         common::INT64, common::INT64, common::STRING},
+        args.no_header);
 
-    long long total = 0;
-    std::vector<SeriesStatRow> rows = collect_series_stats(args, reader);
+    if (is_table_model(args, reader)) {
+        const std::vector<std::shared_ptr<storage::TableSchema>> all_schemas =
+            reader.get_all_table_schemas();
+        if (args.table.empty()) {
+            for (const std::string& requested : args.measurements) {
+                const std::string canonical = storage::to_lower(requested);
+                bool found = false;
+                bool found_other = false;
+                for (const auto& schema : all_schemas) {
+                    if (!schema) {
+                        continue;
+                    }
+                    const int index = schema->find_column_index(canonical);
+                    if (index < 0) {
+                        continue;
+                    }
+                    const auto categories = schema->get_column_categories();
+                    const common::ColumnCategory category =
+                        static_cast<size_t>(index) < categories.size()
+                            ? categories[static_cast<size_t>(index)]
+                            : common::ColumnCategory::FIELD;
+                    if (category == common::ColumnCategory::TAG ||
+                        category == common::ColumnCategory::FIELD) {
+                        found = true;
+                    } else {
+                        found_other = true;
+                    }
+                }
+                if (!found) {
+                    if (found_other) {
+                        err << "Error: count accepts TAG or FIELD columns "
+                               "only; '"
+                            << requested << "' has another category\n";
+                    } else {
+                        err << "Error: column '" << requested
+                            << "' does not exist in the file\n";
+                    }
+                    return kExitUsage;
+                }
+            }
+        }
+        std::vector<ParsedArgs> scopes;
+        if (!args.table.empty()) {
+            scopes.push_back(args);
+        } else {
+            for (const auto& schema : all_schemas) {
+                if (schema) {
+                    ParsedArgs scope = args;
+                    scope.table = schema->get_table_name();
+                    scopes.push_back(scope);
+                }
+            }
+        }
+        std::vector<TableCountSummary> summaries(scopes.size());
+        for (size_t i = 0; i < scopes.size(); ++i) {
+            int ret = collect_table_count(scopes[i], reader, summaries[i], err,
+                                          !args.table.empty());
+            if (ret != kExitOk) {
+                return ret;
+            }
+        }
+        for (const TableCountSummary& summary : summaries) {
+            for (const CountColumn& c : summary.columns) {
+                long long null_count = summary.row_count - c.non_null_count;
+                std::vector<std::string> cells = {
+                    "table",
+                    summary.table_name,
+                    c.name,
+                    count_column_category_name(c.category),
+                    std::to_string(summary.row_count),
+                    std::to_string(summary.has_time ? summary.entity_keys.size()
+                                                    : 0),
+                    std::to_string(c.non_null_count),
+                    std::to_string(null_count),
+                    summary.has_time ? std::to_string(summary.min_time) : "",
+                    summary.has_time ? std::to_string(summary.max_time) : "",
+                    summary.has_time ? "scan" : ""};
+                if (!w.write(cells, {false, false, false, false, false, false,
+                                     false, false, !summary.has_time,
+                                     !summary.has_time, !summary.has_time})) {
+                    err << "Error: failed to write output\n";
+                    return kExitRuntime;
+                }
+            }
+        }
+        if (!w.finish()) {
+            err << "Error: failed to write output\n";
+            return kExitRuntime;
+        }
+        return kExitOk;
+    }
+
+    std::vector<SeriesStatRow> rows;
+    int collect_ret = collect_series_stats(args, reader, rows, err);
+    if (collect_ret != kExitOk) {
+        return collect_ret;
+    }
     for (const SeriesStatRow& row : rows) {
-        total += row.count;
-        w.write({row.target, row.measurement, std::to_string(row.count)},
-                {false, false, false});
+        const long long null_count = row.row_count - row.count;
+        if (!w.write(
+                {"tree", row.target, row.measurement, "FIELD",
+                 std::to_string(row.row_count), "",
+                 row.has_statistic ? std::to_string(row.count) : "",
+                 row.has_statistic ? std::to_string(null_count) : "",
+                 row.has_statistic ? std::to_string(row.start_time) : "",
+                 row.has_statistic ? std::to_string(row.end_time) : "",
+                 row.has_statistic ? "statistics" : ""},
+                {false, false, false, false, false, true, !row.has_statistic,
+                 !row.has_statistic, !row.has_statistic, !row.has_statistic,
+                 !row.has_statistic})) {
+            err << "Error: failed to write output\n";
+            return kExitRuntime;
+        }
+    }
+    if (!w.finish()) {
+        err << "Error: failed to write output\n";
+        return kExitRuntime;
     }
-    w.write({"total", "", std::to_string(total)}, {false, true, false});
-    w.finish();
     return kExitOk;
 }
 
diff --git a/cpp/tools/commands/cmd_export.cc b/cpp/tools/commands/cmd_export.cc
new file mode 100644
index 000000000..81526aff4
--- /dev/null
+++ b/cpp/tools/commands/cmd_export.cc
@@ -0,0 +1,383 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * License); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <cstdio>
+#include <set>
+#ifdef _WIN32
+#include <direct.h>
+#define lstat stat
+#endif
+#include <fstream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cli/exit_codes.h"
+#include "commands/commands.h"
+#include "common/device_id.h"
+#include "common/schema.h"
+#include "format/atomic_output.h"
+#include "reader/tsfile_reader.h"
+
+namespace tsfile_cli {
+namespace {
+
+bool stat_is_directory(const struct stat& st) {
+#ifdef _WIN32
+    return (st.st_mode & S_IFDIR) != 0;
+#else
+    return S_ISDIR(st.st_mode);
+#endif
+}
+
+bool directory_exists(const std::string& path) {
+    struct stat st;
+    return stat(path.c_str(), &st) == 0 && stat_is_directory(st);
+}
+
+int make_directory(const std::string& path) {
+#ifdef _WIN32
+    return _mkdir(path.c_str());
+#else
+    return mkdir(path.c_str(), 0777);
+#endif
+}
+
+int create_directory_no_replace(const std::string& path, std::ostream& err) {
+    struct stat existing;
+    if (lstat(path.c_str(), &existing) == 0) {
+        err << "Error: output directory '" << path << "' already exists\n";
+        return kExitRuntime;
+    }
+    if (make_directory(path) != 0) {
+        err << "Error: cannot create output directory '" << path << "'\n";
+        return kExitRuntime;
+    }
+    if (!directory_exists(path)) {
+        err << "Error: output path '" << path << "' is not a directory\n";
+        return kExitRuntime;
+    }
+    return kExitOk;
+}
+
+int write_atomic_text(const std::string& path, const std::string& content,
+                      const std::string& source, bool force,
+                      std::ostream& err) {
+    std::string tmp;
+    int code = prepare_atomic_output(path, source, force, tmp, err);
+    if (code != kExitOk) {
+        return code;
+    }
+    {
+        std::ofstream out(tmp.c_str(), std::ios::binary | std::ios::trunc);
+        if (!out.is_open()) {
+            err << "Error: cannot create output target '" << path << "'\n";
+            remove_atomic_temp(tmp, err);
+            return kExitRuntime;
+        }
+        out << content;
+        out.flush();
+        if (!out.good()) {
+            err << "Error: failed to write output target '" << path << "'\n";
+            out.close();
+            remove_atomic_temp(tmp, err);
+            return kExitRuntime;
+        }
+        out.close();
+        if (out.fail()) {
+            err << "Error: failed to close output target '" << path << "'\n";
+            remove_atomic_temp(tmp, err);
+            return kExitRuntime;
+        }
+    }
+    code = commit_atomic_output(tmp, path, force, err);
+    if (code != kExitOk && !remove_atomic_temp(tmp, err)) {
+        code = kExitRuntime;
+    }
+    return code;
+}
+
+std::string extension_for_format(ParsedArgs::Format fmt) {
+    if (fmt == ParsedArgs::Format::kCsv) {
+        return ".csv";
+    }
+    if (fmt == ParsedArgs::Format::kJson) {
+        return ".ndjson";
+    }
+    return ".txt";
+}
+
+std::string type_name_for_format(ParsedArgs::Format fmt) {
+    if (fmt == ParsedArgs::Format::kCsv) {
+        return "csv";
+    }
+    if (fmt == ParsedArgs::Format::kJson) {
+        return "ndjson";
+    }
+    return "table";
+}
+
+std::string numbered_file_name(size_t index, ParsedArgs::Format fmt) {
+    char buf[32];
+    std::snprintf(buf, sizeof(buf), "%04zu", index + 1);
+    return std::string(buf) + extension_for_format(fmt);
+}
+
+std::string json_escape(const std::string& s) {
+    std::ostringstream out;
+    for (char c : s) {
+        switch (c) {
+            case '\\':
+                out << "\\\\";
+                break;
+            case '"':
+                out << "\\\"";
+                break;
+            case '\n':
+                out << "\\n";
+                break;
+            case '\r':
+                out << "\\r";
+                break;
+            case '\t':
+                out << "\\t";
+                break;
+            default:
+                out << c;
+        }
+    }
+    return out.str();
+}
+
+struct ManifestEntry {
+    std::string file;
+    std::string model;
+    std::string object;
+    std::string type;
+    std::string rows;
+};
+
+std::string render_manifest(bool complete,
+                            const std::vector<ManifestEntry>& entries) {
+    std::ostringstream out;
+    out << "{\n  \"complete\": " << (complete ? "true" : "false")
+        << ",\n  \"files\": [\n";
+    for (size_t i = 0; i < entries.size(); ++i) {
+        const ManifestEntry& e = entries[i];
+        out << "    {\"file\":\"" << json_escape(e.file) << "\",\"model\":\""
+            << json_escape(e.model) << "\",\"object\":\""
+            << json_escape(e.object) << "\",\"type\":\"" << json_escape(e.type)
+            << "\",\"rows\":\"" << json_escape(e.rows) << "\"}";
+        if (i + 1 != entries.size()) {
+            out << ",";
+        }
+        out << "\n";
+    }
+    out << "  ]\n}\n";
+    return out.str();
+}
+
+int write_manifest(const std::string& dir, bool complete,
+                   const std::vector<ManifestEntry>& entries,
+                   std::ostream& err) {
+    return write_atomic_text(dir + "/_manifest.json",
+                             render_manifest(complete, entries), "", true, err);
+}
+
+int stream_query_to_file(const ParsedArgs& args, storage::TsFileReader& reader,
+                         OutputFormat fmt, const std::string& path, bool force,
+                         long long& rows, std::ostream& err) {
+    std::string temp;
+    int code = prepare_atomic_output(path, args.file, force, temp, err);
+    if (code != kExitOk) {
+        return code;
+    }
+    std::ofstream output(temp.c_str(), std::ios::binary | std::ios::trunc);
+    if (!output.is_open()) {
+        err << "Error: cannot open temporary output for '" << path << "'\n";
+        remove_atomic_temp(temp, err);
+        return kExitRuntime;
+    }
+    code = run_row_query(args, reader, fmt, output, err, args.offset,
+                         args.limit, &rows);
+    output.flush();
+    if (code == kExitOk && !output.good()) {
+        err << "Error: failed to flush output target '" << path << "'\n";
+        code = kExitRuntime;
+    }
+    output.close();
+    if (code == kExitOk && output.fail()) {
+        err << "Error: failed to close output target '" << path << "'\n";
+        code = kExitRuntime;
+    }
+    if (code == kExitOk) {
+        code = commit_atomic_output(temp, path, force, err);
+    }
+    if (code != kExitOk && !remove_atomic_temp(temp, err)) {
+        code = kExitRuntime;
+    }
+    return code;
+}
+
+bool table_exists(storage::TsFileReader& reader, const std::string& table) {
+    const std::string canonical = storage::to_lower(table);
+    auto schemas = reader.get_all_table_schemas();
+    for (const auto& schema : schemas) {
+        if (schema && schema->get_table_name() == canonical) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool device_exists(storage::TsFileReader& reader, const std::string& device) {
+    auto did = std::make_shared<storage::StringArrayDeviceID>(device);
+    std::vector<storage::MeasurementSchema> schema;
+    return reader.get_timeseries_schema(did, schema) == 0 && !schema.empty();
+}
+
+int validate_multi_export_objects(const ParsedArgs& args,
+                                  storage::TsFileReader& reader,
+                                  std::ostream& err) {
+    std::set<std::string> seen;
+    if (!args.tables.empty()) {
+        for (const std::string& table : args.tables) {
+            const std::string canonical = storage::to_lower(table);
+            if (!seen.insert(canonical).second) {
+                err << "Error: table '" << table
+                    << "' was specified more than once\n";
+                return kExitUsage;
+            }
+            if (!table_exists(reader, table)) {
+                err << "Error: table '" << table << "' does not exist\n";
+                return kExitUsage;
+            }
+        }
+    } else {
+        for (const std::string& device : args.devices) {
+            if (!seen.insert(device).second) {
+                err << "Error: device '" << device
+                    << "' was specified more than once\n";
+                return kExitUsage;
+            }
+            if (!device_exists(reader, device)) {
+                err << "Error: device '" << device << "' does not exist\n";
+                return kExitUsage;
+            }
+        }
+    }
+    return kExitOk;
+}
+
+}  // namespace
+
+int cmd_export(const ParsedArgs& args, storage::TsFileReader& reader,
+               OutputFormat fmt, std::ostream& /*out*/, std::ostream& err) {
+    const bool multi_object = args.devices.size() + args.tables.size() > 1;
+    if (multi_object) {
+        int code = validate_multi_export_objects(args, reader, err);
+        if (code != kExitOk) {
+            return code;
+        }
+        code = create_directory_no_replace(args.output_dir, err);
+        if (code != kExitOk) {
+            return code;
+        }
+
+        std::vector<ManifestEntry> entries;
+        code = write_manifest(args.output_dir, false, entries, err);
+        if (code != kExitOk) {
+            return code;
+        }
+
+        const std::vector<std::string>& objects =
+            !args.tables.empty() ? args.tables : args.devices;
+        const bool table_mode = !args.tables.empty();
+        for (size_t i = 0; i < objects.size(); ++i) {
+            ParsedArgs one = args;
+            one.output = args.output_dir + "/" +
+                         numbered_file_name(i, args.export_format);
+            one.output_dir.clear();
+            one.devices.clear();
+            one.tables.clear();
+            one.device.clear();
+            one.table.clear();
+            if (table_mode) {
+                one.table = storage::to_lower(objects[i]);
+                one.tables.push_back(one.table);
+            } else {
+                one.device = objects[i];
+                one.devices.push_back(objects[i]);
+            }
+            one.command = "cat";
+            long long rows = 0;
+            code = stream_query_to_file(one, reader, fmt, one.output, false,
+                                        rows, err);
+            if (code != kExitOk) {
+                return code;
+            }
+            entries.push_back({numbered_file_name(i, args.export_format),
+                               table_mode ? "table" : "tree",
+                               table_mode ? one.table : objects[i],
+                               type_name_for_format(args.export_format),
+                               std::to_string(rows)});
+            code = write_manifest(args.output_dir, false, entries, err);
+            if (code != kExitOk) {
+                if (std::remove(one.output.c_str()) != 0) {
+                    err << "Error: failed to clean unrecorded output '"
+                        << one.output << "'\n";
+                    return kExitRuntime;
+                }
+                return code;
+            }
+        }
+        return write_manifest(args.output_dir, true, entries, err);
+    }
+
+    ParsedArgs query = args;
+    query.command = "cat";
+    long long rows = 0;
+    return stream_query_to_file(query, reader, fmt, args.output, args.force,
+                                rows, err);
+}
+
+int cmd_sketch(const ParsedArgs& args, storage::TsFileReader& reader,
+               std::ostream& out, std::ostream& err) {
+    std::ostringstream content;
+    content << "-------------------------------- TsFile Sketch "
+               "--------------------------------\n"
+            << "file path: " << args.file << "\n"
+            << "model: " << (is_table_model(args, reader) ? "table" : "tree")
+            << "\n"
+            << "---------------------------------- TsFile Sketch End "
+               "----------------------------------\n";
+    if (args.output.empty()) {
+        out << content.str();
+        out.flush();
+        return out.good() ? kExitOk : kExitRuntime;
+    }
+    return write_atomic_text(args.output, content.str(), args.file, args.force,
+                             err);
+}
+
+}  // namespace tsfile_cli
diff --git a/cpp/tools/commands/cmd_ls.cc b/cpp/tools/commands/cmd_ls.cc
index 675151e8a..005184f2b 100644
--- a/cpp/tools/commands/cmd_ls.cc
+++ b/cpp/tools/commands/cmd_ls.cc
@@ -37,7 +37,7 @@ bool is_table_model(const ParsedArgs& args, storage::TsFileReader& reader) {
 }
 
 int cmd_ls(const ParsedArgs& args, storage::TsFileReader& reader,
-           OutputFormat fmt, std::ostream& out, std::ostream& /*err*/) {
+           OutputFormat fmt, std::ostream& out, std::ostream& err) {
     std::vector<std::string> names;
     if (is_table_model(args, reader)) {
         for (auto& ts : reader.get_all_table_schemas()) {
@@ -53,11 +53,19 @@ int cmd_ls(const ParsedArgs& args, storage::TsFileReader& reader,
         }
     }
 
-    RowWriter w(out, fmt, {"name"}, {common::STRING}, args.no_header);
+    const std::string model = is_table_model(args, reader) ? "table" : "tree";
+    RowWriter w(out, fmt, {"model", "object"}, {common::STRING, common::STRING},
+                false);
     for (const std::string& n : names) {
-        w.write({n}, {false});
+        if (!w.write({model, n}, {false, false})) {
+            err << "Error: failed to write output\n";
+            return kExitRuntime;
+        }
+    }
+    if (!w.finish()) {
+        err << "Error: failed to write output\n";
+        return kExitRuntime;
     }
-    w.finish();
     return kExitOk;
 }
 
diff --git a/cpp/tools/commands/cmd_meta.cc b/cpp/tools/commands/cmd_meta.cc
index dd70029f3..5f923b313 100644
--- a/cpp/tools/commands/cmd_meta.cc
+++ b/cpp/tools/commands/cmd_meta.cc
@@ -27,23 +27,17 @@
 namespace tsfile_cli {
 
 int cmd_meta(const ParsedArgs& args, storage::TsFileReader& reader,
-             OutputFormat fmt, std::ostream& out, std::ostream& /*err*/) {
-    RowWriter w(out, fmt,
-                {"file", "model", "device_count", "table_count", "series_count",
-                 "start_time", "end_time", "file_size_bytes"},
-                {common::STRING, common::STRING, common::INT64, common::INT64,
-                 common::INT64, common::INT64, common::INT64, common::INT64},
-                args.no_header);
-
+             OutputFormat fmt, std::ostream& out, std::ostream& err) {
     FileSummary s = collect_file_summary(args, reader);
-    w.write({s.file, s.model, std::to_string(s.device_count),
-             std::to_string(s.table_count), std::to_string(s.series_count),
-             s.has_time_range ? std::to_string(s.start_time) : "",
-             s.has_time_range ? std::to_string(s.end_time) : "",
-             std::to_string(s.file_size_bytes)},
-            {false, false, false, false, false, !s.has_time_range,
-             !s.has_time_range, false});
-    w.finish();
+    RowWriter w(out, fmt, {"size_bytes", "format_version", "model"},
+                {common::INT64, common::INT64, common::STRING}, false);
+    if (!w.write({std::to_string(s.file_size_bytes),
+                  std::to_string(reader.get_file_version()), s.model},
+                 {false, false, false}) ||
+        !w.finish()) {
+        err << "Error: failed to write output\n";
+        return kExitRuntime;
+    }
     return kExitOk;
 }
 
diff --git a/cpp/tools/commands/cmd_sample.cc b/cpp/tools/commands/cmd_sample.cc
deleted file mode 100644
index 0a9c06360..000000000
--- a/cpp/tools/commands/cmd_sample.cc
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * License); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <limits>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "cli/exit_codes.h"
-#include "commands/commands.h"
-#include "common/schema.h"
-#include "format/result_set_format.h"
-#include "reader/filter/filter.h"
-#include "reader/tsfile_reader.h"
-
-namespace tsfile_cli {
-
-int cmd_sample(const ParsedArgs& args, storage::TsFileReader& reader,
-               OutputFormat fmt, std::ostream& out, std::ostream& err) {
-    const int64_t start = args.has_start ? static_cast<int64_t>(args.start)
-                                         : std::numeric_limits<int64_t>::min();
-    const int64_t end = args.has_end ? static_cast<int64_t>(args.end)
-                                     : std::numeric_limits<int64_t>::max();
-    storage::ResultSet* rs = nullptr;
-    int qret = 0;
-    std::unique_ptr<storage::Filter> tag_filter;
-
-    if (is_table_model(args, reader)) {
-        std::string table_name = args.table;
-        if (table_name.empty()) {
-            auto schemas = reader.get_all_table_schemas();
-            if (schemas.empty() || !schemas[0]) {
-                err << "Error: no table found in file\n";
-                return kExitRuntime;
-            }
-            table_name = schemas[0]->get_table_name();
-        }
-        std::vector<std::string> cols = args.measurements;
-        if (cols.empty()) {
-            auto ts = reader.get_table_schema(table_name);
-            if (ts) {
-                cols = ts->get_measurement_names();
-            }
-        }
-        tag_filter = build_table_tag_filter(args, reader, table_name, err);
-        if (args.has_tag_filter && tag_filter == nullptr) {
-            return kExitUsage;
-        }
-        qret = reader.query(table_name, cols, start, end, rs, tag_filter.get());
-    } else {
-        if (args.has_tag_filter) {
-            err << "Error: tag filter flags are only valid for table model\n";
-            return kExitUsage;
-        }
-        std::vector<std::string> paths = collect_tree_query_paths(args, reader);
-        if (paths.empty()) {
-            err << "Error: no time series found\n";
-            return kExitRuntime;
-        }
-        qret = reader.query(paths, start, end, rs);
-    }
-
-    if (qret != 0 || rs == nullptr) {
-        err << "Error: query failed: " << error_code_message(qret) << "\n";
-        if (rs != nullptr) {
-            reader.destroy_query_data_set(rs);
-        }
-        return kExitRuntime;
-    }
-
-    const long long limit = args.limit < 0 ? 10 : args.limit;
-    const unsigned long long seed =
-        args.has_seed ? static_cast<unsigned long long>(args.seed) : 0ULL;
-    int wret =
-        emit_result_set_sampled(rs, fmt, args.no_header, out, limit, seed);
-    reader.destroy_query_data_set(rs);
-    if (wret != 0) {
-        err << "Error: failed to read rows: " << error_code_message(wret)
-            << "\n";
-        return kExitRuntime;
-    }
-    return kExitOk;
-}
-
-}  // namespace tsfile_cli
diff --git a/cpp/tools/commands/cmd_schema.cc b/cpp/tools/commands/cmd_schema.cc
index 9b8442d8c..ad623e85c 100644
--- a/cpp/tools/commands/cmd_schema.cc
+++ b/cpp/tools/commands/cmd_schema.cc
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <map>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -32,10 +33,46 @@
 namespace tsfile_cli {
 namespace {
 
-void write_table_schema_rows(const ParsedArgs& args,
-                             storage::TsFileReader& reader, RowWriter& w) {
+const char* column_category_name(common::ColumnCategory category) {
+    switch (category) {
+        case common::ColumnCategory::TIME:
+            return "TIME";
+        case common::ColumnCategory::TAG:
+            return "TAG";
+        case common::ColumnCategory::ATTRIBUTE:
+            return "ATTRIBUTE";
+        case common::ColumnCategory::FIELD:
+        default:
+            return "FIELD";
+    }
+}
+
+struct SchemaRow {
+    std::vector<std::string> cells;
+    std::vector<bool> nulls;
+};
+
+bool table_measurement_selected(const ParsedArgs& args,
+                                const std::string& name) {
+    if (args.measurements.empty()) {
+        return true;
+    }
+    const std::string folded_name = storage::to_lower(name);
+    for (const std::string& requested : args.measurements) {
+        if (storage::to_lower(requested) == folded_name) {
+            return true;
+        }
+    }
+    return false;
+}
+
+int collect_table_schema_rows(const ParsedArgs& args,
+                              storage::TsFileReader& reader,
+                              std::vector<SchemaRow>& rows, std::ostream& err) {
     const std::string target_table_name = storage::to_lower(args.table);
     auto schemas = reader.get_all_table_schemas();
+    bool matched_table = target_table_name.empty();
+    std::set<std::string> matched_measurements;
     for (auto& schema : schemas) {
         if (!schema) {
             continue;
@@ -44,88 +81,147 @@ void write_table_schema_rows(const ParsedArgs& args,
             schema->get_table_name() != target_table_name) {
             continue;
         }
-        for (const auto& ms : schema->get_measurement_schemas()) {
+        matched_table = true;
+        auto categories = schema->get_column_categories();
+        auto measurements = schema->get_measurement_schemas();
+        for (size_t i = 0; i < measurements.size(); ++i) {
+            const auto& ms = measurements[i];
             if (!ms) {
                 continue;
             }
             const std::string& name = ms->measurement_name_;
-            if (!args.measurements.empty() &&
-                std::find(args.measurements.begin(), args.measurements.end(),
-                          name) == args.measurements.end()) {
+            if (!table_measurement_selected(args, name)) {
                 continue;
             }
-            w.write({schema->get_table_name(), name,
-                     tsdatatype_name(ms->data_type_),
-                     tsencoding_name(ms->encoding_),
-                     compression_name(ms->compression_type_)},
-                    {false, false, false, false, false});
+            matched_measurements.insert(storage::to_lower(name));
+            common::ColumnCategory category =
+                i < categories.size() ? categories[i]
+                                      : common::ColumnCategory::FIELD;
+            const bool physical_null =
+                category == common::ColumnCategory::TIME ||
+                category == common::ColumnCategory::ATTRIBUTE;
+            rows.push_back(
+                {{"table", schema->get_table_name(), name,
+                  column_category_name(category),
+                  tsdatatype_name(ms->data_type_),
+                  physical_null ? "" : tsencoding_name(ms->encoding_),
+                  physical_null ? "" : compression_name(ms->compression_type_)},
+                 {false, false, false, false, false, physical_null,
+                  physical_null}});
         }
     }
+    if (!matched_table) {
+        err << "Error: table '" << args.table << "' does not exist\n";
+        return kExitUsage;
+    }
+    for (const std::string& requested : args.measurements) {
+        if (matched_measurements.find(storage::to_lower(requested)) ==
+            matched_measurements.end()) {
+            err << "Error: column '" << requested << "' does not exist";
+            if (!args.table.empty()) {
+                err << " in table '" << target_table_name << "'";
+            }
+            err << "\n";
+            return kExitUsage;
+        }
+    }
+    return kExitOk;
 }
 
 }  // namespace
 
 int cmd_schema(const ParsedArgs& args, storage::TsFileReader& reader,
-               OutputFormat fmt, std::ostream& out, std::ostream& /*err*/) {
-    RowWriter w(
-        out, fmt,
-        {"target", "measurement", "datatype", "encoding", "compression"},
-        {common::STRING, common::STRING, common::STRING, common::STRING,
-         common::STRING},
-        args.no_header);
-
+               OutputFormat fmt, std::ostream& out, std::ostream& err) {
+    std::vector<SchemaRow> rows;
     if (is_table_model(args, reader)) {
-        write_table_schema_rows(args, reader, w);
-        w.finish();
-        return kExitOk;
-    }
-
-    storage::DeviceTimeseriesMetadataMap meta =
-        reader.get_timeseries_metadata();
-    for (auto& kv : meta) {
-        std::string target = kv.first ? kv.first->get_device_name() : "";
-        if (!args.device.empty() && target != args.device) {
-            continue;
+        int ret = collect_table_schema_rows(args, reader, rows, err);
+        if (ret != kExitOk) {
+            return ret;
         }
+    } else {
+        storage::DeviceTimeseriesMetadataMap meta =
+            reader.get_timeseries_metadata();
+        bool matched_device = args.device.empty();
+        std::set<std::string> matched_measurements;
+        for (auto& kv : meta) {
+            std::string target = kv.first ? kv.first->get_device_name() : "";
+            if (!args.device.empty() && target != args.device) {
+                continue;
+            }
+            matched_device = true;
 
-        // The timeseries metadata (kv.second) carries the data type but not the
-        // encoding/compression, so fetch the measurement schema separately to
-        // fill those two columns, keyed by measurement name.
-        std::map<std::string, std::pair<std::string, std::string>> enc_comp;
-        if (kv.first) {
-            std::vector<storage::MeasurementSchema> ms;
-            if (reader.get_timeseries_schema(kv.first, ms) == 0) {
-                for (auto& m : ms) {
-                    enc_comp[m.measurement_name_] =
-                        std::make_pair(tsencoding_name(m.encoding_),
-                                       compression_name(m.compression_type_));
+            std::map<std::string, std::pair<std::string, std::string>> enc_comp;
+            if (kv.first) {
+                std::vector<storage::MeasurementSchema> ms;
+                if (reader.get_timeseries_schema(kv.first, ms) == 0) {
+                    for (auto& m : ms) {
+                        enc_comp[m.measurement_name_] = std::make_pair(
+                            tsencoding_name(m.encoding_),
+                            compression_name(m.compression_type_));
+                    }
                 }
             }
-        }
 
-        for (auto& ts : kv.second) {
-            if (!ts) {
-                continue;
-            }
-            std::string m = ts->get_measurement_name().to_std_string();
-            if (!args.measurements.empty() &&
-                std::find(args.measurements.begin(), args.measurements.end(),
-                          m) == args.measurements.end()) {
-                continue;
+            for (auto& ts : kv.second) {
+                if (!ts) {
+                    continue;
+                }
+                std::string m = ts->get_measurement_name().to_std_string();
+                if (!args.measurements.empty() &&
+                    std::find(args.measurements.begin(),
+                              args.measurements.end(),
+                              m) == args.measurements.end()) {
+                    continue;
+                }
+                matched_measurements.insert(m);
+                std::string enc;
+                std::string comp;
+                auto it = enc_comp.find(m);
+                if (it != enc_comp.end()) {
+                    enc = it->second.first;
+                    comp = it->second.second;
+                }
+                rows.push_back(
+                    {{"tree", target, m, "FIELD",
+                      tsdatatype_name(ts->get_data_type()), enc, comp},
+                     {false, false, false, false, false, enc.empty(),
+                      comp.empty()}});
             }
-            std::string enc;
-            std::string comp;
-            auto it = enc_comp.find(m);
-            if (it != enc_comp.end()) {
-                enc = it->second.first;
-                comp = it->second.second;
+        }
+        if (!matched_device) {
+            err << "Error: device '" << args.device << "' does not exist\n";
+            return kExitUsage;
+        }
+        for (const std::string& requested : args.measurements) {
+            if (matched_measurements.find(requested) ==
+                matched_measurements.end()) {
+                err << "Error: measurement '" << requested
+                    << "' does not exist";
+                if (!args.device.empty()) {
+                    err << " in device '" << args.device << "'";
+                }
+                err << "\n";
+                return kExitUsage;
             }
-            w.write(
-                {target, m, tsdatatype_name(ts->get_data_type()), enc, comp},
-                {false, false, false, enc.empty(), comp.empty()});
         }
     }
-    w.finish();
+
+    RowWriter w(out, fmt,
+                {"model", "object", "column", "category", "data_type",
+                 "encoding", "compression"},
+                {common::STRING, common::STRING, common::STRING, common::STRING,
+                 common::STRING, common::STRING, common::STRING},
+                args.no_header);
+    for (const SchemaRow& row : rows) {
+        if (!w.write(row.cells, row.nulls)) {
+            err << "Error: failed to write output\n";
+            return kExitRuntime;
+        }
+    }
+    if (!w.finish()) {
+        err << "Error: failed to write output\n";
+        return kExitRuntime;
+    }
     return kExitOk;
 }
 
diff --git a/cpp/tools/commands/cmd_stats.cc b/cpp/tools/commands/cmd_stats.cc
index 898ca469b..f50157cfb 100644
--- a/cpp/tools/commands/cmd_stats.cc
+++ b/cpp/tools/commands/cmd_stats.cc
@@ -17,40 +17,517 @@
  * under the License.
  */
 
+#include <algorithm>
+#include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "cli/exit_codes.h"
 #include "commands/commands.h"
 #include "commands/statistics.h"
+#include "common/schema.h"
+#include "format/result_set_format.h"
+#include "reader/tsfile_reader.h"
+#include "utils/storage_utils.h"
 
 namespace tsfile_cli {
+namespace {
+
+struct StatsColumn {
+    std::string name;
+    common::TSDataType type;
+    common::ColumnCategory category;
+};
+
+struct FieldStatistic {
+    long long count = 0;
+    long long start_time = 0;
+    long long end_time = 0;
+    bool present = false;
+    StatisticCells values;
+};
+
+struct EntityAccumulator {
+    std::vector<std::string> tag_values;
+    std::vector<bool> tag_nulls;
+    std::map<std::string, FieldStatistic> fields;
+    long long row_count = 0;
+    bool has_timeline_statistic = false;
+};
+
+struct TableStatsSummary {
+    std::shared_ptr<storage::TableSchema> schema;
+    std::vector<StatsColumn> columns;
+    std::vector<size_t> tag_indexes;
+    std::vector<size_t> field_indexes;
+    std::map<std::string, EntityAccumulator> entities;
+    std::vector<std::string> entity_order;
+};
+
+const char* stats_column_category_name(common::ColumnCategory category) {
+    switch (category) {
+        case common::ColumnCategory::TAG:
+            return "TAG";
+        case common::ColumnCategory::ATTRIBUTE:
+            return "ATTRIBUTE";
+        case common::ColumnCategory::TIME:
+            return "TIME";
+        case common::ColumnCategory::FIELD:
+        default:
+            return "FIELD";
+    }
+}
+
+bool capture_timeline_statistic(storage::ITimeseriesIndex* index,
+                                EntityAccumulator& entity) {
+    if (index == nullptr) {
+        return false;
+    }
+    storage::Statistic* statistic = nullptr;
+    auto* aligned = dynamic_cast<storage::AlignedTimeseriesIndex*>(index);
+    if (aligned != nullptr && aligned->time_ts_idx_ != nullptr) {
+        statistic = aligned->time_ts_idx_->get_statistic();
+    }
+    auto* multi = dynamic_cast<storage::MultiAlignedTimeseriesIndex*>(index);
+    if (multi != nullptr && multi->time_ts_idx_ != nullptr) {
+        statistic = multi->time_ts_idx_->get_statistic();
+    }
+    if (statistic != nullptr) {
+        entity.row_count = statistic->get_count();
+        entity.has_timeline_statistic = true;
+        return true;
+    }
+
+    common::SimpleList<storage::ChunkMeta*>* chunk_metas =
+        index->get_time_chunk_meta_list();
+    if (chunk_metas == nullptr) {
+        return false;
+    }
+    long long row_count = 0;
+    bool found = false;
+    for (auto it = chunk_metas->begin(); it != chunk_metas->end(); it++) {
+        storage::ChunkMeta* chunk_meta = it.get();
+        if (chunk_meta == nullptr || chunk_meta->statistic_ == nullptr) {
+            continue;
+        }
+        row_count += chunk_meta->statistic_->get_count();
+        found = true;
+    }
+    if (found) {
+        entity.row_count = row_count;
+        entity.has_timeline_statistic = true;
+    }
+    return found;
+}
+
+void capture_field_statistic(storage::TimeseriesIndex* index,
+                             const std::set<std::string>& selected_fields,
+                             EntityAccumulator& entity) {
+    if (index == nullptr) {
+        return;
+    }
+    const std::string name = index->get_measurement_name().to_std_string();
+    if (selected_fields.find(name) == selected_fields.end()) {
+        return;
+    }
+    storage::Statistic* statistic = index->get_statistic();
+    if (statistic == nullptr) {
+        return;
+    }
+    FieldStatistic field;
+    field.count = statistic->get_count();
+    field.start_time = statistic->start_time_;
+    field.end_time = statistic->get_end_time();
+    field.present = true;
+    field.values = statistic_value_cells(statistic);
+    entity.fields[name] = field;
+}
+
+bool selected_for_stats(const ParsedArgs& args, const std::string& name) {
+    if (args.measurements.empty()) {
+        return true;
+    }
+    for (const std::string& requested : args.measurements) {
+        if (storage::to_lower(requested) == name) {
+            return true;
+        }
+    }
+    return false;
+}
+
+int collect_table_stats(const ParsedArgs& args,
+                        const std::shared_ptr<storage::TableSchema>& schema,
+                        storage::TsFileReader& reader,
+                        TableStatsSummary& summary, std::ostream& err,
+                        bool require_all_measurements) {
+    if (!schema) {
+        err << "Error: table '" << args.table << "' does not exist\n";
+        return kExitUsage;
+    }
+    summary.schema = schema;
+
+    auto categories = schema->get_column_categories();
+    auto measurements = schema->get_measurement_schemas();
+    summary.columns.resize(measurements.size());
+    std::set<std::string> known_columns;
+    std::set<std::string> field_names;
+    std::set<std::string> selected_fields;
+    for (size_t i = 0; i < measurements.size(); ++i) {
+        if (!measurements[i]) {
+            continue;
+        }
+        StatsColumn c;
+        c.name = measurements[i]->measurement_name_;
+        c.type = measurements[i]->data_type_;
+        c.category = i < categories.size() ? categories[i]
+                                           : common::ColumnCategory::FIELD;
+        summary.columns[i] = c;
+        known_columns.insert(c.name);
+        if (c.category == common::ColumnCategory::TAG) {
+            summary.tag_indexes.push_back(i);
+        } else if (c.category == common::ColumnCategory::FIELD) {
+            field_names.insert(c.name);
+            if (selected_for_stats(args, c.name)) {
+                summary.field_indexes.push_back(i);
+                selected_fields.insert(c.name);
+            }
+        }
+    }
+    if (require_all_measurements) {
+        for (const std::string& requested : args.measurements) {
+            const std::string canonical = storage::to_lower(requested);
+            if (known_columns.find(canonical) == known_columns.end()) {
+                err << "Error: FIELD '" << requested
+                    << "' does not exist in table " << schema->get_table_name()
+                    << "\n";
+                return kExitUsage;
+            }
+            if (field_names.find(canonical) == field_names.end()) {
+                common::ColumnCategory category = common::ColumnCategory::TAG;
+                int index = schema->find_column_index(canonical);
+                if (index >= 0 &&
+                    static_cast<size_t>(index) < categories.size()) {
+                    category = categories[static_cast<size_t>(index)];
+                }
+                err << "Error: '" << requested << "' is a "
+                    << stats_column_category_name(category)
+                    << "; stats accepts FIELD columns only\n";
+                return kExitUsage;
+            }
+        }
+    }
+
+    std::vector<std::shared_ptr<storage::IDeviceID>> devices =
+        reader.get_all_devices(schema->get_table_name());
+    storage::DeviceTimeseriesMetadataMap metadata =
+        reader.get_timeseries_metadata(devices);
+    for (const auto& device : devices) {
+        if (!device) {
+            continue;
+        }
+        const std::string key = device->get_device_name();
+        EntityAccumulator entity;
+        const auto& segments = device->get_segments();
+        for (size_t i = 0; i < summary.tag_indexes.size(); ++i) {
+            const size_t segment_index = i + 1;
+            const std::string* segment = segment_index < segments.size()
+                                             ? segments[segment_index]
+                                             : nullptr;
+            entity.tag_values.push_back(segment == nullptr ? "" : *segment);
+            entity.tag_nulls.push_back(segment == nullptr);
+        }
+
+        auto metadata_it = metadata.find(device);
+        if (metadata_it != metadata.end()) {
+            for (const auto& index_ptr : metadata_it->second) {
+                storage::ITimeseriesIndex* index = index_ptr.get();
+                if (!entity.has_timeline_statistic) {
+                    capture_timeline_statistic(index, entity);
+                }
+                auto* multi =
+                    dynamic_cast<storage::MultiAlignedTimeseriesIndex*>(index);
+                if (multi != nullptr) {
+                    for (storage::TimeseriesIndex* value_index :
+                         multi->get_value_indices()) {
+                        capture_field_statistic(value_index, selected_fields,
+                                                entity);
+                    }
+                    continue;
+                }
+                auto* aligned =
+                    dynamic_cast<storage::AlignedTimeseriesIndex*>(index);
+                if (aligned != nullptr) {
+                    capture_field_statistic(aligned->value_ts_idx_,
+                                            selected_fields, entity);
+                } else {
+                    capture_field_statistic(
+                        dynamic_cast<storage::TimeseriesIndex*>(index),
+                        selected_fields, entity);
+                }
+            }
+        }
+        summary.entities[key] = entity;
+        summary.entity_order.push_back(key);
+    }
+
+    return kExitOk;
+}
+
+int cmd_table_stats(const ParsedArgs& args, storage::TsFileReader& reader,
+                    OutputFormat fmt, std::ostream& out, std::ostream& err) {
+    std::vector<std::shared_ptr<storage::TableSchema>> schemas;
+    if (!args.table.empty()) {
+        schemas.push_back(
+            reader.get_table_schema(storage::to_lower(args.table)));
+    } else {
+        schemas = reader.get_all_table_schemas();
+    }
+    if (schemas.empty() || !schemas[0]) {
+        err << "Error: table '" << args.table << "' does not exist\n";
+        return kExitUsage;
+    }
+
+    if (args.table.empty()) {
+        for (const std::string& requested : args.measurements) {
+            const std::string canonical = storage::to_lower(requested);
+            bool found_field = false;
+            common::ColumnCategory found_category =
+                common::ColumnCategory::FIELD;
+            bool found_other = false;
+            for (const auto& schema : schemas) {
+                if (!schema) {
+                    continue;
+                }
+                const int index = schema->find_column_index(canonical);
+                if (index < 0) {
+                    continue;
+                }
+                const auto categories = schema->get_column_categories();
+                const common::ColumnCategory category =
+                    static_cast<size_t>(index) < categories.size()
+                        ? categories[static_cast<size_t>(index)]
+                        : common::ColumnCategory::FIELD;
+                if (category == common::ColumnCategory::FIELD) {
+                    found_field = true;
+                } else if (!found_other) {
+                    found_category = category;
+                    found_other = true;
+                }
+            }
+            if (!found_field) {
+                if (found_other) {
+                    err << "Error: '" << requested << "' is a "
+                        << stats_column_category_name(found_category)
+                        << "; stats accepts FIELD columns only\n";
+                } else {
+                    err << "Error: FIELD '" << requested
+                        << "' does not exist in the file\n";
+                }
+                return kExitUsage;
+            }
+        }
+    }
+
+    std::vector<TableStatsSummary> summaries(schemas.size());
+    std::vector<std::string> union_tags;
+    std::set<std::string> seen_tags;
+    for (size_t i = 0; i < schemas.size(); ++i) {
+        ParsedArgs scope = args;
+        scope.table = schemas[i] ? schemas[i]->get_table_name() : "";
+        int ret = collect_table_stats(scope, schemas[i], reader, summaries[i],
+                                      err, !args.table.empty());
+        if (ret != kExitOk) {
+            return ret;
+        }
+        for (size_t tag_index : summaries[i].tag_indexes) {
+            const std::string& tag = summaries[i].columns[tag_index].name;
+            if (seen_tags.insert(tag).second) {
+                union_tags.push_back(tag);
+            }
+        }
+    }
+
+    std::vector<std::string> headers = {"model", "object"};
+    std::vector<common::TSDataType> types = {common::STRING, common::STRING};
+    for (const std::string& tag : union_tags) {
+        headers.push_back("tag." + tag);
+        types.push_back(common::STRING);
+    }
+    const char* rest[] = {"field",      "data_type", "non_null_count",
+                          "null_count", "min_time",  "max_time",
+                          "min",        "max",       "first",
+                          "last",       "sum",       "stats_source"};
+    for (const char* h : rest) {
+        headers.push_back(h);
+        types.push_back(common::STRING);
+    }
+    RowWriter w(out, fmt, headers, types, args.no_header);
+    for (const TableStatsSummary& summary : summaries) {
+        std::map<std::string, size_t> local_tag_positions;
+        for (size_t i = 0; i < summary.tag_indexes.size(); ++i) {
+            local_tag_positions[summary.columns[summary.tag_indexes[i]].name] =
+                i;
+        }
+        for (const std::string& key : summary.entity_order) {
+            const EntityAccumulator& entity =
+                summary.entities.find(key)->second;
+            for (size_t idx : summary.field_indexes) {
+                const StatsColumn& field = summary.columns[idx];
+                auto it = entity.fields.find(field.name);
+                FieldStatistic statistic;
+                if (it != entity.fields.end()) {
+                    statistic = it->second;
+                }
+                const bool has_statistic = statistic.present;
+                const bool has_null_count =
+                    has_statistic && entity.has_timeline_statistic;
+                const long long null_count =
+                    has_null_count ? entity.row_count - statistic.count : 0;
+                std::vector<std::string> cells = {
+                    "table", summary.schema->get_table_name()};
+                std::vector<bool> nulls = {false, false};
+                for (const std::string& tag : union_tags) {
+                    auto position = local_tag_positions.find(tag);
+                    if (position == local_tag_positions.end()) {
+                        cells.push_back("");
+                        nulls.push_back(true);
+                    } else {
+                        cells.push_back(entity.tag_values[position->second]);
+                        nulls.push_back(entity.tag_nulls[position->second]);
+                    }
+                }
+                cells.push_back(field.name);
+                cells.push_back(tsdatatype_name(field.type));
+                cells.push_back(has_statistic ? std::to_string(statistic.count)
+                                              : "");
+                cells.push_back(has_null_count ? std::to_string(null_count)
+                                               : "");
+                cells.push_back(
+                    has_statistic ? std::to_string(statistic.start_time) : "");
+                cells.push_back(
+                    has_statistic ? std::to_string(statistic.end_time) : "");
+                nulls.insert(nulls.end(),
+                             {false, false, !has_statistic, !has_null_count,
+                              !has_statistic, !has_statistic});
+
+                StatisticCells values;
+                values.values.assign(5, "");
+                values.is_null.assign(5, true);
+                if (has_statistic) {
+                    values = statistic.values;
+                }
+                cells.insert(cells.end(), values.values.begin(),
+                             values.values.end());
+                nulls.insert(nulls.end(), values.is_null.begin(),
+                             values.is_null.end());
+                cells.push_back(has_statistic ? "statistics" : "");
+                nulls.push_back(!has_statistic);
+                std::vector<common::TSDataType> row_types(types.size(),
+                                                          common::STRING);
+                const size_t fixed = 2 + union_tags.size();
+                row_types[fixed + 2] = common::INT64;
+                row_types[fixed + 3] = common::INT64;
+                row_types[fixed + 4] = common::INT64;
+                row_types[fixed + 5] = common::INT64;
+                for (size_t value = 0; value < 4; ++value) {
+                    row_types[fixed + 6 + value] = field.type;
+                }
+                if (field.type == common::BOOLEAN ||
+                    field.type == common::INT32 || field.type == common::DATE ||
+                    field.type == common::INT64 ||
+                    field.type == common::TIMESTAMP) {
+                    row_types[fixed + 10] = common::INT64;
+                } else if (field.type == common::FLOAT ||
+                           field.type == common::DOUBLE) {
+                    row_types[fixed + 10] = field.type;
+                }
+                if (!w.write(cells, nulls, row_types)) {
+                    err << "Error: failed to write output\n";
+                    return kExitRuntime;
+                }
+            }
+        }
+    }
+    if (!w.finish()) {
+        err << "Error: failed to write output\n";
+        return kExitRuntime;
+    }
+    return kExitOk;
+}
+
+}  // namespace
 
 int cmd_stats(const ParsedArgs& args, storage::TsFileReader& reader,
-              OutputFormat fmt, std::ostream& out, std::ostream& /*err*/) {
+              OutputFormat fmt, std::ostream& out, std::ostream& err) {
+    if (is_table_model(args, reader)) {
+        return cmd_table_stats(args, reader, fmt, out, err);
+    }
+
     RowWriter w(out, fmt,
-                {"target", "measurement", "count", "start_time", "end_time",
-                 "min", "max", "first", "last", "sum"},
-                {common::STRING, common::STRING, common::INT64, common::INT64,
-                 common::INT64, common::STRING, common::STRING, common::STRING,
+                {"model", "object", "field", "data_type", "non_null_count",
+                 "null_count", "min_time", "max_time", "min", "max", "first",
+                 "last", "sum", "stats_source"},
+                {common::STRING, common::STRING, common::STRING, common::STRING,
+                 common::INT64, common::INT64, common::INT64, common::INT64,
+                 common::STRING, common::STRING, common::STRING, common::STRING,
                  common::STRING, common::STRING},
                 args.no_header);
 
-    std::vector<SeriesStatRow> rows = collect_series_stats(args, reader);
+    std::vector<SeriesStatRow> rows;
+    int collect_ret = collect_series_stats(args, reader, rows, err);
+    if (collect_ret != kExitOk) {
+        return collect_ret;
+    }
     for (const SeriesStatRow& row : rows) {
+        const long long null_count = row.row_count - row.count;
         std::vector<std::string> cells = {
-            row.target, row.measurement, std::to_string(row.count),
-            std::to_string(row.start_time), std::to_string(row.end_time)};
+            "tree",
+            row.target,
+            row.measurement,
+            tsdatatype_name(row.data_type),
+            row.has_statistic ? std::to_string(row.count) : "",
+            row.has_statistic ? std::to_string(null_count) : "",
+            row.has_statistic ? std::to_string(row.start_time) : "",
+            row.has_statistic ? std::to_string(row.end_time) : ""};
         cells.insert(cells.end(), row.value_cells.values.begin(),
                      row.value_cells.values.end());
+        cells.push_back(row.has_statistic ? "statistics" : "");
 
-        std::vector<bool> nulls = {false, false, false, row.count == 0,
-                                   row.count == 0};
+        std::vector<bool> nulls = {false,
+                                   false,
+                                   false,
+                                   false,
+                                   !row.has_statistic,
+                                   !row.has_statistic,
+                                   !row.has_statistic,
+                                   !row.has_statistic};
         nulls.insert(nulls.end(), row.value_cells.is_null.begin(),
                      row.value_cells.is_null.end());
-        w.write(cells, nulls);
+        nulls.push_back(!row.has_statistic);
+        std::vector<common::TSDataType> row_types = {
+            common::STRING, common::STRING, common::STRING, common::STRING,
+            common::INT64,  common::INT64,  common::INT64,  common::INT64,
+            row.data_type,  row.data_type,  row.data_type,  row.data_type,
+            common::STRING, common::STRING};
+        if (row.data_type == common::BOOLEAN ||
+            row.data_type == common::INT32 || row.data_type == common::DATE ||
+            row.data_type == common::INT64 ||
+            row.data_type == common::TIMESTAMP) {
+            row_types[12] = common::INT64;
+        } else if (row.data_type == common::FLOAT ||
+                   row.data_type == common::DOUBLE) {
+            row_types[12] = row.data_type;
+        }
+        if (!w.write(cells, nulls, row_types)) {
+            err << "Error: failed to write output\n";
+            return kExitRuntime;
+        }
+    }
+    if (!w.finish()) {
+        err << "Error: failed to write output\n";
+        return kExitRuntime;
     }
-    w.finish();
     return kExitOk;
 }
 
diff --git a/cpp/tools/commands/cmd_write.cc b/cpp/tools/commands/cmd_write.cc
index 15cee6256..6622e7416 100644
--- a/cpp/tools/commands/cmd_write.cc
+++ b/cpp/tools/commands/cmd_write.cc
@@ -18,8 +18,10 @@
  */
 
 #include <fcntl.h>
+#include <sys/stat.h>
 
 #include <algorithm>
+#include <cctype>
 #include <cerrno>
 #include <cstdint>
 #include <cstdio>
@@ -27,6 +29,8 @@
 #include <ctime>
 #include <fstream>
 #include <iostream>
+#include <map>
+#include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -39,28 +43,100 @@
 #include "common/schema.h"
 #include "common/tablet.h"
 #include "file/write_file.h"
+#include "format/atomic_output.h"
 #include "format/input_format.h"
+#include "format/output_format.h"
 #include "writer/tsfile_table_writer.h"
 
+#ifdef _WIN32
+#define lstat stat
+#endif
+
 namespace tsfile_cli {
 namespace {
 
+struct CsvCell {
+    std::string value;
+    bool quoted;
+};
+
 struct DataRow {
     long long line_no;
     int64_t timestamp;
-    std::vector<std::string> cells;
+    std::vector<CsvCell> cells;
 };
 
+struct WritePhysicalConfig {
+    std::map<common::TSDataType, common::TSEncoding> encodings;
+    std::map<common::TSDataType, common::CompressionType> compressions;
+};
+
+bool has_strict_decimal_body(const std::string& s, size_t start) {
+    if (start >= s.size()) {
+        return false;
+    }
+    if (s[start] == '0' && start + 1 != s.size()) {
+        return false;
+    }
+    for (size_t i = start; i < s.size(); ++i) {
+        if (s[i] < '0' || s[i] > '9') {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool parse_strict_timestamp_cell(const std::string& s, int64_t& out) {
+    if (s.empty()) {
+        return false;
+    }
+    size_t start = (s[0] == '-') ? 1 : 0;
+    if (s[0] == '-' && start + 1 == s.size() && s[start] == '0') {
+        return false;
+    }
+    if (!has_strict_decimal_body(s, start)) {
+        return false;
+    }
+    char* e = nullptr;
+    errno = 0;
+    long long ts = std::strtoll(s.c_str(), &e, 10);
+    if (e == nullptr || *e != '\0' || errno == ERANGE) {
+        return false;
+    }
+    out = static_cast<int64_t>(ts);
+    return true;
+}
+
+bool stat_is_regular_file(const struct stat& st) {
+#ifdef _WIN32
+    return (st.st_mode & S_IFREG) != 0;
+#else
+    return S_ISREG(st.st_mode);
+#endif
+}
+
+bool stat_regular_file(const std::string& path, struct stat& st) {
+    return stat(path.c_str(), &st) == 0 && stat_is_regular_file(st);
+}
+
 // Parse a calendar date in strict YYYY-MM-DD form into a std::tm (year offset
 // from 1900, month 0-based) the way storage::Tablet expects for DATE columns.
 // Validates that it is a real date (DateConverter rejects e.g. 2024-13-40),
 // since the writer silently drops an invalid std::tm rather than erroring.
 bool parse_date_cell(const std::string& cell, std::tm& out) {
+    if (cell.size() != 10 || cell[4] != '-' || cell[7] != '-') {
+        return false;
+    }
+    const size_t digits[] = {0, 1, 2, 3, 5, 6, 8, 9};
+    for (size_t i : digits) {
+        if (cell[i] < '0' || cell[i] > '9') {
+            return false;
+        }
+    }
     int y = 0;
     int m = 0;
     int d = 0;
-    char extra = 0;
-    if (std::sscanf(cell.c_str(), "%4d-%2d-%2d%c", &y, &m, &d, &extra) != 3) {
+    if (std::sscanf(cell.c_str(), "%4d-%2d-%2d", &y, &m, &d) != 3) {
         return false;
     }
     out = std::tm();
@@ -71,12 +147,264 @@ bool parse_date_cell(const std::string& cell, std::tm& out) {
     return common::DateConverter::date_to_int(out, date_int) == common::E_OK;
 }
 
+std::string lower_ascii(const std::string& s) {
+    std::string out;
+    out.reserve(s.size());
+    for (unsigned char c : s) {
+        out += static_cast<char>(c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c);
+    }
+    return out;
+}
+
+bool parse_encoding_name(const std::string& name, common::TSEncoding& out) {
+    static const std::pair<const char*, common::TSEncoding> kEncodings[] = {
+        {"PLAIN", common::PLAIN},
+        {"DICTIONARY", common::DICTIONARY},
+        {"RLE", common::RLE},
+        {"DIFF", common::DIFF},
+        {"TS_2DIFF", common::TS_2DIFF},
+        {"BITMAP", common::BITMAP},
+        {"GORILLA_V1", common::GORILLA_V1},
+        {"REGULAR", common::REGULAR},
+        {"GORILLA", common::GORILLA},
+        {"ZIGZAG", common::ZIGZAG},
+        {"FREQ", common::FREQ},
+        {"CHIMP", common::CHIMP},
+        {"SPRINTZ", common::SPRINTZ},
+        {"RLBE", common::RLBE},
+        {"CAMEL", common::CAMEL},
+    };
+    for (const auto& e : kEncodings) {
+        if (name == e.first) {
+            out = e.second;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool parse_compression_name(const std::string& name,
+                            common::CompressionType& out) {
+    static const std::pair<const char*, common::CompressionType>
+        kCompressions[] = {{"UNCOMPRESSED", common::UNCOMPRESSED},
+                           {"SNAPPY", common::SNAPPY},
+                           {"GZIP", common::GZIP},
+                           {"LZO", common::LZO},
+                           {"SDT", common::SDT},
+                           {"PAA", common::PAA},
+                           {"PLA", common::PLA},
+                           {"LZ4", common::LZ4},
+                           {"ZSTD", common::ZSTD},
+                           {"LZMA2", common::LZMA2}};
+    for (const auto& c : kCompressions) {
+        if (name == c.first) {
+            out = c.second;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool encoding_supported(common::TSDataType type, common::TSEncoding encoding) {
+    switch (type) {
+        case common::BOOLEAN:
+            return encoding == common::PLAIN;
+        case common::INT32:
+        case common::DATE:
+        case common::INT64:
+        case common::TIMESTAMP:
+            return encoding == common::PLAIN || encoding == common::TS_2DIFF ||
+                   encoding == common::GORILLA || encoding == common::ZIGZAG ||
+                   encoding == common::RLE || encoding == common::SPRINTZ ||
+                   encoding == common::CHIMP || encoding == common::RLBE;
+        case common::FLOAT:
+            return encoding == common::PLAIN || encoding == common::TS_2DIFF ||
+                   encoding == common::GORILLA || encoding == common::SPRINTZ ||
+                   encoding == common::CHIMP || encoding == common::RLBE;
+        case common::DOUBLE:
+            return encoding == common::PLAIN || encoding == common::TS_2DIFF ||
+                   encoding == common::GORILLA || encoding == common::SPRINTZ ||
+                   encoding == common::CHIMP || encoding == common::RLBE ||
+                   encoding == common::CAMEL;
+        case common::STRING:
+        case common::TEXT:
+        case common::BLOB:
+            return encoding == common::PLAIN || encoding == common::DICTIONARY;
+        default:
+            return false;
+    }
+}
+
+bool compression_supported(common::CompressionType compression) {
+    return compression == common::UNCOMPRESSED ||
+           compression == common::SNAPPY || compression == common::GZIP ||
+           compression == common::LZO || compression == common::LZ4 ||
+           compression == common::ZSTD || compression == common::LZMA2;
+}
+
+bool build_physical_config(const ParsedArgs& args,
+                           const std::vector<ColumnDef>& columns,
+                           WritePhysicalConfig& config, std::ostream& err) {
+    std::set<common::TSDataType> used_types;
+    for (const ColumnDef& c : columns) {
+        used_types.insert(c.type);
+    }
+    for (const ParsedArgs::PhysicalOverride& o : args.physical_overrides) {
+        common::TSDataType type = common::INVALID_DATATYPE;
+        if (!parse_datatype_name(o.data_type, type) ||
+            o.data_type != tsdatatype_name(type)) {
+            err << "Error: physical override type '" << o.data_type
+                << "' must be a used canonical data type\n";
+            return false;
+        }
+        if (used_types.find(type) == used_types.end()) {
+            err << "Error: physical override type " << o.data_type
+                << " is not used by any declared TAG or FIELD\n";
+            return false;
+        }
+        if (o.kind == ParsedArgs::PhysicalOverride::Kind::kEncoding) {
+            if (config.encodings.find(type) != config.encodings.end()) {
+                err << "Error: encoding for data type " << o.data_type
+                    << " specified more than once\n";
+                return false;
+            }
+            common::TSEncoding encoding = common::INVALID_ENCODING;
+            if (!parse_encoding_name(o.value, encoding) ||
+                !encoding_supported(type, encoding)) {
+                err << "Error: encoding " << o.value
+                    << " is not supported for data type " << o.data_type
+                    << "\n";
+                return false;
+            }
+            config.encodings[type] = encoding;
+        } else {
+            if (config.compressions.find(type) != config.compressions.end()) {
+                err << "Error: compression for data type " << o.data_type
+                    << " specified more than once\n";
+                return false;
+            }
+            common::CompressionType compression = common::INVALID_COMPRESSION;
+            if (!parse_compression_name(o.value, compression) ||
+                !compression_supported(compression)) {
+                err << "Error: compression " << o.value
+                    << " is not supported\n";
+                return false;
+            }
+            config.compressions[type] = compression;
+        }
+    }
+    return true;
+}
+
+bool build_header_mapping(const std::string& header,
+                          const std::vector<ColumnDef>& columns,
+                          std::vector<size_t>& field_indexes,
+                          size_t& time_index, std::ostream& err) {
+    std::vector<std::string> fields = split_line(header, ',', true);
+    std::set<std::string> seen_lower;
+    std::map<std::string, size_t> header_indexes;
+    bool found_time = false;
+    for (size_t i = 0; i < fields.size(); ++i) {
+        std::string folded = lower_ascii(fields[i]);
+        if (seen_lower.find(folded) != seen_lower.end()) {
+            err << "Error: CSV header name '" << fields[i]
+                << "' conflicts case-insensitively\n";
+            return false;
+        }
+        seen_lower.insert(folded);
+        if (folded == "time") {
+            found_time = true;
+            time_index = i;
+        } else {
+            std::string name_error;
+            if (!validate_identifier(folded, name_error)) {
+                err << "Error: invalid CSV header name '" << fields[i]
+                    << "': " << name_error << "\n";
+                return false;
+            }
+            header_indexes[folded] = i;
+        }
+    }
+    if (!found_time) {
+        err << "Error: CSV header is missing required column 'time'\n";
+        return false;
+    }
+
+    std::set<std::string> declared;
+    field_indexes.clear();
+    field_indexes.reserve(columns.size());
+    for (const ColumnDef& c : columns) {
+        const std::string folded = lower_ascii(c.name);
+        declared.insert(folded);
+        auto it = header_indexes.find(folded);
+        if (it == header_indexes.end()) {
+            err << "Error: CSV header is missing required column '" << c.name
+                << "'\n";
+            return false;
+        }
+        field_indexes.push_back(it->second);
+    }
+    for (const auto& kv : header_indexes) {
+        if (declared.find(kv.first) == declared.end()) {
+            err << "Error: CSV contains undeclared column '" << kv.first
+                << "'\n";
+            return false;
+        }
+    }
+    return true;
+}
+
+std::vector<CsvCell> split_csv_cells(const std::string& line, char delim,
+                                     bool& closed_quotes) {
+    std::vector<CsvCell> out;
+    CsvCell field;
+    field.quoted = false;
+    bool in_quotes = false;
+    bool at_field_start = true;
+    for (size_t i = 0; i < line.size(); ++i) {
+        char c = line[i];
+        if (in_quotes) {
+            if (c == '"') {
+                if (i + 1 < line.size() && line[i + 1] == '"') {
+                    field.value += '"';
+                    ++i;
+                } else {
+                    in_quotes = false;
+                }
+            } else {
+                field.value += c;
+            }
+        } else if (c == '"') {
+            if (at_field_start) {
+                field.quoted = true;
+            }
+            in_quotes = true;
+            at_field_start = false;
+        } else if (c == delim) {
+            out.push_back(field);
+            field = CsvCell();
+            at_field_start = true;
+        } else {
+            field.value += c;
+            at_field_start = false;
+        }
+    }
+    out.push_back(field);
+    closed_quotes = !in_quotes;
+    return out;
+}
+
+bool is_csv_null(const CsvCell& cell) {
+    return !cell.quoted && cell.value == "\\N";
+}
+
 bool add_typed_value(storage::Tablet& tablet, uint32_t row,
                      uint32_t schema_index, const ColumnDef& def,
-                     const std::string& cell, std::string& error) {
-    if (cell.empty()) {
+                     const CsvCell& csv_cell, std::string& error) {
+    if (is_csv_null(csv_cell)) {
         return true;  // null
     }
+    const std::string& cell = csv_cell.value;
     char* e = nullptr;
     switch (def.type) {
         case common::BOOLEAN: {
@@ -191,10 +519,37 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
         err << "Error: " << perr << "\n";
         return kExitUsage;
     }
+    const std::string table_name = lower_ascii(args.table);
+    if (!validate_identifier(table_name, perr)) {
+        err << "Error: invalid table name '" << args.table << "': " << perr
+            << "\n";
+        return kExitUsage;
+    }
+    bool has_field = false;
+    for (const ColumnDef& column : columns) {
+        has_field =
+            has_field || column.category == common::ColumnCategory::FIELD;
+    }
+    if (!has_field) {
+        err << "Error: write requires at least one --field column\n";
+        return kExitUsage;
+    }
+    WritePhysicalConfig physical_config;
+    if (!build_physical_config(args, columns, physical_config, err)) {
+        return kExitUsage;
+    }
 
     std::istream* in = &std::cin;
     std::ifstream fin;
+    struct stat input_stat;
+    bool has_input_stat = false;
     if (!args.file.empty() && args.file != "-") {
+        if (!stat_regular_file(args.file, input_stat)) {
+            err << "Error: input must be a regular CSV file: " << args.file
+                << "\n";
+            return kExitFile;
+        }
+        has_input_stat = true;
         fin.open(args.file.c_str());
         if (!fin.is_open()) {
             err << "Error: cannot open input: " << args.file << "\n";
@@ -203,50 +558,35 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
         in = &fin;
     }
 
-    const char delim = (args.format == ParsedArgs::Format::kTsv) ? '\t' : ',';
-    const bool csv_quotes = (delim == ',');
-
-    if (args.verbose) {
-        // Echo the resolved write configuration so the user can self-check the
-        // parsed flags before any rows are imported.
-        err << "write: table=" << args.table << " output=" << args.output
-            << " input=" << (args.file.empty() ? "-" : args.file)
-            << " format=" << (delim == '\t' ? "tsv" : "csv")
-            << " header=" << (args.no_header ? "none" : "yes")
-            << (args.header_match ? " (match)" : "") << "\n";
-        for (const ColumnDef& d : columns) {
-            err << "  column " << d.name << ":" << tsdatatype_name(d.type) << ":"
-                << (d.category == common::ColumnCategory::TAG ? "tag" : "field")
-                << "\n";
-        }
-    }
+    const char delim = ',';
+    const bool csv_quotes = true;
 
     std::string line;
     long long line_no = 0;
     long long record_lines = 0;
-    if (!args.no_header) {
-        if (read_record(*in, csv_quotes, line, record_lines)) {
-            line_no += record_lines;
-            if (args.header_match) {
-                std::vector<std::string> h =
-                    split_line(line, delim, csv_quotes);
-                const size_t expected = columns.size() + 1;
-                if (h.size() != expected) {
-                    err << "Error: header has " << h.size()
-                        << " columns, expected " << expected
-                        << " (time + --columns) (line 1)\n";
-                    return kExitRuntime;
-                }
-                for (size_t i = 0; i < columns.size(); ++i) {
-                    if (h[i + 1] != columns[i].name) {
-                        err << "Error: header column " << (i + 2) << " is '"
-                            << h[i + 1] << "', expected '" << columns[i].name
-                            << "' (line 1)\n";
-                        return kExitRuntime;
-                    }
-                }
-            }
-        }
+    if (!read_record(*in, csv_quotes, line, record_lines)) {
+        err << "Error: CSV header is missing required column 'time'\n";
+        return kExitFile;
+    }
+    line_no += record_lines;
+    const std::string bom = "\xEF\xBB\xBF";
+    if (line.compare(0, bom.size(), bom) == 0) {
+        line.erase(0, bom.size());
+    }
+    if (!is_valid_utf8(line) || contains_utf8_bom(line)) {
+        err << "Error: CSV header contains invalid UTF-8 or a misplaced BOM\n";
+        return kExitFile;
+    }
+    bool closed_quotes = true;
+    split_csv_cells(line, delim, closed_quotes);
+    if (!closed_quotes) {
+        err << "Error: unterminated quoted CSV field in header\n";
+        return kExitFile;
+    }
+    std::vector<size_t> field_indexes;
+    size_t time_index = 0;
+    if (!build_header_mapping(line, columns, field_indexes, time_index, err)) {
+        return kExitFile;
     }
 
     std::vector<std::string> names;
@@ -259,21 +599,29 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
         names.push_back(d.name);
         types.push_back(d.type);
         cats.push_back(d.category);
-        col_schemas.push_back(common::ColumnSchema(
-            d.name, d.type, common::get_default_compressor(),
-            common::get_value_encoder(d.type), d.category));
+        common::CompressionType compression = common::get_default_compressor();
+        auto comp_it = physical_config.compressions.find(d.type);
+        if (comp_it != physical_config.compressions.end()) {
+            compression = comp_it->second;
+        }
+        common::TSEncoding encoding = common::get_value_encoder(d.type);
+        auto enc_it = physical_config.encodings.find(d.type);
+        if (enc_it != physical_config.encodings.end()) {
+            encoding = enc_it->second;
+        }
+        col_schemas.push_back(common::ColumnSchema(d.name, d.type, compression,
+                                                   encoding, d.category));
         if (d.category == common::ColumnCategory::TAG) {
             tag_idx.push_back(j);
         }
     }
 
-    // Creating the output truncates it; refuse to clobber the input we are
-    // still reading from, which would otherwise silently destroy the source
-    // data.
-    if (!args.file.empty() && args.file != "-" && args.output == args.file) {
-        err << "Error: --output is the same as the input file: " << args.output
-            << "\n";
-        return kExitUsage;
+    std::string temp_output;
+    int prepare_ret = prepare_atomic_output(
+        args.output, has_input_stat ? args.file : std::string(), false,
+        temp_output, err);
+    if (prepare_ret != kExitOk) {
+        return prepare_ret;
     }
 
     storage::WriteFile file;
@@ -281,13 +629,14 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
 #ifdef _WIN32
     flags |= O_BINARY;
 #endif
-    int cret = file.create(args.output, flags, 0666);
+    int cret = file.create(temp_output, flags, 0600);
     if (cret != 0) {
         err << "Error: cannot create output " << args.output << ": "
             << error_code_message(cret) << " (code " << cret << ")\n";
-        return kExitFile;
+        remove_atomic_temp(temp_output, err);
+        return kExitRuntime;
     }
-    auto* schema = new storage::TableSchema(args.table, col_schemas);
+    auto* schema = new storage::TableSchema(table_name, col_schemas);
     auto* writer = new storage::TsFileTableWriter(&file, schema);
 
     // Stream rows into fixed-size batches so memory stays bounded regardless of
@@ -303,11 +652,11 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
     // located message instead of an opaque write failure.
     std::unordered_map<std::string, int64_t> last_ts_by_device;
 
-    auto flush_batch = [&]() -> bool {
+    auto flush_batch = [&]() -> int {
         if (batch.empty()) {
-            return true;
+            return kExitOk;
         }
-        storage::Tablet tablet(args.table, names, types, cats,
+        storage::Tablet tablet(table_name, names, types, cats,
                                static_cast<int>(batch.size()));
         for (size_t i = 0; i < batch.size(); ++i) {
             uint32_t r = static_cast<uint32_t>(i);
@@ -318,7 +667,7 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
                                      columns[j], batch[i].cells[j], cell_err)) {
                     err << "Error: " << cell_err << " (line "
                         << batch[i].line_no << ")\n";
-                    return false;
+                    return kExitFile;
                 }
             }
         }
@@ -326,11 +675,11 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
         if (wt != 0) {
             err << "Error: failed to write rows: " << error_code_message(wt)
                 << " (code " << wt << ")\n";
-            return false;
+            return kExitRuntime;
         }
         total_rows += static_cast<long long>(batch.size());
         batch.clear();
-        return true;
+        return kExitOk;
     };
 
     while (read_record(*in, csv_quotes, line, record_lines)) {
@@ -338,30 +687,50 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
         if (line.empty()) {
             continue;
         }
-        std::vector<std::string> fields = split_line(line, delim, csv_quotes);
-        if (fields.size() != columns.size() + 1) {
-            err << "Error: expected " << (columns.size() + 1) << " fields, got "
-                << fields.size() << " (line " << line_no << ")\n";
-            result_code = kExitRuntime;
+        if (!is_valid_utf8(line) || contains_utf8_bom(line)) {
+            err << "Error: invalid UTF-8 or misplaced BOM (line " << line_no
+                << ")\n";
+            result_code = kExitFile;
             break;
         }
-        char* e = nullptr;
-        errno = 0;
-        long long ts = std::strtoll(fields[0].c_str(), &e, 10);
-        if (e == nullptr || *e != '\0' || errno == ERANGE) {
-            err << "Error: bad timestamp '" << fields[0] << "' (line "
-                << line_no << ")\n";
-            result_code = kExitRuntime;
+        std::vector<CsvCell> fields =
+            split_csv_cells(line, delim, closed_quotes);
+        if (!closed_quotes) {
+            err << "Error: unterminated quoted CSV field (line " << line_no
+                << ")\n";
+            result_code = kExitFile;
+            break;
+        }
+        if (fields.size() != field_indexes.size() + 1) {
+            err << "Error: expected " << (field_indexes.size() + 1)
+                << " fields, got " << fields.size() << " (line " << line_no
+                << ")\n";
+            result_code = kExitFile;
+            break;
+        }
+        int64_t ts = 0;
+        if (!parse_strict_timestamp_cell(fields[time_index].value, ts)) {
+            err << "Error: bad timestamp '" << fields[time_index].value
+                << "' (line " << line_no << ")\n";
+            result_code = kExitFile;
             break;
         }
         DataRow r;
         r.line_no = line_no;
-        r.timestamp = static_cast<int64_t>(ts);
-        r.cells.assign(fields.begin() + 1, fields.end());
+        r.timestamp = ts;
+        r.cells.resize(columns.size());
+        for (size_t j = 0; j < columns.size(); ++j) {
+            r.cells[j] = fields[field_indexes[j]];
+        }
 
         std::string device_key;
         for (size_t k : tag_idx) {
-            device_key += r.cells[k];
+            if (is_csv_null(r.cells[k])) {
+                device_key += '\1';
+            } else {
+                device_key += '\2';
+                device_key += r.cells[k].value;
+            }
             device_key.push_back('\0');
         }
         auto seen = last_ts_by_device.find(device_key);
@@ -370,20 +739,22 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
                    "(line "
                 << line_no << ": " << r.timestamp << " <= previous "
                 << seen->second << ")\n";
-            result_code = kExitRuntime;
+            result_code = kExitFile;
             break;
         }
         last_ts_by_device[device_key] = r.timestamp;
 
         batch.push_back(std::move(r));
-        if (batch.size() >= kBatch && !flush_batch()) {
-            result_code = kExitRuntime;
+        if (batch.size() >= kBatch) {
+            result_code = flush_batch();
+        }
+        if (result_code != kExitOk) {
             break;
         }
     }
 
-    if (result_code == kExitOk && !flush_batch()) {
-        result_code = kExitRuntime;
+    if (result_code == kExitOk) {
+        result_code = flush_batch();
     }
 
     if (result_code == kExitOk) {
@@ -406,12 +777,48 @@ int cmd_write(const ParsedArgs& args, std::ostream& /*out*/,
     delete writer;
     delete schema;
 
+    int file_close_ret = file.close();
+    if (result_code == kExitOk && file_close_ret != common::E_OK) {
+        err << "Error: failed to close output: "
+            << error_code_message(file_close_ret) << " (code " << file_close_ret
+            << ")\n";
+        result_code = kExitRuntime;
+    }
+    if (result_code == kExitOk) {
+        result_code =
+            commit_atomic_output(temp_output, args.output, false, err);
+    }
     if (result_code != kExitOk) {
-        // The import failed; do not leave a partial/corrupt .tsfile behind.
-        file.close();
-        std::remove(args.output.c_str());
+        if (!remove_atomic_temp(temp_output, err)) {
+            result_code = kExitRuntime;
+        }
     } else if (args.verbose) {
-        err << "wrote " << total_rows << " rows to " << args.output << "\n";
+        err << "created model=table object=" << table_name
+            << " rows=" << total_rows << " output=" << args.output << "\n";
+        for (const ColumnDef& d : columns) {
+            auto enc_it = physical_config.encodings.find(d.type);
+            common::TSEncoding encoding =
+                enc_it == physical_config.encodings.end()
+                    ? common::get_value_encoder(d.type)
+                    : enc_it->second;
+            auto comp_it = physical_config.compressions.find(d.type);
+            common::CompressionType compression =
+                comp_it == physical_config.compressions.end()
+                    ? common::get_default_compressor()
+                    : comp_it->second;
+            err << "column=" << d.name << " category="
+                << (d.category == common::ColumnCategory::TAG ? "TAG" : "FIELD")
+                << " data_type=" << tsdatatype_name(d.type)
+                << " encoding=" << tsencoding_name(encoding) << " source="
+                << (enc_it == physical_config.encodings.end() ? "default"
+                                                              : "type-override")
+                << " compression=" << compression_name(compression)
+                << " source="
+                << (comp_it == physical_config.compressions.end()
+                        ? "default"
+                        : "type-override")
+                << "\n";
+        }
     }
     return result_code;
 }
diff --git a/cpp/tools/commands/commands.h b/cpp/tools/commands/commands.h
index ea7038ff5..9ecf566fe 100644
--- a/cpp/tools/commands/commands.h
+++ b/cpp/tools/commands/commands.h
@@ -51,7 +51,8 @@ std::unique_ptr<storage::Filter> build_table_tag_filter(
 
 int run_row_query(const ParsedArgs& args, storage::TsFileReader& reader,
                   OutputFormat fmt, std::ostream& out, std::ostream& err,
-                  long long offset, long long limit);
+                  long long offset, long long limit,
+                  long long* emitted_rows = nullptr);
 
 int cmd_ls(const ParsedArgs& args, storage::TsFileReader& reader,
            OutputFormat fmt, std::ostream& out, std::ostream& err);
@@ -67,8 +68,10 @@ int cmd_head(const ParsedArgs& args, storage::TsFileReader& reader,
              OutputFormat fmt, std::ostream& out, std::ostream& err);
 int cmd_cat(const ParsedArgs& args, storage::TsFileReader& reader,
             OutputFormat fmt, std::ostream& out, std::ostream& err);
-int cmd_sample(const ParsedArgs& args, storage::TsFileReader& reader,
+int cmd_export(const ParsedArgs& args, storage::TsFileReader& reader,
                OutputFormat fmt, std::ostream& out, std::ostream& err);
+int cmd_sketch(const ParsedArgs& args, storage::TsFileReader& reader,
+               std::ostream& out, std::ostream& err);
 int cmd_write(const ParsedArgs& args, std::ostream& out, std::ostream& err);
 
 }  // namespace tsfile_cli
diff --git a/cpp/tools/commands/row_query.cc b/cpp/tools/commands/row_query.cc
index 5acb63a4b..b2a1fb5c3 100644
--- a/cpp/tools/commands/row_query.cc
+++ b/cpp/tools/commands/row_query.cc
@@ -21,6 +21,8 @@
 #include <climits>
 #include <limits>
 #include <memory>
+#include <regex>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -37,7 +39,7 @@ namespace {
 
 bool can_push_down_row_window(const ParsedArgs& args, long long offset,
                               long long limit) {
-    return !args.has_start && !args.has_end && offset <= INT_MAX &&
+    return !args.has_start && !args.has_end && offset == 0 &&
            (limit < 0 || limit <= INT_MAX);
 }
 
@@ -45,6 +47,93 @@ int to_reader_row_bound(long long value) {
     return value < 0 ? -1 : static_cast<int>(value);
 }
 
+int resolve_table_fields(const ParsedArgs& args,
+                         const std::shared_ptr<storage::TableSchema>& schema,
+                         std::vector<std::string>& fields, std::ostream& err) {
+    if (!schema) {
+        err << "Error: table '" << args.table << "' does not exist\n";
+        return kExitUsage;
+    }
+    auto measurements = schema->get_measurement_schemas();
+    auto categories = schema->get_column_categories();
+    for (size_t i = 0; i < measurements.size(); ++i) {
+        if (measurements[i] && i < categories.size() &&
+            categories[i] == common::ColumnCategory::TAG) {
+            fields.push_back(measurements[i]->measurement_name_);
+        }
+    }
+    if (args.measurements.empty()) {
+        for (size_t i = 0; i < measurements.size(); ++i) {
+            if (measurements[i] && i < categories.size() &&
+                categories[i] == common::ColumnCategory::FIELD) {
+                fields.push_back(measurements[i]->measurement_name_);
+            }
+        }
+        return kExitOk;
+    }
+    for (const std::string& requested : args.measurements) {
+        const int index = schema->find_column_index(requested);
+        if (index < 0 || static_cast<size_t>(index) >= measurements.size() ||
+            !measurements[index]) {
+            err << "Error: FIELD '" << requested
+                << "' does not exist in table '" << schema->get_table_name()
+                << "'\n";
+            return kExitUsage;
+        }
+        const common::ColumnCategory category =
+            static_cast<size_t>(index) < categories.size()
+                ? categories[index]
+                : common::ColumnCategory::FIELD;
+        if (category != common::ColumnCategory::FIELD) {
+            err << "Error: column '" << requested
+                << "' is not a FIELD in table '" << schema->get_table_name()
+                << "'\n";
+            return kExitUsage;
+        }
+        fields.push_back(measurements[index]->measurement_name_);
+    }
+    return kExitOk;
+}
+
+int resolve_tree_paths(const ParsedArgs& args, storage::TsFileReader& reader,
+                       std::vector<std::string>& paths, std::ostream& err) {
+    auto devices = reader.get_all_device_ids();
+    std::shared_ptr<storage::IDeviceID> target_device;
+    for (const auto& device : devices) {
+        if (device && device->get_device_name() == args.device) {
+            target_device = device;
+            break;
+        }
+    }
+    if (!target_device) {
+        err << "Error: device '" << args.device << "' does not exist\n";
+        return kExitUsage;
+    }
+    std::vector<storage::MeasurementSchema> schemas;
+    if (reader.get_timeseries_schema(target_device, schemas) != common::E_OK) {
+        err << "Error: failed to read schema for device '" << args.device
+            << "'\n";
+        return kExitFile;
+    }
+    std::set<std::string> known;
+    for (const auto& schema : schemas) {
+        known.insert(schema.measurement_name_);
+    }
+    for (const std::string& requested : args.measurements) {
+        if (known.find(requested) == known.end()) {
+            err << "Error: FIELD '" << requested
+                << "' does not exist in device '" << args.device << "'\n";
+            return kExitUsage;
+        }
+    }
+    paths = collect_tree_query_paths(args, reader);
+    if (paths.empty()) {
+        err << "Error: device '" << args.device << "' has no FIELD columns\n";
+        return kExitUsage;
+    }
+    return kExitOk;
+}
+
 }  // namespace
 
 std::unique_ptr<storage::Filter> build_table_tag_filter(
@@ -60,55 +149,52 @@ std::unique_ptr<storage::Filter> build_table_tag_filter(
     }
 
     storage::TagFilterBuilder builder(schema.get());
-    storage::Filter* filter = nullptr;
-    switch (args.tag_filter_op) {
-        case ParsedArgs::TagFilterOp::kEq:
-            filter = builder.eq(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kNeq:
-            filter = builder.neq(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kLt:
-            filter = builder.lt(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kLteq:
-            filter =
-                builder.lteq(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kGt:
-            filter = builder.gt(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kGteq:
-            filter =
-                builder.gteq(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kRegexp:
-            filter =
-                builder.reg_exp(args.tag_filter_column, args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kNotRegexp:
-            filter = builder.not_reg_exp(args.tag_filter_column,
-                                         args.tag_filter_value);
-            break;
-        case ParsedArgs::TagFilterOp::kBetween:
-            filter = builder.between_and(args.tag_filter_column,
-                                         args.tag_filter_value,
-                                         args.tag_filter_value2);
-            break;
-        case ParsedArgs::TagFilterOp::kNotBetween:
-            filter = builder.not_between_and(args.tag_filter_column,
-                                             args.tag_filter_value,
-                                             args.tag_filter_value2);
-            break;
-        case ParsedArgs::TagFilterOp::kNone:
-            break;
-    }
-    if (filter == nullptr) {
-        err << "Error: invalid tag filter column '" << args.tag_filter_column
-            << "' for table " << table_name << "\n";
-        return std::unique_ptr<storage::Filter>();
+    std::unique_ptr<storage::Filter> combined;
+    for (const ParsedArgs::TagFilterSpec& spec : args.tag_filters) {
+        storage::Filter* filter = nullptr;
+        switch (spec.op) {
+            case ParsedArgs::TagFilterOp::kEq:
+                filter = builder.eq(spec.column, spec.value);
+                break;
+            case ParsedArgs::TagFilterOp::kNeq:
+                filter = builder.neq(spec.column, spec.value);
+                break;
+            case ParsedArgs::TagFilterOp::kRegexp:
+                try {
+                    std::regex pattern(spec.value);
+                    (void)pattern;
+                } catch (const std::regex_error&) {
+                    err << "Error: invalid regular expression for TAG '"
+                        << spec.column << "'\n";
+                    return std::unique_ptr<storage::Filter>();
+                }
+                filter = builder.reg_exp(spec.column, spec.value);
+                break;
+            case ParsedArgs::TagFilterOp::kIsNull:
+                filter = builder.is_null(spec.column);
+                break;
+            case ParsedArgs::TagFilterOp::kNotNull:
+                filter = builder.is_not_null(spec.column);
+                break;
+            case ParsedArgs::TagFilterOp::kNone:
+                break;
+        }
+        if (filter == nullptr) {
+            err << "Error: invalid tag filter column '" << spec.column
+                << "' for table " << table_name << "\n";
+            return std::unique_ptr<storage::Filter>();
+        }
+        if (!combined) {
+            combined.reset(filter);
+        } else if (args.tag_match == "any") {
+            combined.reset(storage::TagFilterBuilder::or_filter(
+                combined.release(), filter));
+        } else {
+            combined.reset(storage::TagFilterBuilder::and_filter(
+                combined.release(), filter));
+        }
     }
-    return std::unique_ptr<storage::Filter>(filter);
+    return combined;
 }
 
 std::vector<std::string> collect_tree_query_paths(
@@ -162,7 +248,7 @@ std::vector<std::string> collect_tree_query_paths(
 
 int run_row_query(const ParsedArgs& args, storage::TsFileReader& reader,
                   OutputFormat fmt, std::ostream& out, std::ostream& err,
-                  long long offset, long long limit) {
+                  long long offset, long long limit, long long* emitted_rows) {
     const int64_t start = args.has_start ? static_cast<int64_t>(args.start)
                                          : std::numeric_limits<int64_t>::min();
     const int64_t end = args.has_end ? static_cast<int64_t>(args.end)
@@ -181,24 +267,27 @@ int run_row_query(const ParsedArgs& args, storage::TsFileReader& reader,
                 err << "Error: no table found in file\n";
                 return kExitRuntime;
             }
+            if (schemas.size() != 1) {
+                err << "Error: head/cat requires -t/--table when the file "
+                       "contains multiple tables\n";
+                return kExitUsage;
+            }
             table_name = schemas[0]->get_table_name();
         }
-        std::vector<std::string> cols = args.measurements;
-        if (cols.empty()) {
-            auto ts = reader.get_table_schema(table_name);
-            if (ts) {
-                cols = ts->get_measurement_names();
-            }
+        auto table_schema = reader.get_table_schema(table_name);
+        std::vector<std::string> cols;
+        int selection_ret = resolve_table_fields(args, table_schema, cols, err);
+        if (selection_ret != kExitOk) {
+            return selection_ret;
         }
         tag_filter = build_table_tag_filter(args, reader, table_name, err);
         if (args.has_tag_filter && tag_filter == nullptr) {
             return kExitUsage;
         }
         if (push_down) {
-            qret = reader.queryByRow(table_name, cols,
-                                     to_reader_row_bound(offset),
-                                     to_reader_row_bound(limit), rs,
-                                     tag_filter.get());
+            qret = reader.queryByRow(
+                table_name, cols, to_reader_row_bound(offset),
+                to_reader_row_bound(limit), rs, tag_filter.get());
         } else {
             qret = reader.query(table_name, cols, start, end, rs,
                                 tag_filter.get());
@@ -208,10 +297,25 @@ int run_row_query(const ParsedArgs& args, storage::TsFileReader& reader,
             err << "Error: tag filter flags are only valid for table model\n";
             return kExitUsage;
         }
-        std::vector<std::string> paths = collect_tree_query_paths(args, reader);
-        if (paths.empty()) {
-            err << "Error: no time series found\n";
-            return kExitRuntime;
+        ParsedArgs effective_args = args;
+        if (effective_args.device.empty()) {
+            auto devices = reader.get_all_device_ids();
+            if (devices.empty() || !devices[0]) {
+                err << "Error: no device found in file\n";
+                return kExitRuntime;
+            }
+            if (devices.size() != 1) {
+                err << "Error: head/cat requires -d/--device when the file "
+                       "contains multiple devices\n";
+                return kExitUsage;
+            }
+            effective_args.device = devices[0]->get_device_name();
+        }
+        std::vector<std::string> paths;
+        int selection_ret =
+            resolve_tree_paths(effective_args, reader, paths, err);
+        if (selection_ret != kExitOk) {
+            return selection_ret;
         }
         if (push_down) {
             qret = reader.queryByRow(paths, to_reader_row_bound(offset),
@@ -226,18 +330,22 @@ int run_row_query(const ParsedArgs& args, storage::TsFileReader& reader,
         if (rs != nullptr) {
             reader.destroy_query_data_set(rs);
         }
-        return kExitRuntime;
+        return kExitFile;
     }
 
-    int wret = push_down
-                   ? emit_result_set(rs, fmt, args.no_header, out)
-                   : emit_result_set(rs, fmt, args.no_header, out, offset,
-                                     limit);
+    int wret = push_down ? emit_result_set(rs, fmt, args.no_header, out, 0, -1,
+                                           emitted_rows)
+                         : emit_result_set(rs, fmt, args.no_header, out, offset,
+                                           limit, emitted_rows);
     reader.destroy_query_data_set(rs);
+    if (wret == common::E_OUT_OF_RANGE) {
+        err << "Error: offset exceeds matched row count\n";
+        return kExitUsage;
+    }
     if (wret != 0) {
         err << "Error: failed to read rows: " << error_code_message(wret)
             << "\n";
-        return kExitRuntime;
+        return wret == common::E_FILE_WRITE_ERR ? kExitRuntime : kExitFile;
     }
     return kExitOk;
 }
diff --git a/cpp/tools/commands/statistics.cc b/cpp/tools/commands/statistics.cc
index acb7e01b9..16247128d 100644
--- a/cpp/tools/commands/statistics.cc
+++ b/cpp/tools/commands/statistics.cc
@@ -21,11 +21,19 @@
 
 #include <algorithm>
 #include <fstream>
+#include <iomanip>
 #include <limits>
+#include <map>
+#include <set>
 #include <sstream>
 
+#include "cli/exit_codes.h"
 #include "commands/commands.h"
+#include "common/datatype/date_converter.h"
+#include "common/device_id.h"
 #include "common/statistic.h"
+#include "format/output_format.h"
+#include "reader/result_set.h"
 #include "reader/tsfile_reader.h"
 #include "utils/storage_utils.h"
 
@@ -39,12 +47,35 @@ std::string value_to_string(const T& value) {
     return ss.str();
 }
 
+std::string value_to_string(float value) {
+    std::ostringstream ss;
+    ss << std::setprecision(std::numeric_limits<float>::max_digits10) << value;
+    return ss.str();
+}
+
+std::string value_to_string(double value) {
+    std::ostringstream ss;
+    ss << std::setprecision(std::numeric_limits<double>::max_digits10) << value;
+    return ss.str();
+}
+
 std::string bool_to_string(bool value) { return value ? "true" : "false"; }
 
 std::string string_to_std(const common::String& value) {
     return value.to_std_string();
 }
 
+std::string date_to_string(int32_t value) {
+    std::tm date = std::tm();
+    if (common::DateConverter::int_to_date(value, date) != common::E_OK) {
+        return "";
+    }
+    char result[16];
+    std::snprintf(result, sizeof(result), "%04d-%02d-%02d", date.tm_year + 1900,
+                  date.tm_mon + 1, date.tm_mday);
+    return result;
+}
+
 long long file_size(const std::string& path) {
     std::ifstream in(path.c_str(), std::ios::binary | std::ios::ate);
     if (!in.good()) {
@@ -72,8 +103,7 @@ StatisticCells statistic_value_cells(storage::Statistic* st) {
             cells.is_null = {true, true, false, false, false};
             break;
         }
-        case common::INT32:
-        case common::DATE: {
+        case common::INT32: {
             auto* s = static_cast<storage::Int32Statistic*>(st);
             cells.values = {value_to_string(s->min_value_),
                             value_to_string(s->max_value_),
@@ -83,15 +113,23 @@ StatisticCells statistic_value_cells(storage::Statistic* st) {
             cells.is_null = {false, false, false, false, false};
             break;
         }
+        case common::DATE: {
+            auto* s = static_cast<storage::Int32Statistic*>(st);
+            cells.values = {
+                date_to_string(s->min_value_), date_to_string(s->max_value_),
+                date_to_string(s->first_value_), date_to_string(s->last_value_),
+                ""};
+            cells.is_null = {false, false, false, false, true};
+            break;
+        }
         case common::INT64:
         case common::TIMESTAMP: {
             auto* s = static_cast<storage::Int64Statistic*>(st);
             cells.values = {value_to_string(s->min_value_),
                             value_to_string(s->max_value_),
                             value_to_string(s->first_value_),
-                            value_to_string(s->last_value_),
-                            value_to_string(s->sum_value_)};
-            cells.is_null = {false, false, false, false, false};
+                            value_to_string(s->last_value_), ""};
+            cells.is_null = {false, false, false, false, true};
             break;
         }
         case common::FLOAT: {
@@ -136,49 +174,142 @@ StatisticCells statistic_value_cells(storage::Statistic* st) {
     return cells;
 }
 
-std::vector<SeriesStatRow> collect_series_stats(const ParsedArgs& args,
-                                                storage::TsFileReader& reader) {
-    std::vector<SeriesStatRow> rows;
-    const std::string target_table_name = storage::to_lower(args.table);
-    storage::DeviceTimeseriesMetadataMap meta =
-        reader.get_timeseries_metadata();
-    for (auto& kv : meta) {
-        std::string target = kv.first ? kv.first->get_device_name() : "";
-        if (!args.device.empty() && target != args.device) {
-            continue;
+int collect_series_stats(const ParsedArgs& args, storage::TsFileReader& reader,
+                         std::vector<SeriesStatRow>& rows, std::ostream& err) {
+    rows.clear();
+    const auto all_devices = reader.get_all_device_ids();
+    std::vector<std::shared_ptr<storage::IDeviceID>> devices;
+    for (const auto& device : all_devices) {
+        if (device &&
+            (args.device.empty() || device->get_device_name() == args.device)) {
+            devices.push_back(device);
         }
-        if (!target_table_name.empty() && kv.first &&
-            kv.first->get_table_name() != target_table_name) {
+    }
+    if (!args.device.empty() && devices.empty()) {
+        err << "Error: device '" << args.device << "' does not exist\n";
+        return kExitUsage;
+    }
+
+    storage::DeviceTimeseriesMetadataMap metadata =
+        reader.get_timeseries_metadata(devices);
+    std::map<std::string,
+             std::map<std::string, std::shared_ptr<storage::ITimeseriesIndex>>>
+        metadata_by_name;
+    for (auto& entry : metadata) {
+        if (!entry.first) {
             continue;
         }
-        for (auto& ts : kv.second) {
-            if (!ts) {
-                continue;
+        const std::string device_name = entry.first->get_device_name();
+        for (const auto& series : entry.second) {
+            if (series) {
+                metadata_by_name[device_name][series->get_measurement_name()
+                                                  .to_std_string()] = series;
+            }
+        }
+    }
+
+    std::set<std::string> matched_measurements;
+    for (const auto& device : devices) {
+        const std::string device_name = device->get_device_name();
+        std::vector<storage::MeasurementSchema> schemas;
+        int schema_ret = reader.get_timeseries_schema(device, schemas);
+        if (schema_ret != common::E_OK) {
+            err << "Error: failed to read schema for device '" << device_name
+                << "': " << error_code_message(schema_ret) << "\n";
+            return kExitFile;
+        }
+        std::set<std::string> known;
+        std::vector<std::string> paths;
+        for (const auto& schema : schemas) {
+            known.insert(schema.measurement_name_);
+            paths.push_back(device_name + "." + schema.measurement_name_);
+        }
+        if (!args.device.empty()) {
+            for (const std::string& requested : args.measurements) {
+                if (known.find(requested) != known.end()) {
+                    continue;
+                }
+                err << "Error: FIELD '" << requested
+                    << "' does not exist in device '" << device_name << "'\n";
+                return kExitUsage;
+            }
+        }
+
+        long long row_count = 0;
+        if (!paths.empty()) {
+            storage::ResultSet* result = nullptr;
+            int query_ret =
+                reader.query(paths, std::numeric_limits<int64_t>::min(),
+                             std::numeric_limits<int64_t>::max(), result);
+            if (query_ret != common::E_OK || result == nullptr) {
+                if (result != nullptr) {
+                    reader.destroy_query_data_set(result);
+                }
+                err << "Error: failed to count rows for device '" << device_name
+                    << "': " << error_code_message(query_ret) << "\n";
+                return kExitFile;
+            }
+            bool has_next = false;
+            int next_ret = common::E_OK;
+            while ((next_ret = result->next(has_next)) == common::E_OK &&
+                   has_next) {
+                ++row_count;
+            }
+            reader.destroy_query_data_set(result);
+            if (next_ret != common::E_OK) {
+                err << "Error: failed to count rows for device '" << device_name
+                    << "': " << error_code_message(next_ret) << "\n";
+                return kExitFile;
             }
-            std::string measurement =
-                ts->get_measurement_name().to_std_string();
+        }
+
+        for (const auto& schema : schemas) {
             if (!args.measurements.empty() &&
                 std::find(args.measurements.begin(), args.measurements.end(),
-                          measurement) == args.measurements.end()) {
+                          schema.measurement_name_) ==
+                    args.measurements.end()) {
                 continue;
             }
-            storage::Statistic* st = ts->get_statistic();
+            matched_measurements.insert(schema.measurement_name_);
             SeriesStatRow row;
-            row.target = target;
-            row.measurement = measurement;
-            if (st != nullptr) {
-                row.count = st->get_count();
-                row.start_time = st->start_time_;
-                row.end_time = st->end_time_;
-                row.value_cells = statistic_value_cells(st);
-            } else {
+            row.target = device_name;
+            row.measurement = schema.measurement_name_;
+            row.data_type = schema.data_type_;
+            row.row_count = row_count;
+            auto device_meta = metadata_by_name.find(device_name);
+            if (device_meta != metadata_by_name.end()) {
+                auto series =
+                    device_meta->second.find(schema.measurement_name_);
+                if (series != device_meta->second.end() && series->second) {
+                    storage::Statistic* statistic =
+                        series->second->get_statistic();
+                    if (statistic != nullptr) {
+                        row.has_statistic = true;
+                        row.count = statistic->get_count();
+                        row.start_time = statistic->start_time_;
+                        row.end_time = statistic->end_time_;
+                        row.value_cells = statistic_value_cells(statistic);
+                    }
+                }
+            }
+            if (row.value_cells.values.empty()) {
                 row.value_cells.values.assign(5, "");
                 row.value_cells.is_null.assign(5, true);
             }
             rows.push_back(row);
         }
     }
-    return rows;
+    if (args.device.empty()) {
+        for (const std::string& requested : args.measurements) {
+            if (matched_measurements.find(requested) ==
+                matched_measurements.end()) {
+                err << "Error: FIELD '" << requested
+                    << "' does not exist in the file\n";
+                return kExitUsage;
+            }
+        }
+    }
+    return kExitOk;
 }
 
 FileSummary collect_file_summary(const ParsedArgs& args,
@@ -191,24 +322,24 @@ FileSummary collect_file_summary(const ParsedArgs& args,
         static_cast<long long>(reader.get_all_table_schemas().size());
     s.file_size_bytes = file_size(args.file);
 
-    // The file summary (series_count + overall time range) describes the whole
-    // file, so clear any -d/-t/-m filters from the args copy before collecting
-    // per-series stats; otherwise meta would only count the filtered subset.
-    ParsedArgs all = args;
-    all.device.clear();
-    all.table.clear();
-    all.measurements.clear();
-    std::vector<SeriesStatRow> rows = collect_series_stats(all, reader);
-    s.series_count = static_cast<long long>(rows.size());
+    storage::DeviceTimeseriesMetadataMap metadata =
+        reader.get_timeseries_metadata();
     long long min_start = std::numeric_limits<long long>::max();
     long long max_end = std::numeric_limits<long long>::min();
-    for (const SeriesStatRow& row : rows) {
-        if (row.count <= 0) {
-            continue;
+    for (const auto& device : metadata) {
+        for (const auto& series : device.second) {
+            if (!series) {
+                continue;
+            }
+            ++s.series_count;
+            storage::Statistic* statistic = series->get_statistic();
+            if (statistic == nullptr || statistic->get_count() <= 0) {
+                continue;
+            }
+            min_start = std::min(min_start, statistic->start_time_);
+            max_end = std::max(max_end, statistic->get_end_time());
+            s.has_time_range = true;
         }
-        min_start = std::min(min_start, row.start_time);
-        max_end = std::max(max_end, row.end_time);
-        s.has_time_range = true;
     }
     if (s.has_time_range) {
         s.start_time = min_start;
diff --git a/cpp/tools/commands/statistics.h b/cpp/tools/commands/statistics.h
index 031b5b4aa..a29df39a5 100644
--- a/cpp/tools/commands/statistics.h
+++ b/cpp/tools/commands/statistics.h
@@ -20,10 +20,12 @@
 #ifndef TSFILE_CLI_STATISTICS_H
 #define TSFILE_CLI_STATISTICS_H
 
+#include <ostream>
 #include <string>
 #include <vector>
 
 #include "cli/cli_args.h"
+#include "common/db_common.h"
 
 namespace storage {
 class Statistic;
@@ -40,9 +42,12 @@ struct StatisticCells {
 struct SeriesStatRow {
     std::string target;
     std::string measurement;
+    common::TSDataType data_type = common::INVALID_DATATYPE;
+    long long row_count = 0;
     long long count = 0;
     long long start_time = 0;
     long long end_time = 0;
+    bool has_statistic = false;
     StatisticCells value_cells;
 };
 
@@ -59,8 +64,8 @@ struct FileSummary {
 };
 
 StatisticCells statistic_value_cells(storage::Statistic* st);
-std::vector<SeriesStatRow> collect_series_stats(const ParsedArgs& args,
-                                                storage::TsFileReader& reader);
+int collect_series_stats(const ParsedArgs& args, storage::TsFileReader& reader,
+                         std::vector<SeriesStatRow>& rows, std::ostream& err);
 FileSummary collect_file_summary(const ParsedArgs& args,
                                  storage::TsFileReader& reader);
 
diff --git a/cpp/tools/format/atomic_output.cc b/cpp/tools/format/atomic_output.cc
new file mode 100644
index 000000000..77204938b
--- /dev/null
+++ b/cpp/tools/format/atomic_output.cc
@@ -0,0 +1,212 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "format/atomic_output.h"
+
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <sstream>
+
+#include "cli/exit_codes.h"
+
+#ifdef _WIN32
+#include <io.h>
+#include <process.h>
+#include <windows.h>
+#define lstat stat
+#define close _close
+#define getpid _getpid
+#else
+#include <unistd.h>
+#endif
+
+namespace tsfile_cli {
+namespace {
+
+bool is_regular_file(const struct stat& st) {
+#ifdef _WIN32
+    return (st.st_mode & S_IFREG) != 0;
+#else
+    return S_ISREG(st.st_mode);
+#endif
+}
+
+bool is_same_file(const std::string& source_path,
+                  const std::string& target_path, const struct stat& target) {
+#ifdef _WIN32
+    (void)target;
+    const DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+    HANDLE source = CreateFileA(source_path.c_str(), 0, share, nullptr,
+                                OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (source == INVALID_HANDLE_VALUE) {
+        return false;
+    }
+    HANDLE output = CreateFileA(target_path.c_str(), 0, share, nullptr,
+                                OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (output == INVALID_HANDLE_VALUE) {
+        CloseHandle(source);
+        return false;
+    }
+    BY_HANDLE_FILE_INFORMATION source_info;
+    BY_HANDLE_FILE_INFORMATION output_info;
+    const bool same =
+        GetFileInformationByHandle(source, &source_info) != 0 &&
+        GetFileInformationByHandle(output, &output_info) != 0 &&
+        source_info.dwVolumeSerialNumber == output_info.dwVolumeSerialNumber &&
+        source_info.nFileIndexHigh == output_info.nFileIndexHigh &&
+        source_info.nFileIndexLow == output_info.nFileIndexLow;
+    CloseHandle(output);
+    CloseHandle(source);
+    return same;
+#else
+    (void)target_path;
+    struct stat source;
+    return stat(source_path.c_str(), &source) == 0 &&
+           source.st_dev == target.st_dev && source.st_ino == target.st_ino;
+#endif
+}
+
+int validate_target(const std::string& target_path,
+                    const std::string& source_path, bool force,
+                    std::ostream& err) {
+    struct stat target;
+    if (lstat(target_path.c_str(), &target) != 0) {
+        if (errno == ENOENT) {
+            return kExitOk;
+        }
+        err << "Error: cannot inspect output target '" << target_path
+            << "': " << std::strerror(errno) << "\n";
+        return kExitRuntime;
+    }
+#ifndef _WIN32
+    if (S_ISLNK(target.st_mode)) {
+        err << "Error: output target '" << target_path
+            << "' must not be a symbolic link\n";
+        return kExitRuntime;
+    }
+#else
+    DWORD attributes = GetFileAttributesA(target_path.c_str());
+    if (attributes != INVALID_FILE_ATTRIBUTES &&
+        (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
+        err << "Error: output target '" << target_path
+            << "' must not be a reparse point\n";
+        return kExitRuntime;
+    }
+#endif
+    if (!is_regular_file(target)) {
+        err << "Error: output target '" << target_path
+            << "' is not a regular file\n";
+        return kExitRuntime;
+    }
+    if (!source_path.empty() &&
+        is_same_file(source_path, target_path, target)) {
+        err << "Error: output target '" << target_path
+            << "' is the same as the input file '" << source_path << "'\n";
+        return kExitRuntime;
+    }
+    if (!force) {
+        err << "Error: output target '" << target_path
+            << "' already exists; use --force to replace a regular file\n";
+        return kExitRuntime;
+    }
+    return kExitOk;
+}
+
+}  // namespace
+
+int prepare_atomic_output(const std::string& target_path,
+                          const std::string& source_path, bool force,
+                          std::string& temp_path, std::ostream& err) {
+    int ret = validate_target(target_path, source_path, force, err);
+    if (ret != kExitOk) {
+        return ret;
+    }
+    for (unsigned int attempt = 0; attempt < 1000; ++attempt) {
+        std::ostringstream candidate;
+        candidate << target_path << ".tmp." << getpid() << "." << attempt;
+        temp_path = candidate.str();
+        int flags = O_WRONLY | O_CREAT | O_EXCL;
+#ifdef _WIN32
+        flags |= O_BINARY;
+#endif
+        int fd = ::open(temp_path.c_str(), flags, 0600);
+        if (fd >= 0) {
+            if (::close(fd) != 0) {
+                err << "Error: failed to close temporary output '" << temp_path
+                    << "': " << std::strerror(errno) << "\n";
+                std::remove(temp_path.c_str());
+                return kExitRuntime;
+            }
+            return kExitOk;
+        }
+        if (errno != EEXIST) {
+            err << "Error: cannot create output temporary file for '"
+                << target_path << "': " << std::strerror(errno) << "\n";
+            return kExitRuntime;
+        }
+    }
+    err << "Error: cannot allocate a unique temporary output for '"
+        << target_path << "'\n";
+    return kExitRuntime;
+}
+
+int commit_atomic_output(const std::string& temp_path,
+                         const std::string& target_path, bool force,
+                         std::ostream& err) {
+#ifdef _WIN32
+    DWORD flags = MOVEFILE_WRITE_THROUGH;
+    if (force) {
+        flags |= MOVEFILE_REPLACE_EXISTING;
+    }
+    if (MoveFileExA(temp_path.c_str(), target_path.c_str(), flags) != 0) {
+        return kExitOk;
+    }
+#else
+    if (force) {
+        if (std::rename(temp_path.c_str(), target_path.c_str()) == 0) {
+            return kExitOk;
+        }
+    } else if (::link(temp_path.c_str(), target_path.c_str()) == 0) {
+        if (std::remove(temp_path.c_str()) == 0) {
+            return kExitOk;
+        }
+        err << "Error: output was committed but temporary path remains: '"
+            << temp_path << "'\n";
+        return kExitRuntime;
+    }
+#endif
+    err << "Error: failed to commit output target '" << target_path << "'\n";
+    return kExitRuntime;
+}
+
+bool remove_atomic_temp(const std::string& temp_path, std::ostream& err) {
+    if (temp_path.empty() || std::remove(temp_path.c_str()) == 0 ||
+        errno == ENOENT) {
+        return true;
+    }
+    err << "Error: failed to remove temporary output '" << temp_path
+        << "': " << std::strerror(errno) << "\n";
+    return false;
+}
+
+}  // namespace tsfile_cli
diff --git a/cpp/tools/format/atomic_output.h b/cpp/tools/format/atomic_output.h
new file mode 100644
index 000000000..9cd010b10
--- /dev/null
+++ b/cpp/tools/format/atomic_output.h
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef TSFILE_CLI_ATOMIC_OUTPUT_H
+#define TSFILE_CLI_ATOMIC_OUTPUT_H
+
+#include <ostream>
+#include <string>
+
+namespace tsfile_cli {
+
+int prepare_atomic_output(const std::string& target_path,
+                          const std::string& source_path, bool force,
+                          std::string& temp_path, std::ostream& err);
+int commit_atomic_output(const std::string& temp_path,
+                         const std::string& target_path, bool force,
+                         std::ostream& err);
+bool remove_atomic_temp(const std::string& temp_path, std::ostream& err);
+
+}  // namespace tsfile_cli
+
+#endif  // TSFILE_CLI_ATOMIC_OUTPUT_H
diff --git a/cpp/tools/format/input_format.cc b/cpp/tools/format/input_format.cc
index eb2c99a92..7db5e359f 100644
--- a/cpp/tools/format/input_format.cc
+++ b/cpp/tools/format/input_format.cc
@@ -34,6 +34,15 @@ void strip_cr(std::string& s) {
     }
 }
 
+std::string lower_ascii(const std::string& s) {
+    std::string out;
+    out.reserve(s.size());
+    for (unsigned char c : s) {
+        out += static_cast<char>(c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c);
+    }
+    return out;
+}
+
 }  // namespace
 
 bool read_record(std::istream& in, bool csv_quotes, std::string& record,
@@ -104,7 +113,7 @@ bool parse_columns_spec(const std::string& spec, std::vector<ColumnDef>& out,
             return false;
         }
         ColumnDef def;
-        def.name = parts[0];
+        def.name = lower_ascii(parts[0]);
         if (def.name.empty()) {
             error = "empty column name in '" + item + "'";
             return false;
@@ -117,6 +126,14 @@ bool parse_columns_spec(const std::string& spec, std::vector<ColumnDef>& out,
             error = "bad category '" + parts[2] + "' (want tag|field)";
             return false;
         }
+        if (!validate_identifier(def.name, error)) {
+            return false;
+        }
+        if (def.category == common::ColumnCategory::TAG &&
+            def.type != common::STRING) {
+            error = "TAG column '" + def.name + "' must use STRING";
+            return false;
+        }
         for (const ColumnDef& prev : out) {
             if (prev.name == def.name) {
                 error = "duplicate column name '" + def.name + "'";
@@ -128,6 +145,79 @@ bool parse_columns_spec(const std::string& spec, std::vector<ColumnDef>& out,
     return true;
 }
 
+bool is_valid_utf8(const std::string& s) {
+    const unsigned char* bytes =
+        reinterpret_cast<const unsigned char*>(s.data());
+    size_t i = 0;
+    while (i < s.size()) {
+        unsigned char b = bytes[i];
+        if (b <= 0x7F) {
+            ++i;
+            continue;
+        }
+        size_t count = 0;
+        if (b >= 0xC2 && b <= 0xDF) {
+            count = 1;
+        } else if (b >= 0xE0 && b <= 0xEF) {
+            count = 2;
+        } else if (b >= 0xF0 && b <= 0xF4) {
+            count = 3;
+        } else {
+            return false;
+        }
+        if (i + count >= s.size()) {
+            return false;
+        }
+        for (size_t j = 1; j <= count; ++j) {
+            if (bytes[i + j] < 0x80 || bytes[i + j] > 0xBF) {
+                return false;
+            }
+        }
+        if ((b == 0xE0 && bytes[i + 1] < 0xA0) ||
+            (b == 0xED && bytes[i + 1] > 0x9F) ||
+            (b == 0xF0 && bytes[i + 1] < 0x90) ||
+            (b == 0xF4 && bytes[i + 1] > 0x8F)) {
+            return false;
+        }
+        i += count + 1;
+    }
+    return true;
+}
+
+bool contains_utf8_bom(const std::string& s) {
+    return s.find("\xEF\xBB\xBF") != std::string::npos;
+}
+
+bool validate_identifier(const std::string& name, std::string& error) {
+    if (name.empty()) {
+        error = "name must not be empty";
+        return false;
+    }
+    if (!is_valid_utf8(name) || contains_utf8_bom(name)) {
+        error = "name '" + name + "' is not valid UTF-8";
+        return false;
+    }
+    for (size_t i = 0; i < name.size(); ++i) {
+        const unsigned char c = static_cast<unsigned char>(name[i]);
+        if (c < 0x20 || c == 0x7F) {
+            error = "name contains a control character";
+            return false;
+        }
+        if (c == 0xC2 && i + 1 < name.size()) {
+            const unsigned char next = static_cast<unsigned char>(name[i + 1]);
+            if (next >= 0x80 && next <= 0x9F) {
+                error = "name contains a control character";
+                return false;
+            }
+        }
+    }
+    if (lower_ascii(name) == "time") {
+        error = "name '" + name + "' is reserved";
+        return false;
+    }
+    return true;
+}
+
 bool parse_bool_cell(const std::string& s, bool& out) {
     std::string l;
     l.reserve(s.size());
diff --git a/cpp/tools/format/input_format.h b/cpp/tools/format/input_format.h
index 3b46af769..d7cfc38a2 100644
--- a/cpp/tools/format/input_format.h
+++ b/cpp/tools/format/input_format.h
@@ -42,6 +42,9 @@ bool parse_columns_spec(const std::string& spec, std::vector<ColumnDef>& out,
 std::vector<std::string> split_line(const std::string& line, char delim,
                                     bool csv_quotes);
 bool parse_bool_cell(const std::string& s, bool& out);
+bool is_valid_utf8(const std::string& s);
+bool contains_utf8_bom(const std::string& s);
+bool validate_identifier(const std::string& name, std::string& error);
 
 // Read one logical record from `in`. When `csv_quotes` is true a field may span
 // multiple physical lines if it opens a double-quote that is not yet closed, so
diff --git a/cpp/tools/format/output_format.cc b/cpp/tools/format/output_format.cc
index 3fecfb69b..05c07a3d9 100644
--- a/cpp/tools/format/output_format.cc
+++ b/cpp/tools/format/output_format.cc
@@ -83,7 +83,8 @@ OutputFormat resolve_format(ParsedArgs::Format f, bool stdout_is_tty) {
             return OutputFormat::kTable;
         case ParsedArgs::Format::kAuto:
         default:
-            return stdout_is_tty ? OutputFormat::kTable : OutputFormat::kTsv;
+            (void)stdout_is_tty;
+            return OutputFormat::kTable;
     }
 }
 
@@ -241,6 +242,18 @@ bool json_nonfinite(common::TSDataType t, const std::string& cell) {
     return cell.find_first_of("nNiI") != std::string::npos;
 }
 
+std::string blob_hex(const std::string& cell) {
+    static const char kHex[] = "0123456789abcdef";
+    std::string out;
+    out.reserve(2 + cell.size() * 2);
+    out += "0x";
+    for (unsigned char c : cell) {
+        out += kHex[c >> 4];
+        out += kHex[c & 0x0f];
+    }
+    return out;
+}
+
 }  // namespace
 
 RowWriter::RowWriter(std::ostream& out, OutputFormat fmt,
@@ -250,35 +263,51 @@ RowWriter::RowWriter(std::ostream& out, OutputFormat fmt,
       fmt_(fmt),
       header_(std::move(header)),
       types_(std::move(types)),
-      no_header_(no_header) {}
+      no_header_(no_header),
+      table_widths_(header_.size(), 0) {
+    if (!no_header_) {
+        for (size_t i = 0; i < header_.size(); ++i) {
+            table_widths_[i] = header_[i].size();
+        }
+    }
+}
 
-bool RowWriter::emits_json_bare(size_t col) const {
-    if (col >= types_.size()) {
-        return false;
+RowWriter::~RowWriter() {
+    if (spool_ != nullptr) {
+        std::fclose(spool_);
     }
-    // These types serialize to a bare (unquoted) JSON token: numbers as numeric
-    // literals, BOOLEAN as the literal true/false, TIMESTAMP as a number.
-    // Everything else (strings, blobs, dates) is quoted.
-    switch (types_[col]) {
+}
+
+bool RowWriter::emits_json_bare(common::TSDataType type) const {
+    // External NDJSON keeps INT64 and TIMESTAMP as decimal strings so
+    // JavaScript consumers do not lose precision. Smaller and floating-point
+    // numeric types remain bare JSON tokens; everything else is quoted.
+    switch (type) {
         case common::BOOLEAN:
         case common::INT32:
-        case common::INT64:
         case common::FLOAT:
         case common::DOUBLE:
-        case common::TIMESTAMP:
             return true;
         default:
             return false;
     }
 }
 
-void RowWriter::ensure_header() {
+std::string RowWriter::format_cell(common::TSDataType type,
+                                   const std::string& cell) const {
+    if (type == common::BLOB) {
+        return blob_hex(cell);
+    }
+    return cell;
+}
+
+bool RowWriter::ensure_header() {
     if (header_done_) {
-        return;
+        return out_.good();
     }
     header_done_ = true;
     if (no_header_) {
-        return;
+        return out_.good();
     }
     const char sep = (fmt_ == OutputFormat::kCsv) ? ',' : '\t';
     for (size_t i = 0; i < header_.size(); ++i) {
@@ -289,14 +318,47 @@ void RowWriter::ensure_header() {
                                             : header_[i]);
     }
     out_ << "\n";
+    return out_.good();
 }
 
-void RowWriter::write(const std::vector<std::string>& cells,
+bool RowWriter::write(const std::vector<std::string>& cells,
                       const std::vector<bool>& is_null) {
+    return write(cells, is_null, types_);
+}
+
+bool RowWriter::write(const std::vector<std::string>& cells,
+                      const std::vector<bool>& is_null,
+                      const std::vector<common::TSDataType>& row_types) {
+    if (!out_.good()) {
+        return false;
+    }
     if (fmt_ == OutputFormat::kTable) {
-        rows_.push_back(cells);
-        rows_null_.push_back(is_null);
-        return;
+        if (spool_ == nullptr) {
+            spool_ = std::tmpfile();
+            if (spool_ == nullptr) {
+                return false;
+            }
+        }
+        for (size_t i = 0; i < header_.size(); ++i) {
+            const unsigned char null =
+                i >= cells.size() || (i < is_null.size() && is_null[i]);
+            const common::TSDataType type =
+                i < row_types.size() ? row_types[i] : common::STRING;
+            const std::string value = null ? std::string() : cells[i];
+            const uint64_t length = static_cast<uint64_t>(value.size());
+            const int32_t serialized_type = static_cast<int32_t>(type);
+            if (std::fwrite(&null, sizeof(null), 1, spool_) != 1 ||
+                std::fwrite(&serialized_type, sizeof(serialized_type), 1,
+                            spool_) != 1 ||
+                std::fwrite(&length, sizeof(length), 1, spool_) != 1 ||
+                (length > 0 &&
+                 std::fwrite(value.data(), 1, length, spool_) != length)) {
+                return false;
+            }
+            table_widths_[i] =
+                std::max(table_widths_[i], format_cell(type, value).size());
+        }
+        return true;
     }
     if (fmt_ == OutputFormat::kJson) {
         out_ << "{";
@@ -305,24 +367,32 @@ void RowWriter::write(const std::vector<std::string>& cells,
                 out_ << ",";
             }
             out_ << "\"" << json_escape(header_[i]) << "\":";
+            const common::TSDataType type =
+                i < row_types.size() ? row_types[i] : common::STRING;
             if (i < is_null.size() && is_null[i]) {
                 out_ << "null";
-            } else if (emits_json_bare(i)) {
-                if (i >= cells.size() || json_nonfinite(types_[i], cells[i])) {
+            } else if (emits_json_bare(type)) {
+                const std::string cell =
+                    format_cell(type, i < cells.size() ? cells[i] : "");
+                if (json_nonfinite(type, cell)) {
                     out_ << "null";  // NaN/Inf: match JSON serializer practice
                 } else {
-                    out_ << cells[i];
+                    out_ << cell;
                 }
             } else {
-                out_ << "\"" << json_escape(i < cells.size() ? cells[i] : "")
+                out_ << "\""
+                     << json_escape(
+                            format_cell(type, i < cells.size() ? cells[i] : ""))
                      << "\"";
             }
         }
         out_ << "}\n";
-        return;
+        return out_.good();
     }
 
-    ensure_header();
+    if (!ensure_header()) {
+        return false;
+    }
     const char sep = (fmt_ == OutputFormat::kCsv) ? ',' : '\t';
     for (size_t i = 0; i < cells.size(); ++i) {
         if (i) {
@@ -330,43 +400,53 @@ void RowWriter::write(const std::vector<std::string>& cells,
         }
         bool null_cell = i < is_null.size() && is_null[i];
         if (null_cell) {
+            if (fmt_ == OutputFormat::kCsv) {
+                out_ << "\\N";
+            }
             continue;
         }
-        out_ << (fmt_ == OutputFormat::kCsv ? csv_escape(cells[i]) : cells[i]);
+        const common::TSDataType type =
+            i < row_types.size() ? row_types[i] : common::STRING;
+        const std::string cell = format_cell(type, cells[i]);
+        if (fmt_ == OutputFormat::kCsv && cell.empty()) {
+            out_ << "\"\"";
+        } else {
+            out_ << (fmt_ == OutputFormat::kCsv ? csv_escape(cell) : cell);
+        }
     }
     out_ << "\n";
+    return out_.good();
 }
 
-void RowWriter::finish() {
+bool RowWriter::finish() {
+    if (!out_.good()) {
+        return false;
+    }
     if (fmt_ != OutputFormat::kTable) {
         if (fmt_ == OutputFormat::kCsv || fmt_ == OutputFormat::kTsv) {
-            ensure_header();
+            if (!ensure_header()) {
+                return false;
+            }
         }
-        return;
+        out_.flush();
+        return out_.good();
     }
 
     const size_t ncols = header_.size();
-    std::vector<size_t> width(ncols, 0);
-    if (!no_header_) {
-        for (size_t i = 0; i < ncols; ++i) {
-            width[i] = header_[i].size();
-        }
-    }
-    for (const auto& row : rows_) {
-        for (size_t i = 0; i < ncols && i < row.size(); ++i) {
-            width[i] = std::max(width[i], row[i].size());
-        }
-    }
 
     auto emit = [&](const std::vector<std::string>& cells,
-                    const std::vector<bool>& nulls) {
+                    const std::vector<bool>& nulls,
+                    const std::vector<common::TSDataType>& row_types) {
         for (size_t i = 0; i < ncols; ++i) {
             std::string cell =
-                (i < cells.size() && !(i < nulls.size() && nulls[i])) ? cells[i]
-                                                                      : "";
+                (i < cells.size() && !(i < nulls.size() && nulls[i]))
+                    ? format_cell(
+                          i < row_types.size() ? row_types[i] : common::STRING,
+                          cells[i])
+                    : "";
             out_ << cell;
             if (i + 1 < ncols) {
-                out_ << std::string(width[i] - cell.size() + 2, ' ');
+                out_ << std::string(table_widths_[i] - cell.size() + 2, ' ');
             }
         }
         out_ << "\n";
@@ -374,11 +454,55 @@ void RowWriter::finish() {
 
     if (!no_header_) {
         std::vector<bool> no_nulls(ncols, false);
-        emit(header_, no_nulls);
+        emit(header_, no_nulls,
+             std::vector<common::TSDataType>(ncols, common::STRING));
     }
-    for (size_t r = 0; r < rows_.size(); ++r) {
-        emit(rows_[r], rows_null_[r]);
+    if (spool_ != nullptr) {
+        if (std::fflush(spool_) != 0 || std::fseek(spool_, 0, SEEK_SET) != 0) {
+            return false;
+        }
+        while (true) {
+            std::vector<std::string> cells(ncols);
+            std::vector<bool> nulls(ncols, false);
+            std::vector<common::TSDataType> row_types(ncols, common::STRING);
+            bool eof = false;
+            for (size_t i = 0; i < ncols; ++i) {
+                unsigned char null = 0;
+                int32_t serialized_type = 0;
+                uint64_t length = 0;
+                if (std::fread(&null, sizeof(null), 1, spool_) != 1) {
+                    eof = i == 0 && std::feof(spool_);
+                    if (!eof) {
+                        return false;
+                    }
+                    break;
+                }
+                if (std::fread(&serialized_type, sizeof(serialized_type), 1,
+                               spool_) != 1 ||
+                    std::fread(&length, sizeof(length), 1, spool_) != 1) {
+                    return false;
+                }
+                nulls[i] = null != 0;
+                row_types[i] = static_cast<common::TSDataType>(serialized_type);
+                cells[i].resize(static_cast<size_t>(length));
+                if (length > 0 &&
+                    std::fread(&cells[i][0], 1, length, spool_) != length) {
+                    return false;
+                }
+            }
+            if (eof) {
+                break;
+            }
+            emit(cells, nulls, row_types);
+            if (!out_.good()) {
+                return false;
+            }
+        }
+        std::fclose(spool_);
+        spool_ = nullptr;
     }
+    out_.flush();
+    return out_.good();
 }
 
 }  // namespace tsfile_cli
diff --git a/cpp/tools/format/output_format.h b/cpp/tools/format/output_format.h
index c7efdd190..cfab60a69 100644
--- a/cpp/tools/format/output_format.h
+++ b/cpp/tools/format/output_format.h
@@ -20,6 +20,7 @@
 #ifndef TSFILE_CLI_OUTPUT_FORMAT_H
 #define TSFILE_CLI_OUTPUT_FORMAT_H
 
+#include <cstdio>
 #include <ostream>
 #include <string>
 #include <vector>
@@ -49,14 +50,20 @@ class RowWriter {
     RowWriter(std::ostream& out, OutputFormat fmt,
               std::vector<std::string> header,
               std::vector<common::TSDataType> types, bool no_header);
+    ~RowWriter();
 
-    void write(const std::vector<std::string>& cells,
+    bool write(const std::vector<std::string>& cells,
                const std::vector<bool>& is_null);
-    void finish();
+    bool write(const std::vector<std::string>& cells,
+               const std::vector<bool>& is_null,
+               const std::vector<common::TSDataType>& row_types);
+    bool finish();
 
    private:
-    void ensure_header();
-    bool emits_json_bare(size_t col) const;
+    bool ensure_header();
+    bool emits_json_bare(common::TSDataType type) const;
+    std::string format_cell(common::TSDataType type,
+                            const std::string& cell) const;
 
     std::ostream& out_;
     OutputFormat fmt_;
@@ -64,8 +71,8 @@ class RowWriter {
     std::vector<common::TSDataType> types_;
     bool no_header_;
     bool header_done_ = false;
-    std::vector<std::vector<std::string>> rows_;
-    std::vector<std::vector<bool>> rows_null_;
+    std::FILE* spool_ = nullptr;
+    std::vector<size_t> table_widths_;
 };
 
 }  // namespace tsfile_cli
diff --git a/cpp/tools/format/result_set_format.cc b/cpp/tools/format/result_set_format.cc
index e73642889..ea0b350b4 100644
--- a/cpp/tools/format/result_set_format.cc
+++ b/cpp/tools/format/result_set_format.cc
@@ -73,7 +73,8 @@ std::string cell_to_string(storage::ResultSet* rs, uint32_t i,
 }
 
 int emit_result_set(storage::ResultSet* rs, OutputFormat fmt, bool no_header,
-                    std::ostream& out, long long offset, long long limit) {
+                    std::ostream& out, long long offset, long long limit,
+                    long long* emitted_rows) {
     auto meta = rs->get_metadata();
     const uint32_t ncol = meta->get_column_count();
     std::vector<std::string> header;
@@ -107,10 +108,20 @@ int emit_result_set(storage::ResultSet* rs, OutputFormat fmt, bool no_header,
                 cells[i - 1] = cell_to_string(rs, i, types[i - 1]);
             }
         }
-        writer.write(cells, nulls);
+        if (!writer.write(cells, nulls)) {
+            return common::E_FILE_WRITE_ERR;
+        }
         ++emitted;
     }
-    writer.finish();
+    if (code == common::E_OK && skipped < offset) {
+        return common::E_OUT_OF_RANGE;
+    }
+    if (!writer.finish()) {
+        return common::E_FILE_WRITE_ERR;
+    }
+    if (emitted_rows != nullptr) {
+        *emitted_rows = emitted;
+    }
     return code;
 }
 
@@ -178,9 +189,13 @@ int emit_result_set_sampled(storage::ResultSet* rs, OutputFormat fmt,
 
     RowWriter writer(out, fmt, header, types, no_header);
     for (const BufferedRow& row : reservoir) {
-        writer.write(row.cells, row.nulls);
+        if (!writer.write(row.cells, row.nulls)) {
+            return common::E_FILE_WRITE_ERR;
+        }
+    }
+    if (!writer.finish()) {
+        return common::E_FILE_WRITE_ERR;
     }
-    writer.finish();
     return code;
 }
 
diff --git a/cpp/tools/format/result_set_format.h b/cpp/tools/format/result_set_format.h
index a9fb2a4b1..40814a47b 100644
--- a/cpp/tools/format/result_set_format.h
+++ b/cpp/tools/format/result_set_format.h
@@ -34,7 +34,7 @@ std::string cell_to_string(storage::ResultSet* rs, uint32_t col_index,
 
 int emit_result_set(storage::ResultSet* rs, OutputFormat fmt, bool no_header,
                     std::ostream& out, long long offset = 0,
-                    long long limit = -1);
+                    long long limit = -1, long long* emitted_rows = nullptr);
 
 int emit_result_set_sampled(storage::ResultSet* rs, OutputFormat fmt,
                             bool no_header, std::ostream& out, long long limit,
diff --git a/cpp/tools/skills/tsfile-cli/SKILL.md b/cpp/tools/skills/tsfile-cli/SKILL.md
index 8261cc70a..a52aabbbb 100644
--- a/cpp/tools/skills/tsfile-cli/SKILL.md
+++ b/cpp/tools/skills/tsfile-cli/SKILL.md
@@ -18,15 +18,21 @@
 name: tsfile-cli
 description: >-
   Use specifically for the project's C++ `tsfile-cli` in cpp/tools: inspect,
-  preview, export, or sample an Apache TsFile; report metadata or per-series
-  counts; or use its explicit single-table CSV/TSV write command.
+  preview, export, or create an Apache TsFile; report metadata or per-series
+  counts; or use its explicit single-table CSV write command.
 ---
 
 # tsfile-cli
 
-Single pipe-friendly C++ binary to inspect `.tsfile` files and create a new
-table-model TsFile from CSV/TSV (TsFile's analogue of `parquet-cli`/`pqrs`).
-Source `cpp/tools/`. Read data → stdout, diagnostics → stderr.
+Single pipe-friendly C++ binary to inspect, read, export, and create `.tsfile`
+files. Source `cpp/tools/`. Result data goes to stdout except `export`,
+`sketch -o`, and `write`; diagnostics go to stderr.
+
+Reference files:
+
+- `references/commands.md`: command syntax and result fields.
+- `references/errors.md`: exit-code and failure-handling rules.
+- `references/examples.md`: reviewed command recipes.
 
 ## Scope
 
@@ -36,7 +42,7 @@ checks or backfill to the top-level `tsfile` skill when it is installed.
 
 The names overlap but the semantics do not: `tsfile-cli count` is a read-only
 per-series report, not the Java table point-count property tool. `tsfile-cli
-write` is the C++ binary's narrow one-file/stream, one-table CSV/TSV import; it
+write` is the C++ binary's narrow one-file/stream, one-table CSV import; it
 does not replace the Java batch and format-aware import tools.
 
 ## Binary
@@ -50,66 +56,68 @@ does not replace the Java batch and format-aware import tools.
 
 | cmd | output | scans pages |
 |---|---|---|
-| `ls` | device (tree) / table (table) per line | no |
-| `schema` | `target,measurement,datatype,encoding,compression` | no |
-| `meta` | model, device/table/series counts, time range, size | no |
-| `stats` | per-series `count,start,end,min,max,first,last,sum` | no |
-| `count` | per-series counts + `total` row | no |
+| `ls` | `model,object` rows for tree devices or table names | no |
+| `schema` | `model,object,column,category,data_type,encoding,compression` | no |
+| `meta` | `size_bytes,format_version,model` | no |
+| `stats` | FIELD statistics with null counts and source | maybe |
+| `count` | object/column counts; no summary row | maybe |
 | `head` | first N rows (default 10, `-n`) | yes |
 | `cat` | all matching rows (streamed; `table` format buffers) | yes |
-| `sample` | reservoir sample (default 10, `-n` + `--seed`) | yes |
+| `sketch` | physical layout text from the bound `printSketch` behavior | no FIELD decode |
+| `export` | writes one object file or a numbered multi-object directory | yes |
 
-Prefer no-scan verbs (`ls/schema/meta/stats/count`) — cheap and never hit the page-decode caveat.
+Prefer metadata verbs (`ls/schema/meta/stats/count`) before row verbs so the
+file model, scope, and columns are known.
 
-Table model + row verbs (`head/cat/sample`): without `-t`, only the **first** table is queried. Pass `-t <table>` to target a specific one (`count` covers all tables).
+For `head` and `cat`, omit `-d/-t` only when the selected model has exactly one
+accessible object. Multi-object files require explicit scope. `export` always
+requires explicit scope.
 
 ```
-opts: -f csv|tsv|json|table  (default TTY→table, pipe→tsv)
+opts: -f table|ndjson|csv  (default table)
       -d <device> | -t <table>   (mutually exclusive)
-      -m a,b,c (projection) · -n N · --offset N · --start <ms> · --end <ms> (inclusive)
-      --tag-filter C OP V · --tag-between C L U · --tag-not-between C L U (table TAG predicates)
-      --seed N · --no-header · --model tree|table (else auto)
-applies: -m → schema/stats/count/head/cat/sample · -d/-t → row cmds/schema/stats/count
-         (-d needs tree model, -t needs table model in head/cat/sample/schema) · --offset ∉ sample
-         tag filters → head/cat/sample table model; OP=eq|neq|lt|lteq|gt|gteq|regexp|not-regexp
-json=NDJSON (num/bool bare, else quoted, null→null, NaN/Inf→null) · csv=RFC4180 · ts=raw epoch ms
+      -m <column> repeat for projection or metadata filtering; no comma lists
+      -n N · --offset N · --start <int64> · --end <int64> for head/cat/export
+      --tag-filter C OP [V] where OP=eq|neq|regexp|is-null|not-null
+      --tag-match all|any when two or more tag filters are present
+ndjson=one JSON object per line · csv=RFC 4180 with header · INT64/TIMESTAMP as decimal strings
 exit: 0 ok · 1 usage · 2 file open/corrupt · 3 query/runtime
 ```
 
 ```sh
 B=cpp/build/Debug/bin/tsfile-cli
-$B meta data.tsfile; $B count -t table1 -f tsv data.tsfile
-$B cat -t table1 --tag-filter device eq dev_1 -m temp -f tsv data.tsfile
+$B meta data.tsfile; $B count -t table1 -f csv data.tsfile
+$B cat -t table1 --tag-filter device eq dev_1 -m temp -f ndjson data.tsfile
 $B cat -m temp --start 1700000000000 -f csv data.tsfile 2>/dev/null | head
 ```
 
 ## Write
 
-`tsfile-cli write --table <name> --columns <spec> -o <out> [-f csv|tsv] [--no-header] [--header-match] [-v] [<input> | -]`
+`tsfile-cli write --table <name> (--tag <name> STRING)* (--field <name> <TYPE>)+ [--encoding <TYPE> <ENC>] [--compression <TYPE> <COMP>] (-i <input.csv>|--stdin) -o <out.tsfile> [-v]`
 
-Imports rows into a **new table-model** file (overwritten). Input col 0 = timestamp
-(epoch ms, int); remaining cols declared by `--columns` — **no type inference**.
+Creates a new single-table, table-model file from strict CSV. The target must
+not already exist; the command never creates tree-model TsFiles and never
+modifies an existing TsFile.
 
 ```
-spec  := col (',' col)*
-col   := name ':' TYPE ':' ('tag' | 'field')          # TYPE + category case-insensitive
 TYPE  ∈ { BOOLEAN, INT32, INT64, FLOAT, DOUBLE, STRING, TEXT, TIMESTAMP, DATE, BLOB }
-input := file | '-' | omitted                          # '-' or omitted = stdin
+ENC   ∈ bound TsFile encodings such as PLAIN, TS_2DIFF, GORILLA, DICTIONARY
+COMP  ∈ UNCOMPRESSED, SNAPPY, GZIP, LZO, LZ4, ZSTD, LZMA2
 ```
 
-- `-o` required (overwritten, must differ from input); `-f` default csv (json/table → usage error).
-- header: first line skipped by default · `--no-header` if none · `--header-match` validates
-  header names vs `--columns` (mutually exclusive with `--no-header`).
-- empty cell = null · `--table` is lower-cased · `DATE` cells are `YYYY-MM-DD`, `TIMESTAMP` epoch ms · each column stored with the engine default encoding/compression for its type · success **silent**, `-v` → echoes the resolved config + `wrote N rows to <out>` on stderr.
+- CSV must contain a unique header with `time` and exactly the declared TAG/FIELD names; rows are mapped by header name, not physical column order.
+- `--encoding` and `--compression` are keyed by declared data type and apply to all declared columns of that type.
+- `DATE` cells are `YYYY-MM-DD`; `TIMESTAMP` and row `time` use strict decimal int64.
 - **timestamps must be strictly increasing per device** (device = tag-column values); rows for
   different tags may interleave/reuse timestamps. Out-of-order input → error with line number.
-- a failed import deletes its partial output (no half-written `.tsfile` left behind).
-- exit: `1` usage (missing `--table`/`--columns`/`-o`, bad spec, dup column, read-only flag) · `2` IO open · `3` row (field-count / type / overflow / timestamp-order / header mismatch).
+- A failed import deletes its partial output; success is silent unless `-v` is used.
+- `-v` writes one post-commit summary to stderr: `created model=table object=<table> rows=<n> output=<path>` plus one line per column with resolved physical settings.
+- exit: `1` usage/parameter error · `2` CSV/input problem · `3` target/write/commit failure.
 
 ```sh
 printf 'time,id1,s1\n0,dev,0\n1,dev,10\n' \
-  | tsfile-cli write --table t1 --columns "id1:STRING:tag,s1:INT64:field" -o out.tsfile -
-tsfile-cli count -f tsv out.tsfile        # -> t1.dev  s1  2
+  | tsfile-cli write --table t1 --tag id1 STRING --field s1 INT64 --stdin -o out.tsfile
+tsfile-cli count -f csv out.tsfile
 ```
 
 Tree-model / JSON / programmatic writes → C++ SDK `cpp/examples/cpp_examples/demo_write.cpp`
@@ -117,9 +125,6 @@ Tree-model / JSON / programmatic writes → C++ SDK `cpp/examples/cpp_examples/d
 
 ## Caveats
 
-- `head`/`cat`/`sample` decode pages → may abort (`decode_cur_time_page_data`, exit 134) on
-  some aligned files incl. bundled `cpp/examples/test_cpp.tsfile`. Storage-engine/file issue,
-  not a CLI bug; metadata verbs still work. Use a well-formed (e.g. self-written) file for rows.
-- table-model `target` is derived from tag bytes → may show non-printable chars in `stats/count/schema`.
-- `schema` lists all columns; `meta/stats/count` count only field series → `series_count` can be
-  fewer than `schema` rows (not a bug).
+- `head`/`cat`/`export` decode pages; nonzero exit means any produced stdout or files are not complete results.
+- Table results always include all TAG columns before selected FIELD columns.
+- `sketch` follows the bound TsFile `printSketch` text and does not support `-f`.
diff --git a/cpp/tools/skills/tsfile-cli/references/commands.md b/cpp/tools/skills/tsfile-cli/references/commands.md
new file mode 100644
index 000000000..85b49203c
--- /dev/null
+++ b/cpp/tools/skills/tsfile-cli/references/commands.md
@@ -0,0 +1,46 @@
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+
+# tsfile-cli Commands
+
+Use `tsfile-cli <command> --help` as the runtime source of truth. This file
+summarizes the same supported surface for agents.
+
+## Metadata
+
+- `ls [-f table|ndjson|csv] <file.tsfile>` outputs `model,object`.
+- `schema [-d <device>|-t <table>] [-m <column>]... [-f table|ndjson|csv] <file.tsfile>` outputs `model,object,column,category,data_type,encoding,compression`.
+- `meta [-f table|ndjson|csv] <file.tsfile>` outputs `size_bytes,format_version,model`.
+- `stats [-d <device>|-t <table>] [-m <field>]... [-f table|ndjson|csv] <file.tsfile>` outputs FIELD statistics. Tree rows use `model,object,field,data_type,non_null_count,null_count,min_time,max_time,min,max,first,last,sum,stats_source`; table rows insert dynamic `tag.<name>` fields after `object`.
+- `count [-d <device>|-t <table>] [-m <column>]... [-f table|ndjson|csv] <file.tsfile>` outputs per-column logical counts.
+- `sketch [-o <file>] [--force] <file.tsfile>` outputs the bound `printSketch` physical layout text.
+
+## Rows And Export
+
+- `head` and `cat` read one object and accept `-d|-t`, repeated `-m`, `--start`, `--end`, `--offset`, optional `-n`, table `--tag-filter`, conditional `--tag-match`, and `-f table|ndjson|csv`.
+- `head` defaults to `--limit 10`; `cat` defaults to no row limit.
+- `export` requires `--type table|ndjson|csv`. Single-object export uses `-o`; multi-object export repeats only devices or only tables and uses `--output-dir`.
+
+## Write
+
+`write --table <name> (--tag <name> STRING)* (--field <name> <TYPE>)+ [--encoding <TYPE> <ENC>] [--compression <TYPE> <COMP>] (-i <input.csv>|--stdin) -o <out.tsfile> [-v]`
+
+`write` creates one new table-model TsFile from strict CSV. The CSV header must
+contain `time` and exactly the declared TAG/FIELD names. Rows are mapped by
+header name. The target must not exist.
diff --git a/cpp/tools/skills/tsfile-cli/references/errors.md b/cpp/tools/skills/tsfile-cli/references/errors.md
new file mode 100644
index 000000000..660357f03
--- /dev/null
+++ b/cpp/tools/skills/tsfile-cli/references/errors.md
@@ -0,0 +1,34 @@
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+
+# tsfile-cli Errors
+
+Exit status is the only success signal.
+
+- `0`: complete success.
+- `1`: usage or parameter error, including unknown commands, invalid options, missing scope, invalid projection, offset errors, or mismatched model/scope.
+- `2`: input problem, including missing or unreadable TsFile input, damaged TsFile input, invalid CSV syntax or data during `write`, or unsupported source file type for `write -i`.
+- `3`: runtime or target problem, including query/write failures, output target conflicts, output creation failure, or atomic commit failure.
+
+Rules for callers:
+
+- Ignore stdout and output files unless the exit status is `0`.
+- `cat > file` is shell-managed and not atomic; use `export` for atomic files.
+- `export`, `sketch -o`, and `write` write final targets only after successful command-level validation and commit.
+- `write -v` emits a summary only after the target TsFile is committed.
diff --git a/cpp/tools/skills/tsfile-cli/references/examples.md b/cpp/tools/skills/tsfile-cli/references/examples.md
new file mode 100644
index 000000000..c0569c035
--- /dev/null
+++ b/cpp/tools/skills/tsfile-cli/references/examples.md
@@ -0,0 +1,51 @@
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+-->
+
+# tsfile-cli Examples
+
+Inspect before reading rows:
+
+```sh
+tsfile-cli ls -f ndjson data.tsfile
+tsfile-cli meta -f ndjson data.tsfile
+tsfile-cli schema -t sensors -f csv data.tsfile
+tsfile-cli count -t sensors -f csv data.tsfile
+```
+
+Read bounded data:
+
+```sh
+tsfile-cli head -t sensors -m temperature -n 20 -f csv data.tsfile
+tsfile-cli cat -t sensors --tag-filter site eq north -m temperature -f ndjson data.tsfile
+```
+
+Export one object atomically:
+
+```sh
+tsfile-cli export -t sensors --type csv -o sensors.csv data.tsfile
+```
+
+Create a new table-model TsFile and verify it through a read command:
+
+```sh
+printf 'time,site,temperature\n0,north,21.5\n1,north,21.7\n' \
+  | tsfile-cli write --table sensors --tag site STRING \
+      --field temperature DOUBLE --stdin -o sensors.tsfile
+tsfile-cli count -t sensors -f csv sensors.tsfile
+```
diff --git a/cpp/tools/tools_main.cc b/cpp/tools/tools_main.cc
index 48924945d..785c77cce 100644
--- a/cpp/tools/tools_main.cc
+++ b/cpp/tools/tools_main.cc
@@ -19,6 +19,9 @@
 
 #include <exception>
 #include <iostream>
+#ifndef _WIN32
+#include <csignal>
+#endif
 #include <string>
 #include <vector>
 
@@ -26,6 +29,9 @@
 #include "cli/run_cli.h"
 
 int main(int argc, char** argv) {
+#ifndef _WIN32
+    std::signal(SIGPIPE, SIG_IGN);
+#endif
     std::vector<std::string> args(argv + 1, argv + argc);
     try {
         return tsfile_cli::run_cli(args, std::cout, std::cerr);