feat(vxcore): make month/day snippet names follow an app-set locale

The built-in %MMM%/%MMMM%/%ddd%/%dddd% snippets resolved day and month
names through std::strftime, i.e. the process-wide C runtime LC_TIME.
That is the wrong source of truth (it tracks the OS locale, not the
embedder's language setting) and, on Windows with a non-C LC_TIME, it
emits ANSI code page bytes that become mojibake once they cross the C
ABI into a UTF-8-decoding consumer.

Add locale-independent UTF-8 name tables (en, zh_CN, ja) in
core/datetime_names, a runtime-only context locale
(vxcore_context_set_locale / _get_locale, purely additive ABI), and have
the four callbacks read the table at call time. English is the
deterministic default, so the CLI, tests and other embedders no longer
depend on the host locale. Non-ASCII entries use explicit UTF-8 byte
escapes because the production target is not built with /utf-8.

SnippetManager's copy and move operations are deleted: the dynamic
callbacks now capture this.

Author: tamlok

AGENTS.md

@@ -577,6 +577,31 @@ VXCORE_LOG_INFO("Opening notebook: %s", path.c_str());
 VXCORE_LOG_ERROR("Failed to open database: %s", db_path.c_str());
 ```
 
+### Context locale
+
+`vxcore_context_set_locale(ctx, "zh_CN")` / `vxcore_context_get_locale(ctx, &out)` set the
+app-wide locale used for locale-aware, UTF-8 output. Today the only consumer is
+`SnippetManager`'s built-in `%MMM%` / `%MMMM%` / `%ddd%` / `%dddd%` snippets.
+
+- **Runtime-only.** The locale is consumer *policy* pushed in at startup; it is NEVER written
+  to `vxcore.json`. (VNote pushes `QLocale().name()` right after `loadTranslators`.)
+- **English is the deterministic default.** A context that is never told a locale resolves
+  through the English table — output does not depend on the host OS locale, so the CLI, tests
+  and other embedders are reproducible.
+- **Month/day names never come from `strftime` / `setlocale`.** They come from the
+  statically-compiled UTF-8 tables in `src/core/datetime_names.{h,cpp}`. `strftime` would
+  return ANSI-code-page bytes on Windows, which become mojibake once they cross the C ABI
+  into a UTF-8-decoding consumer. Do not reintroduce a `strftime`-based helper.
+- **Non-ASCII table entries are written as explicit UTF-8 byte escapes** (`"\xE5\x9B\x9B..."`).
+  The production `vxcore` target does not get MSVC's `/utf-8`, so a raw CJK literal would be
+  re-encoded with the active ANSI code page. Do not "clean them up".
+- **Adding a locale** means adding a table entry in `datetime_names.cpp` plus a
+  `CanonicalizeLocale` mapping — nothing else. Matching is: normalize `-`→`_`, lowercase,
+  exact match, then language subtag, else English.
+- `SnippetManager` is not thread-safe; `SetLocale` inherits that. Set it before use, from the
+  thread that applies snippets. Its copy/move operations are deleted because the built-in
+  dynamic callbacks capture `this`.
+
 ## Common Patterns
 
 ### Adding a New C API Function

include/vxcore/vxcore.h

@@ -28,6 +28,16 @@ VXCORE_API VxCoreError vxcore_context_create(const char *config_json,
 
 VXCORE_API void vxcore_context_destroy(VxCoreContextHandle context);
 
+// Set the app-wide locale used for locale-aware, UTF-8 output (currently the
+// built-in %MMM%/%MMMM%/%ddd%/%dddd% snippets). |locale| is a Qt/POSIX-style name
+// such as "en_US", "zh_CN", "ja". Unknown or NULL/empty resolves to English.
+// Runtime-only: NOT persisted to vxcore.json. Not thread-safe; call before use.
+VXCORE_API VxCoreError vxcore_context_set_locale(VxCoreContextHandle context,
+                                                 const char *locale);
+
+// Out: canonical locale name ("en" | "zh_CN" | "ja"). Free with vxcore_string_free.
+VXCORE_API VxCoreError vxcore_context_get_locale(VxCoreContextHandle context, char **out_locale);
+
 // Snapshot current session state (buffers, workspaces) to disk.
 // Sets the shutdown_called flag, preventing destructor double-saves.
 // Idempotent: no-op if already called.

src/CMakeLists.txt

@@ -47,6 +47,7 @@ set(VXCORE_SOURCES
     core/raw_folder_manager.cpp
     core/template_manager.cpp
     core/snippet_manager.cpp
+    core/datetime_names.cpp
     core/work_queue.cpp
     core/event_manager.cpp
     core/activity_manager.cpp

src/api/vxcore_api.cpp

@@ -5,6 +5,7 @@
 #include "core/buffer_manager.h"
 #include "core/config_manager.h"
 #include "core/context.h"
+#include "core/datetime_names.h"
 #include "core/event_manager.h"
 #include "core/notebook_manager.h"
 #include "core/snippet_manager.h"
@@ -277,6 +278,46 @@ VXCORE_API VxCoreError vxcore_context_get_last_error(VxCoreContextHandle context
   return VXCORE_OK;
 }
 
+VXCORE_API VxCoreError vxcore_context_set_locale(VxCoreContextHandle context,
+                                                 const char *locale) {
+  if (!context) {
+    return VXCORE_ERR_NULL_POINTER;
+  }
+
+  auto *ctx = reinterpret_cast<vxcore::VxCoreContext *>(context);
+  try {
+    // NULL/empty is valid and means English.
+    ctx->locale = vxcore::CanonicalizeLocale(locale ? std::string(locale) : std::string());
+    if (ctx->snippet_manager) {
+      ctx->snippet_manager->SetLocale(ctx->locale);
+    }
+    return VXCORE_OK;
+  } catch (const std::exception &e) {
+    VXCORE_LOG_ERROR("vxcore_context_set_locale failed: %s", e.what());
+    return VXCORE_ERR_UNKNOWN;
+  }
+}
+
+VXCORE_API VxCoreError vxcore_context_get_locale(VxCoreContextHandle context, char **out_locale) {
+  if (!context || !out_locale) {
+    return VXCORE_ERR_NULL_POINTER;
+  }
+
+  *out_locale = nullptr;
+
+  auto *ctx = reinterpret_cast<vxcore::VxCoreContext *>(context);
+  try {
+    *out_locale = vxcore_strdup(ctx->locale.c_str());
+    if (!*out_locale) {
+      return VXCORE_ERR_OUT_OF_MEMORY;
+    }
+    return VXCORE_OK;
+  } catch (const std::exception &e) {
+    VXCORE_LOG_ERROR("vxcore_context_get_locale failed: %s", e.what());
+    return VXCORE_ERR_UNKNOWN;
+  }
+}
+
 VXCORE_API VxCoreError vxcore_context_get_data_path(VxCoreContextHandle context,
                                                     VxCoreDataLocation location, char **out_path) {
   if (!context || !out_path) {

src/core/context.h

@@ -37,6 +37,9 @@ struct VxCoreContext {
   // be alive at that point.
   std::unique_ptr<ActivityManager> activity_manager;
   std::string last_error;
+  // App-wide locale used for locale-aware, UTF-8 output (see
+  // vxcore_context_set_locale). Runtime-only: never persisted to vxcore.json.
+  std::string locale = "en";
   bool shutdown_called = false;
 };
 

src/core/datetime_names.cpp

@@ -0,0 +1,155 @@
+#include "core/datetime_names.h"
+
+#include <cctype>
+
+namespace vxcore {
+
+// NOTE: every non-ASCII entry below is written as explicit UTF-8 byte escapes.
+// The production `vxcore` target is NOT compiled with MSVC's /utf-8 flag (that
+// flag is applied directory-wide only under libs/vxcore/tests), so a raw CJK
+// literal here would be re-encoded using the active ANSI code page in the DLL
+// while the direct-compiled test copy compiled correctly. The escapes remove
+// the source-encoding dependence entirely. Do NOT "clean them up" into raw
+// literals, and keep the comments in this file ASCII-only.
+namespace {
+
+// ---------------------------------------------------------------------------
+// English
+// ---------------------------------------------------------------------------
+const char *const kEnShortMonths[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                                        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+const char *const kEnLongMonths[12] = {"January",   "February", "March",    "April",
+                                       "May",       "June",     "July",     "August",
+                                       "September", "October",  "November", "December"};
+const char *const kEnShortDays[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+const char *const kEnLongDays[7] = {"Sunday",   "Monday", "Tuesday", "Wednesday",
+                                    "Thursday", "Friday", "Saturday"};
+
+// ---------------------------------------------------------------------------
+// Shared CJK building blocks (UTF-8 byte escapes).
+// ---------------------------------------------------------------------------
+#define VX_YUE "\xE6\x9C\x88"   // U+6708 month
+#define VX_ZHOU "\xE5\x91\xA8"  // U+5468 week (zh abbreviated day prefix)
+#define VX_XING "\xE6\x98\x9F"  // U+661F
+#define VX_QI "\xE6\x9C\x9F"    // U+671F
+#define VX_YAO "\xE6\x9B\x9C"   // U+66DC (ja day-of-week marker)
+
+#define VX_RI "\xE6\x97\xA5"     // U+65E5 sun/day
+#define VX_YUE_MOON "\xE6\x9C\x88"  // U+6708 moon (same glyph as month)
+#define VX_HUO "\xE7\x81\xAB"    // U+706B fire
+#define VX_SHUI "\xE6\xB0\xB4"   // U+6C34 water
+#define VX_MU "\xE6\x9C\xA8"     // U+6728 wood
+#define VX_JIN "\xE9\x87\x91"    // U+91D1 metal
+#define VX_TU "\xE5\x9C\x9F"     // U+571F earth
+
+#define VX_YI "\xE4\xB8\x80"    // U+4E00 one
+#define VX_ER "\xE4\xBA\x8C"    // U+4E8C two
+#define VX_SAN "\xE4\xB8\x89"   // U+4E09 three
+#define VX_SI "\xE5\x9B\x9B"    // U+56DB four
+#define VX_WU "\xE4\xBA\x94"    // U+4E94 five
+#define VX_LIU "\xE5\x85\xAD"   // U+516D six
+#define VX_QId "\xE4\xB8\x83"   // U+4E03 seven
+#define VX_BA "\xE5\x85\xAB"    // U+516B eight
+#define VX_JIU "\xE4\xB9\x9D"   // U+4E5D nine
+#define VX_SHI "\xE5\x8D\x81"   // U+5341 ten
+
+// ---------------------------------------------------------------------------
+// Simplified Chinese (zh_CN)
+// ---------------------------------------------------------------------------
+const char *const kZhShortMonths[12] = {
+    "1" VX_YUE, "2" VX_YUE,  "3" VX_YUE,  "4" VX_YUE,  "5" VX_YUE,  "6" VX_YUE,
+    "7" VX_YUE, "8" VX_YUE,  "9" VX_YUE,  "10" VX_YUE, "11" VX_YUE, "12" VX_YUE};
+const char *const kZhLongMonths[12] = {
+    VX_YI VX_YUE,          VX_ER VX_YUE,         VX_SAN VX_YUE,        VX_SI VX_YUE,
+    VX_WU VX_YUE,          VX_LIU VX_YUE,        VX_QId VX_YUE,        VX_BA VX_YUE,
+    VX_JIU VX_YUE,         VX_SHI VX_YUE,        VX_SHI VX_YI VX_YUE,  VX_SHI VX_ER VX_YUE};
+const char *const kZhShortDays[7] = {VX_ZHOU VX_RI,  VX_ZHOU VX_YI,  VX_ZHOU VX_ER,
+                                     VX_ZHOU VX_SAN, VX_ZHOU VX_SI,  VX_ZHOU VX_WU,
+                                     VX_ZHOU VX_LIU};
+const char *const kZhLongDays[7] = {
+    VX_XING VX_QI VX_RI,  VX_XING VX_QI VX_YI, VX_XING VX_QI VX_ER, VX_XING VX_QI VX_SAN,
+    VX_XING VX_QI VX_SI,  VX_XING VX_QI VX_WU, VX_XING VX_QI VX_LIU};
+
+// ---------------------------------------------------------------------------
+// Japanese (ja)
+// ---------------------------------------------------------------------------
+const char *const kJaShortMonths[12] = {
+    "1" VX_YUE, "2" VX_YUE, "3" VX_YUE,  "4" VX_YUE,  "5" VX_YUE,  "6" VX_YUE,
+    "7" VX_YUE, "8" VX_YUE, "9" VX_YUE,  "10" VX_YUE, "11" VX_YUE, "12" VX_YUE};
+const char *const *const kJaLongMonths = kJaShortMonths;
+const char *const kJaShortDays[7] = {VX_RI,  VX_YUE_MOON, VX_HUO, VX_SHUI,
+                                     VX_MU,  VX_JIN,      VX_TU};
+const char *const kJaLongDays[7] = {
+    VX_RI VX_YAO VX_RI,  VX_YUE_MOON VX_YAO VX_RI, VX_HUO VX_YAO VX_RI, VX_SHUI VX_YAO VX_RI,
+    VX_MU VX_YAO VX_RI,  VX_JIN VX_YAO VX_RI,      VX_TU VX_YAO VX_RI};
+
+std::string NormalizeLocale(const std::string &locale) {
+  std::string s;
+  s.reserve(locale.size());
+  for (char c : locale) {
+    if (c == '-') {
+      s.push_back('_');
+    } else {
+      s.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
+    }
+  }
+  return s;
+}
+
+}  // namespace
+
+std::string CanonicalizeLocale(const std::string &locale) {
+  const std::string s = NormalizeLocale(locale);
+  if (s.empty()) {
+    return "en";
+  }
+
+  // Exact match on the canonical names first.
+  if (s == "en") return "en";
+  if (s == "zh_cn") return "zh_CN";
+  if (s == "ja") return "ja";
+
+  // Language subtag match.
+  const std::string lang = s.substr(0, s.find('_'));
+  if (lang == "zh") return "zh_CN";
+  if (lang == "ja") return "ja";
+  if (lang == "en") return "en";
+
+  return "en";
+}
+
+const DateTimeNames &DateTimeNames::ForLocale(const std::string &locale) {
+  static const DateTimeNames kEn("en", kEnShortMonths, kEnLongMonths, kEnShortDays, kEnLongDays);
+  static const DateTimeNames kZh("zh_CN", kZhShortMonths, kZhLongMonths, kZhShortDays,
+                                 kZhLongDays);
+  static const DateTimeNames kJa("ja", kJaShortMonths, kJaLongMonths, kJaShortDays, kJaLongDays);
+
+  const std::string canonical = CanonicalizeLocale(locale);
+  if (canonical == "zh_CN") return kZh;
+  if (canonical == "ja") return kJa;
+  return kEn;
+}
+
+const char *DateTimeNames::ShortMonth(int tm_mon) const {
+  if (tm_mon < 0 || tm_mon > 11) tm_mon = 0;
+  return short_months_[tm_mon];
+}
+
+const char *DateTimeNames::LongMonth(int tm_mon) const {
+  if (tm_mon < 0 || tm_mon > 11) tm_mon = 0;
+  return long_months_[tm_mon];
+}
+
+const char *DateTimeNames::ShortDay(int tm_wday) const {
+  if (tm_wday < 0 || tm_wday > 6) tm_wday = 0;
+  return short_days_[tm_wday];
+}
+
+const char *DateTimeNames::LongDay(int tm_wday) const {
+  if (tm_wday < 0 || tm_wday > 6) tm_wday = 0;
+  return long_days_[tm_wday];
+}
+
+const char *DateTimeNames::CanonicalName() const { return canonical_name_; }
+
+}  // namespace vxcore

src/core/datetime_names.h

@@ -0,0 +1,51 @@
+#ifndef VXCORE_DATETIME_NAMES_H
+#define VXCORE_DATETIME_NAMES_H
+
+#include <string>
+
+namespace vxcore {
+
+// UTF-8 month/day names for a supported locale. Immutable, statically allocated.
+//
+// The tables are locale-independent data compiled into the library: they never
+// consult the C runtime locale (`setlocale`/`LC_TIME`) or `strftime`, so the
+// bytes returned are always valid UTF-8 regardless of the host locale or the
+// Windows ANSI code page.
+class DateTimeNames {
+ public:
+  // |locale| accepts "en", "en_US", "zh_CN", "zh-CN", "ja_JP" (case-insensitive,
+  // '-' normalized to '_'). Exact match, then language subtag, else English.
+  // Never returns null. The returned object is statically allocated and
+  // immutable; there is no global mutable state, so this is safe to call from
+  // any thread.
+  static const DateTimeNames &ForLocale(const std::string &locale);
+
+  const char *ShortMonth(int tm_mon) const;  // 0..11, out of range -> January
+  const char *LongMonth(int tm_mon) const;
+  const char *ShortDay(int tm_wday) const;  // 0..6, 0 = Sunday, out of range -> Sunday
+  const char *LongDay(int tm_wday) const;
+  const char *CanonicalName() const;  // "en" | "zh_CN" | "ja"
+
+ private:
+  DateTimeNames(const char *canonical_name, const char *const *short_months,
+                const char *const *long_months, const char *const *short_days,
+                const char *const *long_days)
+      : canonical_name_(canonical_name),
+        short_months_(short_months),
+        long_months_(long_months),
+        short_days_(short_days),
+        long_days_(long_days) {}
+
+  const char *canonical_name_ = "en";
+  const char *const *short_months_ = nullptr;
+  const char *const *long_months_ = nullptr;
+  const char *const *short_days_ = nullptr;
+  const char *const *long_days_ = nullptr;
+};
+
+// Canonical name a locale string resolves to; "" and unknown -> "en".
+std::string CanonicalizeLocale(const std::string &locale);
+
+}  // namespace vxcore
+
+#endif  // VXCORE_DATETIME_NAMES_H