@@ -391,6 +391,7 @@ void cbm_reset_thread_parser(void) {
 
 void cbm_destroy_thread_parser(void) {
     // Full cleanup: delete the parser. Call on worker thread exit.
+    cbm_destroy_thread_kind_cache();
     if (tl_parser) {
         ts_parser_delete(tl_parser);
         tl_parser = NULL;
 
@@ -500,6 +500,13 @@ typedef struct {
 enum { KS_SLOTS = 512, KS_SLOT_MASK = 511, KS_PROBE = 8 };
 static CBM_TLS ks_slot_t ks_cache[KS_SLOTS];
 
+void cbm_destroy_thread_kind_cache(void) {
+    for (int i = 0; i < KS_SLOTS; i++) {
+        free(ks_cache[i].bits);
+        memset(&ks_cache[i], 0, sizeof(ks_cache[i]));
+    }
+}
+
 static ks_slot_t *ks_build(const TSLanguage *lang, const char *const *types, ks_slot_t *s) {
     s->lang = lang;
     s->types = types;
 
@@ -3,6 +3,8 @@
 
 #include "cbm.h"
 
+void cbm_destroy_thread_kind_cache(void);
+
 // Portable memmem: find first occurrence of `needle` (needle_len bytes) within
 // `haystack` (haystack_len bytes). Returns a pointer into haystack, or NULL.
 // Hand-rolled so it compiles identically on all platforms (GNU/BSD-only
 
@@ -16,9 +16,8 @@
 #include "test_framework.h"
 #include "cbm.h"
 #include "grammar_cases.h"
+#include "../src/foundation/compat_thread.h"
 
-#include <pthread.h>
-#include <sched.h>
 #include <stdatomic.h>
 
 static int reg_has_def_any(CBMFileResult *r, const char *name) {
@@ -406,37 +405,48 @@ TEST(grammar_regression_all) {
 }
 
 typedef struct {
-    atomic_int *ready;
+    atomic_bool *go;
     atomic_int *failures;
 } PropertiesParallelArgs;
 
 static void *properties_parallel_worker(void *arg) {
     PropertiesParallelArgs *args = arg;
-    atomic_fetch_add(args->ready, 1);
-    while (atomic_load(args->ready) != 8)
-        sched_yield();
+    while (!atomic_load(args->go)) {}
     for (int i = 0; i < 8; i++) {
         CBMFileResult *r = extract("# generated probe\nalpha=one\nbeta=two\ngamma=three\n",
                                    CBM_LANG_PROPERTIES, "parallel", "probe.properties");
-        if (!r)
+        if (!r) {
+            atomic_fetch_add(args->failures, 1);
+            continue;
+        }
+        if (r->has_error || r->parse_incomplete || !reg_has_def_any(r, "alpha") ||
+            !reg_has_def_any(r, "beta") || !reg_has_def_any(r, "gamma"))
             atomic_fetch_add(args->failures, 1);
         cbm_free_result(r);
     }
+    cbm_destroy_thread_parser();
     return NULL;
 }
 
 TEST(properties_scanner_parallel_extract) {
     enum { WORKERS = 8 };
-    pthread_t threads[WORKERS];
-    atomic_int ready = 0;
+    cbm_thread_t threads[WORKERS];
+    atomic_bool go = false;
     atomic_int failures = 0;
-    PropertiesParallelArgs args = {.ready = &ready, .failures = &failures};
-    for (int i = 0; i < WORKERS; i++)
-        ASSERT_EQ(pthread_create(&threads[i], NULL, properties_parallel_worker, &args), 0);
-    while (atomic_load(&ready) != WORKERS)
-        sched_yield();
-    for (int i = 0; i < WORKERS; i++)
-        ASSERT_EQ(pthread_join(threads[i], NULL), 0);
+    PropertiesParallelArgs args = {.go = &go, .failures = &failures};
+    int started = 0;
+    int create_error = 0;
+    for (; started < WORKERS; started++) {
+        create_error = cbm_thread_create(&threads[started], 0, properties_parallel_worker, &args);
+        if (create_error != 0)
+            break;
+    }
+    atomic_store(&go, true);
+    int join_errors = 0;
+    for (int i = 0; i < started; i++)
+        join_errors += cbm_thread_join(&threads[i]) != 0;
+    ASSERT_EQ(create_error, 0);
+    ASSERT_EQ(join_errors, 0);
     ASSERT_EQ(atomic_load(&failures), 0);
     PASS();
 }