diff --git a/ddprof-lib/src/main/cpp/arguments.cpp b/ddprof-lib/src/main/cpp/arguments.cpp
index d9aae05cb4..82db261aa5 100644
--- a/ddprof-lib/src/main/cpp/arguments.cpp
+++ b/ddprof-lib/src/main/cpp/arguments.cpp
@@ -119,6 +119,32 @@ static const Multiplier UNIVERSAL[] = {
 //     alluser            - include only user-mode events
 //
 
+// Parses the y/yes,t/true,1 vs n/no,f/false,0 boolean convention. A NULL value
+// (bare option, no '=') enables the flag, matching the documented no-value-means-
+// enable convention shared by every boolean option in this file. Returns false
+// (leaving out untouched) when a non-NULL value matches none of the above, so the
+// caller can raise "Invalid <option> value" instead of coercing garbage to a
+// default. Takes out by reference since every caller passes a real bool.
+static bool parseBoolOption(const char *value, bool &out) {
+  if (value == nullptr) {
+    out = true;
+    return true;
+  }
+  if (strcmp(value, "y") == 0 || strcmp(value, "yes") == 0 ||
+      strcmp(value, "t") == 0 || strcmp(value, "true") == 0 ||
+      strcmp(value, "1") == 0) {
+    out = true;
+    return true;
+  }
+  if (strcmp(value, "n") == 0 || strcmp(value, "no") == 0 ||
+      strcmp(value, "f") == 0 || strcmp(value, "false") == 0 ||
+      strcmp(value, "0") == 0) {
+    out = false;
+    return true;
+  }
+  return false;
+}
+
 Error Arguments::parse(const char *args) {
   if (args == NULL) {
     return Error::OK;
@@ -255,7 +281,9 @@ Error Arguments::parse(const char *args) {
       }
 
       CASE("generations")
-      _gc_generations = value != NULL && strcmp(value, "true") == 0;
+      if (!parseBoolOption(value, _gc_generations)) {
+        msg = "Invalid generations value";
+      }
       if (_gc_generations && _memory <= 0) {
         _memory =
             4 * 1024 *
@@ -327,8 +355,10 @@ Error Arguments::parse(const char *args) {
           _cstack = CSTACK_VM;
           _features.mixed = 1;
           _features.carrier_frames = 1;
-        } else {
+        } else if (strcmp(value, "no") == 0) {
           _cstack = CSTACK_NO;
+        } else {
+          msg = "Invalid cstack value";
         }
       }
 
@@ -345,104 +375,48 @@ Error Arguments::parse(const char *args) {
       }
 
       CASE("lightweight")
-      if (value != NULL) {
-        switch (value[0]) {
-        case 'y': // yes
-        case 't': // true
-          _lightweight = true;
-          break;
-        default:
-          _lightweight = false;
-        }
+      if (value != NULL && !parseBoolOption(value, _lightweight)) {
+        msg = "Invalid lightweight value";
       }
 
       CASE("mcleanup")
-      if (value != NULL) {
-        switch (value[0]) {
-        case 'n': // no
-        case 'f': // false
-        case '0': // 0
-          _enable_method_cleanup = false;
-          break;
-        case 'y': // yes
-        case 't': // true
-        case '1': // 1
-        default:
-          _enable_method_cleanup = true;
-        }
-      } else {
-        // No value means enable
-        _enable_method_cleanup = true;
+      // No value means enable.
+      if (!parseBoolOption(value, _enable_method_cleanup)) {
+        msg = "Invalid mcleanup value";
       }
 
       CASE("remotesym")
-      if (value != NULL) {
-        switch (value[0]) {
-        case 'n': // no
-        case 'f': // false
-        case '0': // 0
-          _remote_symbolication = false;
-          break;
-        case 'y': // yes
-        case 't': // true
-        case '1': // 1
-        default:
-          _remote_symbolication = true;
-        }
-      } else {
-        // No value means enable
-        _remote_symbolication = true;
+      // No value means enable.
+      if (!parseBoolOption(value, _remote_symbolication)) {
+        msg = "Invalid remotesym value";
       }
 
       CASE("jvmtistacks")
-      if (value != NULL) {
-        switch (value[0]) {
-        case 'y': // yes
-        case 't': // true
-        case '1': // 1
-          _jvmtistacks = true;
-          break;
-        default:
-          _jvmtistacks = false;
-        }
-      } else {
-        _jvmtistacks = true;
+      if (!parseBoolOption(value, _jvmtistacks)) {
+        msg = "Invalid jvmtistacks value";
       }
 
       CASE("wallprecheck")
-      if (value != NULL) {
-        _wall_precheck = strcmp(value, "false") != 0 && strcmp(value, "0") != 0;
-      } else {
-        // No value means enable
-        _wall_precheck = true;
+      // No value means enable.
+      if (!parseBoolOption(value, _wall_precheck)) {
+        msg = "Invalid wallprecheck value";
       }
 
       CASE("wallsampler")
       if (value != NULL) {
-          switch (value[0]) {
-              case 'j':
-                  _wallclock_sampler = JVMTI;
-                  break;
-              case 'a':
-              default:
-                  _wallclock_sampler = ASGCT;
+          if (strcasecmp(value, "jvmti") == 0) {
+              _wallclock_sampler = JVMTI;
+          } else if (strcasecmp(value, "asgct") == 0) {
+              _wallclock_sampler = ASGCT;
+          } else {
+              msg = "Invalid wallsampler value";
           }
       }
 
       CASE("nosanity")
-      if (value != NULL) {
-        switch (value[0]) {
-        case 'n': // no
-        case 'f': // false
-        case '0': // 0
-          _skip_sanity_checks = false;
-          break;
-        default:
-          _skip_sanity_checks = true;
-        }
-      } else {
-        // A bare 'nosanity' with no value skips the checks.
-        _skip_sanity_checks = true;
+      // A bare 'nosanity' with no value skips the checks.
+      if (!parseBoolOption(value, _skip_sanity_checks)) {
+        msg = "Invalid nosanity value";
       }
 
       CASE("nativemem")
@@ -474,18 +448,9 @@ Error Arguments::parse(const char *args) {
         if (config) {
           *(config++) = 0;
         }
-        if (value != NULL) {
-          switch (value[0]) {
-          case 'n': // no
-          case 'f': // false
-          case '0': // 0
-            _reference_chains = false;
-            break;
-          default:
-            _reference_chains = true;
-          }
-        } else {
-          _reference_chains = true;
+        // A bare 'referencechains' with no value means enable.
+        if (!parseBoolOption(value, _reference_chains)) {
+          msg = "Invalid referencechains value";
         }
         char *cursor = config;
         while (cursor != NULL) {
@@ -528,15 +493,18 @@ Error Arguments::parse(const char *args) {
               _reference_chains_first_pass_budget = std::min(
                   std::max(atoi(eq), 0), MAX_REFERENCE_CHAINS_FIRST_PASS_BUDGET);
               _reference_chains_tuned_mask |= REF_CHAINS_TUNED_FIRST_PASS_BUDGET;
+            } else {
+              _unknown_args.push_back(cursor);
             }
+          } else if (*cursor != 0) {
+            _unknown_args.push_back(cursor);
           }
           cursor = next;
         }
       }
 
       DEFAULT()
-      if (_unknown_arg == NULL)
-        _unknown_arg = arg;
+      _unknown_args.push_back(arg);
     }
   }
 
diff --git a/ddprof-lib/src/main/cpp/arguments.h b/ddprof-lib/src/main/cpp/arguments.h
index 54943b348b..d6222f9157 100644
--- a/ddprof-lib/src/main/cpp/arguments.h
+++ b/ddprof-lib/src/main/cpp/arguments.h
@@ -201,9 +201,9 @@ class Error {
 
   explicit Error(const char *message) : _message(message) {}
 
-  const char *message() { return _message; }
+  const char *message() const { return _message; }
 
-  operator bool() { return _message != NULL; }
+  operator bool() const { return _message != NULL; }
 };
 
 class Arguments {
@@ -260,7 +260,7 @@ class Arguments {
   const char* _file;
   const char* _log;
   const char* _loglevel;
-  const char* _unknown_arg;
+  std::vector<std::string> _unknown_args;
   const char* _filter;
   CStack _cstack;
   Clock _clock;
@@ -311,7 +311,7 @@ class Arguments {
         _file(NULL),
         _log(NULL),
         _loglevel(NULL),
-        _unknown_arg(NULL),
+        _unknown_args({}),
         _filter(NULL),
         _cstack(CSTACK_DEFAULT),
         _clock(CLK_DEFAULT),
diff --git a/ddprof-lib/src/main/cpp/javaApi.cpp b/ddprof-lib/src/main/cpp/javaApi.cpp
index 5b007ad5e1..90f6696755 100644
--- a/ddprof-lib/src/main/cpp/javaApi.cpp
+++ b/ddprof-lib/src/main/cpp/javaApi.cpp
@@ -115,13 +115,13 @@ Java_com_datadoghq_profiler_JavaProfiler_execute0(JNIEnv *env, jobject unused,
   JniString command_str(env, command);
   Error error = args.parse(command_str.c_str());
 
+  Log::open(args);
+
   if (error) {
     throwNew(env, "java/lang/IllegalArgumentException", error.message());
     return NULL;
   }
 
-  Log::open(args);
-
   std::ostringstream out;
 
   // Attach ProfiledThread
diff --git a/ddprof-lib/src/main/cpp/log.cpp b/ddprof-lib/src/main/cpp/log.cpp
index 14fd1c250c..c10a748c23 100644
--- a/ddprof-lib/src/main/cpp/log.cpp
+++ b/ddprof-lib/src/main/cpp/log.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright 2021 Andrei Pangin
+ * Copyright 2026, Datadog, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,12 +28,20 @@ LogLevel Log::_level = LOG_NONE;
 void Log::open(Arguments &args) {
   open(args._log, args._loglevel);
 
-  if (args._unknown_arg != NULL) {
-    warn("Unknown argument: %s", args._unknown_arg);
+  for (const std::string &arg : args._unknown_args) {
+    warn("Unknown argument: %s", arg.c_str());
   }
 }
 
 void Log::open(const char *file_name, const char *level) {
+  if (file_name == NULL && level == NULL) {
+    // Nothing to reconfigure. In particular, this keeps a rejected execute0()
+    // command (which parses to _log == NULL, _loglevel == NULL when the
+    // caller didn't ask to change logging) from resetting an active custom
+    // log file back to stdout/LOG_NONE before the parse error is thrown.
+    return;
+  }
+
   if (_file != stdout && _file != stderr) {
     fclose(_file);
   }
diff --git a/ddprof-lib/src/test/cpp/arguments_ut.cpp b/ddprof-lib/src/test/cpp/arguments_ut.cpp
index 5ae29bfcaa..8ecefc13fc 100644
--- a/ddprof-lib/src/test/cpp/arguments_ut.cpp
+++ b/ddprof-lib/src/test/cpp/arguments_ut.cpp
@@ -49,3 +49,207 @@ TEST_F(ArgumentsTest, HopsBudgetFrameCapStillFlooredAtOne) {
     EXPECT_EQ(args._reference_chains_budget, 1);
     EXPECT_EQ(args._reference_chains_frontier_cap, 1);
 }
+
+// An unrecognized top-level token must not be dropped silently: every unmatched
+// token has to end up in _unknown_args, not just the first one.
+TEST_F(ArgumentsTest, UnknownTopLevelArgsAreAllCaptured) {
+    Arguments args;
+    Error error = args.parse("start,foo=1,bar=2");
+    EXPECT_FALSE(error);
+    ASSERT_EQ(args._unknown_args.size(), 2u);
+    EXPECT_EQ(args._unknown_args[0], "foo");
+    EXPECT_EQ(args._unknown_args[1], "bar");
+}
+
+// referencechains sub-options are parsed by their own colon-delimited loop,
+// separate from the outer comma-token switch - an unmatched sub-key must still
+// surface through the same _unknown_args reporting path instead of vanishing.
+TEST_F(ArgumentsTest, UnknownReferenceChainsSubOptionIsCaptured) {
+    Arguments args;
+    Error error = args.parse("referencechains=true:budgt=500");
+    EXPECT_FALSE(error);
+    ASSERT_EQ(args._unknown_args.size(), 1u);
+    EXPECT_EQ(args._unknown_args[0], "budgt");
+    // The typo must not silently apply as if it were "budget".
+    EXPECT_EQ(args._reference_chains_budget, DEFAULT_REFERENCE_CHAINS_BUDGET);
+}
+
+// A referencechains sub-token with no '=' at all (e.g. a stray colon) must also
+// be reported rather than silently skipped.
+TEST_F(ArgumentsTest, ReferenceChainsSubOptionWithoutEqualsIsCaptured) {
+    Arguments args;
+    Error error = args.parse("referencechains=true:hops=10:bogus");
+    EXPECT_FALSE(error);
+    ASSERT_EQ(args._unknown_args.size(), 1u);
+    EXPECT_EQ(args._unknown_args[0], "bogus");
+    EXPECT_EQ(args._reference_chains_hop_cap, 10);
+}
+
+TEST_F(ArgumentsTest, InvalidCstackValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("cstack=dwrf");
+    EXPECT_TRUE(error);
+}
+
+// "no" is a documented cstack value distinct from a typo and must keep working.
+TEST_F(ArgumentsTest, CstackNoIsStillValid) {
+    Arguments args;
+    Error error = args.parse("cstack=no");
+    EXPECT_FALSE(error);
+    EXPECT_EQ(args._cstack, CSTACK_NO);
+}
+
+TEST_F(ArgumentsTest, InvalidWallsamplerValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("wallsampler=x");
+    EXPECT_TRUE(error);
+}
+
+// wallsampler used to switch on value[0] alone, so any value starting with 'j' or
+// 'a' was silently accepted - a typo like "junk" or "anything" must now be rejected.
+TEST_F(ArgumentsTest, InvalidWallsamplerJTypoIsAnError) {
+    Arguments args;
+    Error error = args.parse("wallsampler=junk");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, InvalidWallsamplerATypoIsAnError) {
+    Arguments args;
+    Error error = args.parse("wallsampler=anything");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, WallsamplerValidValuesStillWork) {
+    Arguments args;
+    Error error = args.parse("wallsampler=jvmti");
+    EXPECT_FALSE(error);
+    EXPECT_EQ(args._wallclock_sampler, JVMTI);
+
+    Arguments args2;
+    error = args2.parse("wallsampler=asgct");
+    EXPECT_FALSE(error);
+    EXPECT_EQ(args2._wallclock_sampler, ASGCT);
+}
+
+// mcleanup previously grouped its `default:` case with the "true" branch, so a
+// typo silently enabled the feature instead of erroring.
+TEST_F(ArgumentsTest, InvalidMcleanupValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("mcleanup=xyz");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, InvalidRemotesymValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("remotesym=xyz");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, InvalidNosanityValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("nosanity=xyz");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, InvalidJvmtistacksValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("jvmtistacks=xyz");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, InvalidLightweightValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("lightweight=xyz");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, InvalidReferenceChainsBooleanValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("referencechains=xyz");
+    EXPECT_TRUE(error);
+}
+
+// A bare 'referencechains' with no '=' at all must still enable the feature - the
+// parseBoolOption rewrite must not turn the no-value case into a silent no-op.
+TEST_F(ArgumentsTest, BareReferenceChainsEnablesFeature) {
+    Arguments args;
+    Error error = args.parse("referencechains");
+    EXPECT_FALSE(error);
+    EXPECT_TRUE(args._reference_chains);
+}
+
+// Sub-options only attach after an explicit boolean ("referencechains=true:hops=10").
+// A bare "referencechains:hops=10" has no '=' right after the option name, so the
+// top-level arg/value split (which cuts at the *first* '=' in the whole token) lands
+// on the one inside "hops=10" instead - the resulting token "referencechains:hops"
+// doesn't match the CASE at all and must be captured as unknown rather than silently
+// misparsed as if hops=10 had been applied.
+TEST_F(ArgumentsTest, ReferenceChainsSubOptionsWithoutBooleanIsUnknown) {
+    Arguments args;
+    Error error = args.parse("referencechains:hops=10");
+    EXPECT_FALSE(error);
+    EXPECT_FALSE(args._reference_chains);
+    EXPECT_EQ(args._reference_chains_hop_cap, DEFAULT_REFERENCE_CHAINS_HOP_CAP);
+    ASSERT_EQ(args._unknown_args.size(), 1u);
+    EXPECT_EQ(args._unknown_args[0], "referencechains:hops");
+}
+
+TEST_F(ArgumentsTest, InvalidGenerationsValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("generations=xyz");
+    EXPECT_TRUE(error);
+}
+
+TEST_F(ArgumentsTest, GenerationsTrueAndFalseStillWork) {
+    Arguments args;
+    Error error = args.parse("generations=true");
+    EXPECT_FALSE(error);
+    EXPECT_TRUE(args._gc_generations);
+
+    Arguments args2;
+    error = args2.parse("generations=false");
+    EXPECT_FALSE(error);
+    EXPECT_FALSE(args2._gc_generations);
+}
+
+// generations used to accept only the literal strings "true"/"false", unlike every
+// other boolean option in this file - a user had no way to know that from the command
+// string alone. It now goes through the same parseBoolOption convention as the rest.
+TEST_F(ArgumentsTest, GenerationsAcceptsSharedBooleanConvention) {
+    Arguments args;
+    Error error = args.parse("generations=1,memory=128");
+    EXPECT_FALSE(error);
+    EXPECT_TRUE(args._gc_generations);
+
+    Arguments args2;
+    error = args2.parse("generations=no,memory=128");
+    EXPECT_FALSE(error);
+    EXPECT_FALSE(args2._gc_generations);
+}
+
+// The established yes/no spelling (LightweightContextCpuTest.java, remoteargs_ut.cpp,
+// wallprecheck_args_ut.cpp, SanityChecks.md) must keep working through the shared
+// parseBoolOption helper.
+TEST_F(ArgumentsTest, YesNoSpellingStillAccepted) {
+    Arguments args;
+    Error error = args.parse("lightweight=yes,remotesym=no");
+    EXPECT_FALSE(error);
+    EXPECT_TRUE(args._lightweight);
+    EXPECT_FALSE(args._remote_symbolication);
+}
+
+// A typo that merely starts with a valid boolean letter (e.g. "tweq" starts with
+// 't', "fjdw" starts with 'f') must still be rejected - parseBoolOption matches the
+// whole value, not just value[0], otherwise these bugs would remain silent.
+TEST_F(ArgumentsTest, BooleanOptionRejectsTypoSharingFirstLetterWithValidValue) {
+    {
+        Arguments args;
+        Error error = args.parse("mcleanup=tweq");
+        EXPECT_TRUE(error);
+    }
+    {
+        Arguments args;
+        Error error = args.parse("mcleanup=fjdw");
+        EXPECT_TRUE(error);
+    }
+}
diff --git a/ddprof-lib/src/test/cpp/log_ut.cpp b/ddprof-lib/src/test/cpp/log_ut.cpp
new file mode 100644
index 0000000000..21267e610e
--- /dev/null
+++ b/ddprof-lib/src/test/cpp/log_ut.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2026, Datadog, Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <gtest/gtest.h>
+#include <cstdio>
+#include <cstdlib>
+#include <unistd.h>
+#include <string>
+#include "log.h"
+#include "../../main/cpp/gtest_crash_handler.h"
+
+static constexpr char LOG_TEST_NAME[] = "LogTest";
+
+class LogGlobalSetup {
+public:
+    LogGlobalSetup() {
+        installGtestCrashHandler<LOG_TEST_NAME>();
+    }
+    ~LogGlobalSetup() {
+        restoreDefaultSignalHandlers();
+    }
+};
+
+static LogGlobalSetup global_setup;
+
+static std::string readFile(const char *path) {
+    FILE *f = fopen(path, "r");
+    if (f == nullptr) {
+        return "";
+    }
+    std::string contents;
+    char buf[256];
+    size_t n;
+    while ((n = fread(buf, 1, sizeof(buf), f)) > 0) {
+        contents.append(buf, n);
+    }
+    fclose(f);
+    return contents;
+}
+
+// Log::open(NULL, NULL) is what a rejected execute0() command triggers when the
+// command itself didn't specify log=/loglevel=. It must not clobber an already
+// active custom log file - see javaApi.cpp's execute0 and log.cpp's Log::open.
+TEST(LogTest, OpenWithBothNullDoesNotResetActiveLog) {
+    char path[] = "/tmp/ddprof_log_ut_XXXXXX";
+    int fd = mkstemp(path);
+    ASSERT_GE(fd, 0);
+    close(fd);
+
+    Log::open(path, "DEBUG");
+    Log::error("marker-before");
+
+    Log::open(NULL, NULL);
+    Log::error("marker-after");
+
+    std::string contents = readFile(path);
+    EXPECT_NE(contents.find("marker-before"), std::string::npos);
+    EXPECT_NE(contents.find("marker-after"), std::string::npos);
+
+    // Restore process-wide defaults before other gtest cases in this binary run.
+    Log::open(NULL, "NONE");
+    unlink(path);
+}
diff --git a/ddprof-lib/src/test/cpp/remoteargs_ut.cpp b/ddprof-lib/src/test/cpp/remoteargs_ut.cpp
index 4286cf9a2b..72ed92c034 100644
--- a/ddprof-lib/src/test/cpp/remoteargs_ut.cpp
+++ b/ddprof-lib/src/test/cpp/remoteargs_ut.cpp
@@ -129,8 +129,8 @@ TEST_F(RemoteArgsTest, RemoteSymbolicationNoVariant) {
 TEST_F(RemoteArgsTest, RemoteSymbolicationInvalidValue) {
     Arguments args;
 
-    // Test invalid value that starts with unrecognized char (should enable due to default)
+    // An unrecognized value must be a hard parse error, not silently coerced to
+    // enabled - a typo here used to silently enable remote symbolication.
     Error error = args.parse("remotesym=invalid");
-    EXPECT_FALSE(error);
-    EXPECT_TRUE(args._remote_symbolication);
+    EXPECT_TRUE(error);
 }
\ No newline at end of file
diff --git a/ddprof-lib/src/test/cpp/wallprecheck_args_ut.cpp b/ddprof-lib/src/test/cpp/wallprecheck_args_ut.cpp
index 5579e354fe..ebde382e01 100644
--- a/ddprof-lib/src/test/cpp/wallprecheck_args_ut.cpp
+++ b/ddprof-lib/src/test/cpp/wallprecheck_args_ut.cpp
@@ -41,14 +41,26 @@ TEST(WallPrecheckArgsTest, ExplicitBooleanValues) {
     EXPECT_FALSE(args._wall_precheck);
 }
 
-TEST(WallPrecheckArgsTest, UnknownValueTreatedAsTrue) {
-    // Any value that is not "false" or "0" enables the precheck (strcmp semantics).
+TEST(WallPrecheckArgsTest, YesNoSpellingStillWorks) {
+    // "yes" is a documented boolean spelling (parseBoolOption), not merely
+    // "anything that isn't false/0" - see InvalidValueIsAnError below for the
+    // typo case this distinction matters for.
     Arguments args;
     Error error = args.parse("wallprecheck=yes");
     EXPECT_FALSE(error);
     EXPECT_TRUE(args._wall_precheck);
 }
 
+// wallprecheck used to accept any value other than the literal "false"/"0" via a
+// raw strcmp, so a typo like "flase" silently enabled it instead of erroring - it
+// now goes through the shared parseBoolOption convention like every other boolean
+// option in this file.
+TEST(WallPrecheckArgsTest, InvalidValueIsAnError) {
+    Arguments args;
+    Error error = args.parse("wallprecheck=flase");
+    EXPECT_TRUE(error);
+}
+
 TEST(WallPrecheckArgsTest, EnabledWithinLongerArgString) {
     Arguments args;
     Error error = args.parse("wall=1ms,wallprecheck=true");
diff --git a/doc/architecture/SanityChecks.md b/doc/architecture/SanityChecks.md
index 3adfdf3355..e804054eec 100644
--- a/doc/architecture/SanityChecks.md
+++ b/doc/architecture/SanityChecks.md
@@ -96,14 +96,8 @@ disables both checks. Parsed in `Arguments::parse()`
 ```cpp
 CASE("nosanity")
 if (value != NULL) {
-  switch (value[0]) {
-  case 'n': // no
-  case 'f': // false
-  case '0': // 0
-    _skip_sanity_checks = false;
-    break;
-  default:
-    _skip_sanity_checks = true;
+  if (!parseBoolOption(value, &_skip_sanity_checks)) {
+    msg = "Invalid nosanity value";
   }
 } else {
   // bare 'nosanity' with no value means skip checks
@@ -111,9 +105,11 @@ if (value != NULL) {
 }
 ```
 
-A bare `nosanity` keyword, or any value not starting with `n`/`f`/`0`
-(e.g. `true`, `yes`, `1`), skips the checks; `nosanity=no`, `nosanity=false`,
-`nosanity=0` explicitly keep them enabled.
+A bare `nosanity` keyword, or an explicit `nosanity=true`/`yes`/`1`/`t`/`y`, skips the
+checks; `nosanity=no`/`false`/`0`/`f`/`n` explicitly keep them enabled. Any other value
+(e.g. a typo like `nosanity=tru`) is a hard parse error instead of being silently
+coerced to one or the other -- `parseBoolOption` (`arguments.cpp`) matches the whole
+value against these known spellings, not just its first character.
 
 ---