diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index cf7f339..1b71e57 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -446,9 +446,23 @@ status for kernel work.
 ## Code Standards
 
 - **Strict ANSI C99** — No GNU extensions, no C++ features
-- **Zero warnings target** — Build with `-Wall -Werror`; note `-Wmissing-field-initializers`
-  warnings have been observed in `src/test_runner/modules/vocabulary_words_test.c` during a
-  full kernel build — worth reporting if it recurs, not silently patched
+- **Zero warnings target, with four explicit exceptions — corrected 2026-08-18, previous
+  claim was wrong.** Build with `-Wall -Wextra -Werror`, but `Makefile.starkernel` carries
+  `-Wno-error=unused-parameter -Wno-error=shift-negative-value -Wno-error=sign-compare
+  -Wno-error=missing-field-initializers` — those four classes are enabled (still visible as
+  warnings) but deliberately downgraded from fatal, everything else is. The previous version
+  of this line claimed `-Wmissing-field-initializers` was isolated to one file
+  (`vocabulary_words_test.c`) — that was never accurate; a full audit found it systemic
+  across 20 files in `src/test_runner/modules/` (all missing the same later-added
+  `TestCase.contract`/`WordTestSuite.suite_contract` trailing field, ~3,010 instances). Fixed
+  in place across all 20 files (mechanical: added the missing `{0}` initializer, semantically
+  a no-op since C99 already zero-fills unlisted trailing fields — the fix only silences the
+  diagnostic). Verified clean on all three architectures. Remaining, still-open warnings as
+  of the same audit: 26 `-Wunused-parameter` (scattered, several files, not yet fixed), 2
+  `-Wsign-compare` (`control_words_test.c:127`), and 2 `-Wstringop-truncation` in
+  `tools/mkcapsule.c` — that last one is a separate host build tool compiled via plain `cc
+  -Wall -Wextra -O2` (no `-Werror` at all), never actually gated by this policy in the first
+  place, genuinely unfixed rather than exempted.
 - **No hidden state** — All VM state is explicit in the `VM` struct
 - **Platform-agnostic** — Kernel code gated by `__STARKERNEL__` and `STARFORTH_ENABLE_VM`
 - **Content-addressed immutability** — Capsule ID = content hash; any mutation is detectable
diff --git a/capsules/BLOCK_MAP.md b/capsules/BLOCK_MAP.md
index f673cbc..27d6378 100644
--- a/capsules/BLOCK_MAP.md
+++ b/capsules/BLOCK_MAP.md
@@ -1,5 +1,5 @@
 # Capsule Block Manifest — Auto-generated
-<!-- Generated by mkcapsule --manifest  2026-08-19T00:14:53Z -->
+<!-- Generated by mkcapsule --manifest  2026-08-19T01:42:10Z -->
 <!-- DO NOT EDIT — re-run mkcapsule --manifest to refresh.  -->
 <!-- Hand-written justifications and immutability notes live  -->
 <!-- in MANIFEST.md alongside this auto-generated index.      -->
diff --git a/src/test_runner/modules/arithmetic_words_test.c b/src/test_runner/modules/arithmetic_words_test.c
index c550699..34ec090 100644
--- a/src/test_runner/modules/arithmetic_words_test.c
+++ b/src/test_runner/modules/arithmetic_words_test.c
@@ -47,222 +47,222 @@
 static WordTestSuite arithmetic_word_suites[] = {
     {
         "+", {
-            {"basic", "5 7 + . CR", "Should print: 12", TEST_NORMAL, 0, 1},
-            {"zero_add", "42 0 + . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"negative", "-5 3 + . CR", "Should print: -2", TEST_NORMAL, 0, 1},
-            {"both_negative", "-5 -3 + . CR", "Should print: -8", TEST_NORMAL, 0, 1},
-            {"overflow", "2147483647 1 + . CR", "Should overflow", TEST_EDGE_CASE, 0, 1},
-            {"underflow", "-2147483648 -1 + . CR", "Should underflow", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 +", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "5 7 + . CR", "Should print: 12", TEST_NORMAL, 0, 1, {0}},
+            {"zero_add", "42 0 + . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-5 3 + . CR", "Should print: -2", TEST_NORMAL, 0, 1, {0}},
+            {"both_negative", "-5 -3 + . CR", "Should print: -8", TEST_NORMAL, 0, 1, {0}},
+            {"overflow", "2147483647 1 + . CR", "Should overflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"underflow", "-2147483648 -1 + . CR", "Should underflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 +", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "-", {
-            {"basic", "10 3 - . CR", "Should print: 7", TEST_NORMAL, 0, 1},
-            {"zero_sub", "42 0 - . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"from_zero", "0 5 - . CR", "Should print: -5", TEST_NORMAL, 0, 1},
-            {"negative", "5 -3 - . CR", "Should print: 8", TEST_NORMAL, 0, 1},
-            {"same_values", "42 42 - . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"overflow", "-2147483648 1 - . CR", "Should underflow", TEST_EDGE_CASE, 0, 1},
-            {"underflow", "2147483647 -1 - . CR", "Should overflow", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "-", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 -", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "10 3 - . CR", "Should print: 7", TEST_NORMAL, 0, 1, {0}},
+            {"zero_sub", "42 0 - . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"from_zero", "0 5 - . CR", "Should print: -5", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "5 -3 - . CR", "Should print: 8", TEST_NORMAL, 0, 1, {0}},
+            {"same_values", "42 42 - . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"overflow", "-2147483648 1 - . CR", "Should underflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"underflow", "2147483647 -1 - . CR", "Should overflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "-", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 -", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        9
+        9, {0}
     },
 
     {
         "*", {
-            {"basic", "6 7 * . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"by_zero", "42 0 * . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"by_one", "42 1 * . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"by_negative", "6 -7 * . CR", "Should print: -42", TEST_NORMAL, 0, 1},
-            {"negative_negative", "-6 -7 * . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"large_numbers", "32767 2 * . CR", "Should print: 65534", TEST_EDGE_CASE, 0, 1},
-            {"overflow", "65536 65536 * . CR", "May overflow", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "*", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 *", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "6 7 * . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"by_zero", "42 0 * . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "42 1 * . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"by_negative", "6 -7 * . CR", "Should print: -42", TEST_NORMAL, 0, 1, {0}},
+            {"negative_negative", "-6 -7 * . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"large_numbers", "32767 2 * . CR", "Should print: 65534", TEST_EDGE_CASE, 0, 1, {0}},
+            {"overflow", "65536 65536 * . CR", "May overflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "*", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 *", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        9
+        9, {0}
     },
 
     {
         "/", {
-            {"basic", "15 3 / . CR", "Should print: 5", TEST_NORMAL, 0, 1},
-            {"by_one", "42 1 / . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"negative_dividend", "-15 3 / . CR", "Should print: -5", TEST_NORMAL, 0, 1},
-            {"negative_divisor", "15 -3 / . CR", "Should print: -5", TEST_NORMAL, 0, 1},
-            {"both_negative", "-15 -3 / . CR", "Should print: 5", TEST_NORMAL, 0, 1},
-            {"truncation", "7 3 / . CR", "Should print: 2 (truncated)", TEST_NORMAL, 0, 1},
-            {"by_zero", "42 0 /", "Should cause division by zero", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "/", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 /", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "15 3 / . CR", "Should print: 5", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "42 1 / . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative_dividend", "-15 3 / . CR", "Should print: -5", TEST_NORMAL, 0, 1, {0}},
+            {"negative_divisor", "15 -3 / . CR", "Should print: -5", TEST_NORMAL, 0, 1, {0}},
+            {"both_negative", "-15 -3 / . CR", "Should print: 5", TEST_NORMAL, 0, 1, {0}},
+            {"truncation", "7 3 / . CR", "Should print: 2 (truncated)", TEST_NORMAL, 0, 1, {0}},
+            {"by_zero", "42 0 /", "Should cause division by zero", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "/", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 /", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        9
+        9, {0}
     },
 
     {
         "MOD", {
-            {"basic", "17 5 MOD . CR", "Should print: 2", TEST_NORMAL, 0, 1},
-            {"exact_division", "15 3 MOD . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"by_one", "42 1 MOD . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative_dividend", "-17 5 MOD . CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"negative_divisor", "17 -5 MOD . CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"small_by_large", "3 7 MOD . CR", "Should print: 3", TEST_NORMAL, 0, 1},
-            {"by_zero", "42 0 MOD", "Should cause division by zero", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "17 5 MOD . CR", "Should print: 2", TEST_NORMAL, 0, 1, {0}},
+            {"exact_division", "15 3 MOD . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "42 1 MOD . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative_dividend", "-17 5 MOD . CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"negative_divisor", "17 -5 MOD . CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"small_by_large", "3 7 MOD . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {"by_zero", "42 0 MOD", "Should cause division by zero", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        9
+        9, {0}
     },
 
     {
         "/MOD", {
-            {"basic",       "17 5 /MOD . . CR", "Should print: 3 2",              TEST_NORMAL,     0, 1},
-            {"exact",       "15 3 /MOD . . CR", "Should print: 5 0",              TEST_NORMAL,     0, 1},
-            {"negative",    "-17 5 /MOD . . CR","Should handle negative dividend", TEST_NORMAL,     0, 1},
-            {"by_zero",     "42 0 /MOD",        "Should cause division by zero",   TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "/MOD",             "Should cause stack underflow",    TEST_ERROR_CASE, 1, 1},
-            {"one_item",    "42 /MOD",          "Should cause stack underflow",    TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "17 5 /MOD . . CR", "Should print: 3 2",              TEST_NORMAL,     0, 1, {0}},
+            {"exact",       "15 3 /MOD . . CR", "Should print: 5 0",              TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-17 5 /MOD . . CR","Should handle negative dividend", TEST_NORMAL,     0, 1, {0}},
+            {"by_zero",     "42 0 /MOD",        "Should cause division by zero",   TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "/MOD",             "Should cause stack underflow",    TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item",    "42 /MOD",          "Should cause stack underflow",    TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "ABS", {
-            {"positive",    "42 ABS . CR",          "Should print: 42",  TEST_NORMAL,     0, 1},
-            {"negative",    "-42 ABS . CR",         "Should print: 42",  TEST_NORMAL,     0, 1},
-            {"zero",        "0 ABS . CR",           "Should print: 0",   TEST_NORMAL,     0, 1},
-            {"min_int",     "-2147483648 ABS . CR", "Should print: 2147483648", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "ABS",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive",    "42 ABS . CR",          "Should print: 42",  TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-42 ABS . CR",         "Should print: 42",  TEST_NORMAL,     0, 1, {0}},
+            {"zero",        "0 ABS . CR",           "Should print: 0",   TEST_NORMAL,     0, 1, {0}},
+            {"min_int",     "-2147483648 ABS . CR", "Should print: 2147483648", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "ABS",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "NEGATE", {
-            {"positive",    "42 NEGATE . CR",          "Should print: -42", TEST_NORMAL,     0, 1},
-            {"negative",    "-42 NEGATE . CR",         "Should print: 42",  TEST_NORMAL,     0, 1},
-            {"zero",        "0 NEGATE . CR",           "Should print: 0",   TEST_NORMAL,     0, 1},
-            {"min_int",     "-2147483648 NEGATE . CR", "Should print: 2147483648", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "NEGATE",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive",    "42 NEGATE . CR",          "Should print: -42", TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-42 NEGATE . CR",         "Should print: 42",  TEST_NORMAL,     0, 1, {0}},
+            {"zero",        "0 NEGATE . CR",           "Should print: 0",   TEST_NORMAL,     0, 1, {0}},
+            {"min_int",     "-2147483648 NEGATE . CR", "Should print: 2147483648", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "NEGATE",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "MIN", {
-            {"basic",       "5 3 MIN . CR",    "Should print: 3",   TEST_NORMAL,     0, 1},
-            {"equal",       "42 42 MIN . CR",  "Should print: 42",  TEST_NORMAL,     0, 1},
-            {"negative",    "-5 -3 MIN . CR",  "Should print: -5",  TEST_NORMAL,     0, 1},
-            {"mixed",       "-1 1 MIN . CR",   "Should print: -1",  TEST_NORMAL,     0, 1},
-            {"one_item",    "42 MIN",          "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "MIN",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "5 3 MIN . CR",    "Should print: 3",   TEST_NORMAL,     0, 1, {0}},
+            {"equal",       "42 42 MIN . CR",  "Should print: 42",  TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-5 -3 MIN . CR",  "Should print: -5",  TEST_NORMAL,     0, 1, {0}},
+            {"mixed",       "-1 1 MIN . CR",   "Should print: -1",  TEST_NORMAL,     0, 1, {0}},
+            {"one_item",    "42 MIN",          "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "MIN",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "MAX", {
-            {"basic",       "5 3 MAX . CR",    "Should print: 5",   TEST_NORMAL,     0, 1},
-            {"equal",       "42 42 MAX . CR",  "Should print: 42",  TEST_NORMAL,     0, 1},
-            {"negative",    "-5 -3 MAX . CR",  "Should print: -3",  TEST_NORMAL,     0, 1},
-            {"mixed",       "-1 1 MAX . CR",   "Should print: 1",   TEST_NORMAL,     0, 1},
-            {"one_item",    "42 MAX",          "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "MAX",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "5 3 MAX . CR",    "Should print: 5",   TEST_NORMAL,     0, 1, {0}},
+            {"equal",       "42 42 MAX . CR",  "Should print: 42",  TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-5 -3 MAX . CR",  "Should print: -3",  TEST_NORMAL,     0, 1, {0}},
+            {"mixed",       "-1 1 MAX . CR",   "Should print: 1",   TEST_NORMAL,     0, 1, {0}},
+            {"one_item",    "42 MAX",          "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "MAX",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "1+", {
-            {"basic",          "5 1+ . CR",          "Should print: 6",  TEST_NORMAL, 0, 1},
-            {"zero",           "0 1+ . CR",           "Should print: 1",  TEST_NORMAL, 0, 1},
-            {"negative",       "-1 1+ . CR",          "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"chain",          "3 1+ 1+ 1+ . CR",     "Should print: 6",  TEST_NORMAL, 0, 1},
-            {"overflow",       "2147483647 1+ . CR",  "Should overflow",  TEST_EDGE_CASE, 0, 1},
-            {"empty_stack",    "1+",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",          "5 1+ . CR",          "Should print: 6",  TEST_NORMAL, 0, 1, {0}},
+            {"zero",           "0 1+ . CR",           "Should print: 1",  TEST_NORMAL, 0, 1, {0}},
+            {"negative",       "-1 1+ . CR",          "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"chain",          "3 1+ 1+ 1+ . CR",     "Should print: 6",  TEST_NORMAL, 0, 1, {0}},
+            {"overflow",       "2147483647 1+ . CR",  "Should overflow",  TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack",    "1+",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "1-", {
-            {"basic",          "5 1- . CR",           "Should print: 4",  TEST_NORMAL, 0, 1},
-            {"to_zero",        "1 1- . CR",           "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"to_negative",    "0 1- . CR",           "Should print: -1", TEST_NORMAL, 0, 1},
-            {"chain",          "6 1- 1- 1- . CR",     "Should print: 3",  TEST_NORMAL, 0, 1},
-            {"underflow",      "-2147483648 1- . CR", "Should underflow", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack",    "1-",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",          "5 1- . CR",           "Should print: 4",  TEST_NORMAL, 0, 1, {0}},
+            {"to_zero",        "1 1- . CR",           "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"to_negative",    "0 1- . CR",           "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"chain",          "6 1- 1- 1- . CR",     "Should print: 3",  TEST_NORMAL, 0, 1, {0}},
+            {"underflow",      "-2147483648 1- . CR", "Should underflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack",    "1-",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "2+", {
-            {"basic",          "5 2+ . CR",           "Should print: 7",  TEST_NORMAL, 0, 1},
-            {"zero",           "0 2+ . CR",           "Should print: 2",  TEST_NORMAL, 0, 1},
-            {"negative",       "-3 2+ . CR",          "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack",    "2+",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",          "5 2+ . CR",           "Should print: 7",  TEST_NORMAL, 0, 1, {0}},
+            {"zero",           "0 2+ . CR",           "Should print: 2",  TEST_NORMAL, 0, 1, {0}},
+            {"negative",       "-3 2+ . CR",          "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack",    "2+",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "2-", {
-            {"basic",          "7 2- . CR",           "Should print: 5",  TEST_NORMAL, 0, 1},
-            {"zero",           "2 2- . CR",           "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"negative",       "0 2- . CR",           "Should print: -2", TEST_NORMAL, 0, 1},
-            {"empty_stack",    "2-",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",          "7 2- . CR",           "Should print: 5",  TEST_NORMAL, 0, 1, {0}},
+            {"zero",           "2 2- . CR",           "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"negative",       "0 2- . CR",           "Should print: -2", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack",    "2-",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "2*", {
-            {"basic",          "5 2* . CR",           "Should print: 10", TEST_NORMAL, 0, 1},
-            {"zero",           "0 2* . CR",           "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"negative",       "-3 2* . CR",          "Should print: -6", TEST_NORMAL, 0, 1},
-            {"one",            "1 2* . CR",           "Should print: 2",  TEST_NORMAL, 0, 1},
-            {"large",          "1073741823 2* . CR",  "Should print: 2147483646", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack",    "2*",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",          "5 2* . CR",           "Should print: 10", TEST_NORMAL, 0, 1, {0}},
+            {"zero",           "0 2* . CR",           "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"negative",       "-3 2* . CR",          "Should print: -6", TEST_NORMAL, 0, 1, {0}},
+            {"one",            "1 2* . CR",           "Should print: 2",  TEST_NORMAL, 0, 1, {0}},
+            {"large",          "1073741823 2* . CR",  "Should print: 2147483646", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack",    "2*",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "2/", {
-            {"basic",          "10 2/ . CR",          "Should print: 5",  TEST_NORMAL, 0, 1},
-            {"odd",            "7 2/ . CR",           "Should print: 3",  TEST_NORMAL, 0, 1},
-            {"zero",           "0 2/ . CR",           "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"negative_even",  "-10 2/ . CR",         "Should print: -5", TEST_NORMAL, 0, 1},
-            {"one",            "1 2/ . CR",           "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"empty_stack",    "2/",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",          "10 2/ . CR",          "Should print: 5",  TEST_NORMAL, 0, 1, {0}},
+            {"odd",            "7 2/ . CR",           "Should print: 3",  TEST_NORMAL, 0, 1, {0}},
+            {"zero",           "0 2/ . CR",           "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"negative_even",  "-10 2/ . CR",         "Should print: -5", TEST_NORMAL, 0, 1, {0}},
+            {"one",            "1 2/ . CR",           "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack",    "2/",                  "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/block_words_test.c b/src/test_runner/modules/block_words_test.c
index ccff364..a30c088 100644
--- a/src/test_runner/modules/block_words_test.c
+++ b/src/test_runner/modules/block_words_test.c
@@ -62,135 +62,135 @@
 static WordTestSuite block_word_suites[] = {
     {
         "BLOCK", {
-            {"basic", "1 BLOCK DUP . CR", "Should return block address", TEST_NORMAL, 0, 1},
-            {"zero_block", "0 BLOCK", "Should handle block 0", TEST_ERROR_CASE, 1, 1},
-            {"large_block", "65536 BLOCK", "Should handle large number", TEST_ERROR_CASE, 1, 1},
-            {"negative", "-1 BLOCK", "Should handle negative", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "BLOCK", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 BLOCK DUP . CR", "Should return block address", TEST_NORMAL, 0, 1, {0}},
+            {"zero_block", "0 BLOCK", "Should handle block 0", TEST_ERROR_CASE, 1, 1, {0}},
+            {"large_block", "65536 BLOCK", "Should handle large number", TEST_ERROR_CASE, 1, 1, {0}},
+            {"negative", "-1 BLOCK", "Should handle negative", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "BLOCK", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "BUFFER", {
-            {"basic", "1 BUFFER DUP . CR", "Should return buffer address", TEST_NORMAL, 0, 1},
-            {"zero_block", "0 BUFFER", "Should handle block 0", TEST_ERROR_CASE, 1, 1},
-            {"flush_dirty", "2 BLOCK 1+ 2 BUFFER", "Should flush if dirty", TEST_NORMAL, 0, 1},
-            {"empty_stack", "BUFFER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 BUFFER DUP . CR", "Should return buffer address", TEST_NORMAL, 0, 1, {0}},
+            {"zero_block", "0 BUFFER", "Should handle block 0", TEST_ERROR_CASE, 1, 1, {0}},
+            {"flush_dirty", "2 BLOCK 1+ 2 BUFFER", "Should flush if dirty", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "BUFFER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "UPDATE", {
-            {"basic", "1 BLOCK UPDATE", "Should mark block dirty", TEST_NORMAL, 0, 1},
-            {"multiple", "1 BLOCK UPDATE UPDATE", "Should handle multiple updates", TEST_NORMAL, 0, 1},
-            {"no_block", "0 SCR ! UPDATE", "Should error: blk=0 is invalid", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 BLOCK UPDATE", "Should mark block dirty", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "1 BLOCK UPDATE UPDATE", "Should handle multiple updates", TEST_NORMAL, 0, 1, {0}},
+            {"no_block", "0 SCR ! UPDATE", "Should error: blk=0 is invalid", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "SAVE-BUFFERS", {
-            {"basic", "SAVE-BUFFERS", "Should flush all buffers", TEST_NORMAL, 0, 1},
-            {"dirty_blocks", "1 BLOCK UPDATE SAVE-BUFFERS", "Should save dirty blocks", TEST_NORMAL, 0, 1},
-            {"no_dirty", "SAVE-BUFFERS", "Should handle no dirty blocks", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "SAVE-BUFFERS", "Should flush all buffers", TEST_NORMAL, 0, 1, {0}},
+            {"dirty_blocks", "1 BLOCK UPDATE SAVE-BUFFERS", "Should save dirty blocks", TEST_NORMAL, 0, 1, {0}},
+            {"no_dirty", "SAVE-BUFFERS", "Should handle no dirty blocks", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "EMPTY-BUFFERS", {
-            {"basic", "EMPTY-BUFFERS", "Should invalidate all buffers", TEST_NORMAL, 0, 1},
-            {"after_use", "1 BLOCK EMPTY-BUFFERS", "Should invalidate used buffers", TEST_NORMAL, 0, 1},
-            {"dirty_blocks", "1 BLOCK UPDATE EMPTY-BUFFERS", "Should handle dirty blocks", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "EMPTY-BUFFERS", "Should invalidate all buffers", TEST_NORMAL, 0, 1, {0}},
+            {"after_use", "1 BLOCK EMPTY-BUFFERS", "Should invalidate used buffers", TEST_NORMAL, 0, 1, {0}},
+            {"dirty_blocks", "1 BLOCK UPDATE EMPTY-BUFFERS", "Should handle dirty blocks", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "FLUSH", {
-            {"basic", "FLUSH", "Should save and invalidate buffers", TEST_NORMAL, 0, 1},
-            {"dirty_blocks", "1 BLOCK UPDATE FLUSH", "Should flush dirty blocks", TEST_NORMAL, 0, 1},
-            {"after_empty", "EMPTY-BUFFERS FLUSH", "Should handle empty buffers", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "FLUSH", "Should save and invalidate buffers", TEST_NORMAL, 0, 1, {0}},
+            {"dirty_blocks", "1 BLOCK UPDATE FLUSH", "Should flush dirty blocks", TEST_NORMAL, 0, 1, {0}},
+            {"after_empty", "EMPTY-BUFFERS FLUSH", "Should handle empty buffers", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "LOAD", {
-            {"basic", "1 LOAD", "Should interpret block 1", TEST_NORMAL, 0, 1},
-            {"zero_block", "0 LOAD", "Should handle block 0", TEST_ERROR_CASE, 1, 1},
-            {"nonexistent", "9999 LOAD", "Should handle missing block", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "LOAD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 LOAD", "Should interpret block 1", TEST_NORMAL, 0, 1, {0}},
+            {"zero_block", "0 LOAD", "Should handle block 0", TEST_ERROR_CASE, 1, 1, {0}},
+            {"nonexistent", "9999 LOAD", "Should handle missing block", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "LOAD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "LIST", {
-            {"basic", "1 LIST", "Should display block 1", TEST_NORMAL, 0, 1},
-            {"zero_block", "0 LIST", "Should handle block 0", TEST_ERROR_CASE, 1, 1},
-            {"nonexistent", "9999 LIST", "Should handle missing block", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "LIST", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 LIST", "Should display block 1", TEST_NORMAL, 0, 1, {0}},
+            {"zero_block", "0 LIST", "Should handle block 0", TEST_ERROR_CASE, 1, 1, {0}},
+            {"nonexistent", "9999 LIST", "Should handle missing block", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "LIST", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SCR", {
-            {"basic", "SCR @ . CR", "Should show current block", TEST_NORMAL, 0, 1},
-            {"after_list", "1 LIST SCR @ . CR", "Should update after LIST", TEST_NORMAL, 0, 1},
-            {"after_load", "1 LOAD SCR @ . CR", "Should update after LOAD", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "SCR @ . CR", "Should show current block", TEST_NORMAL, 0, 1, {0}},
+            {"after_list", "1 LIST SCR @ . CR", "Should update after LIST", TEST_NORMAL, 0, 1, {0}},
+            {"after_load", "1 LOAD SCR @ . CR", "Should update after LOAD", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "THRU", {
             /* Basic functionality */
-            {"single_block", "1 1 THRU", "Should load single block (1-1)", TEST_NORMAL, 0, 1},
-            {"ascending", "1 3 THRU", "Should load blocks 1-3 in order", TEST_NORMAL, 0, 1},
-            {"descending", "3 1 THRU", "Should auto-swap and load 1-3", TEST_NORMAL, 0, 1},
-            {"same_block", "2 2 THRU", "Should load single block (2-2)", TEST_NORMAL, 0, 1},
+            {"single_block", "1 1 THRU", "Should load single block (1-1)", TEST_NORMAL, 0, 1, {0}},
+            {"ascending", "1 3 THRU", "Should load blocks 1-3 in order", TEST_NORMAL, 0, 1, {0}},
+            {"descending", "3 1 THRU", "Should auto-swap and load 1-3", TEST_NORMAL, 0, 1, {0}},
+            {"same_block", "2 2 THRU", "Should load single block (2-2)", TEST_NORMAL, 0, 1, {0}},
 
             /* Error cases - invalid block numbers */
-            {"zero_start", "0 3 THRU", "Should reject block 0 as start", TEST_ERROR_CASE, 1, 1},
-            {"zero_end", "1 0 THRU", "Should reject block 0 as end", TEST_ERROR_CASE, 1, 1},
-            {"both_zero", "0 0 THRU", "Should reject both blocks as 0", TEST_ERROR_CASE, 1, 1},
-            {"invalid_start", "9999 10000 THRU", "Should reject invalid start block", TEST_ERROR_CASE, 1, 1},
-            {"invalid_end", "1 9999 THRU", "Should reject invalid end block", TEST_ERROR_CASE, 1, 1},
-            {"both_invalid", "9998 9999 THRU", "Should reject both invalid blocks", TEST_ERROR_CASE, 1, 1},
+            {"zero_start", "0 3 THRU", "Should reject block 0 as start", TEST_ERROR_CASE, 1, 1, {0}},
+            {"zero_end", "1 0 THRU", "Should reject block 0 as end", TEST_ERROR_CASE, 1, 1, {0}},
+            {"both_zero", "0 0 THRU", "Should reject both blocks as 0", TEST_ERROR_CASE, 1, 1, {0}},
+            {"invalid_start", "9999 10000 THRU", "Should reject invalid start block", TEST_ERROR_CASE, 1, 1, {0}},
+            {"invalid_end", "1 9999 THRU", "Should reject invalid end block", TEST_ERROR_CASE, 1, 1, {0}},
+            {"both_invalid", "9998 9999 THRU", "Should reject both invalid blocks", TEST_ERROR_CASE, 1, 1, {0}},
 
             /* Stack underflow */
-            {"empty_stack", "THRU", "Should cause stack underflow (no args)", TEST_ERROR_CASE, 1, 1},
-            {"one_arg", "1 THRU", "Should cause stack underflow (one arg)", TEST_ERROR_CASE, 1, 1},
+            {"empty_stack", "THRU", "Should cause stack underflow (no args)", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_arg", "1 THRU", "Should cause stack underflow (one arg)", TEST_ERROR_CASE, 1, 1, {0}},
 
             /* Range tests */
-            {"small_range", "1 2 THRU", "Should load 2-block range", TEST_NORMAL, 0, 1},
-            {"medium_range", "1 5 THRU", "Should load 5-block range", TEST_NORMAL, 0, 1},
+            {"small_range", "1 2 THRU", "Should load 2-block range", TEST_NORMAL, 0, 1, {0}},
+            {"medium_range", "1 5 THRU", "Should load 5-block range", TEST_NORMAL, 0, 1, {0}},
 
             /* Edge cases */
-            {"negative_start", "-1 3 THRU", "Should handle negative start", TEST_ERROR_CASE, 1, 1},
-            {"negative_end", "1 -3 THRU", "Should handle negative end", TEST_ERROR_CASE, 1, 1},
-            {"both_negative", "-3 -1 THRU", "Should handle both negative", TEST_ERROR_CASE, 1, 1},
+            {"negative_start", "-1 3 THRU", "Should handle negative start", TEST_ERROR_CASE, 1, 1, {0}},
+            {"negative_end", "1 -3 THRU", "Should handle negative end", TEST_ERROR_CASE, 1, 1, {0}},
+            {"both_negative", "-3 -1 THRU", "Should handle both negative", TEST_ERROR_CASE, 1, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        17
+        17, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/control_words_test.c b/src/test_runner/modules/control_words_test.c
index a8a8bbe..f0a0a25 100644
--- a/src/test_runner/modules/control_words_test.c
+++ b/src/test_runner/modules/control_words_test.c
@@ -50,206 +50,203 @@
 static WordTestSuite control_word_suites[] = {
     {
         "IF", {
-            {"true", ": TEST1 IF 42 ELSE 24 THEN ; -1 TEST1 . CR", "Should take true branch", TEST_NORMAL, 0, 1},
-            {"false", ": TEST2 IF 42 ELSE 24 THEN ; 0 TEST2 . CR", "Should take false branch", TEST_NORMAL, 0, 1},
+            {"true", ": TEST1 IF 42 ELSE 24 THEN ; -1 TEST1 . CR", "Should take true branch", TEST_NORMAL, 0, 1, {0}},
+            {"false", ": TEST2 IF 42 ELSE 24 THEN ; 0 TEST2 . CR", "Should take false branch", TEST_NORMAL, 0, 1, {0}},
             {
                 "nested", ": TEST3 IF IF 1 ELSE 2 THEN ELSE 3 THEN ; -1 -1 TEST3 . CR", "Should handle nesting",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"no_else", ": TEST4 IF 42 THEN ; -1 TEST4 . CR", "Should work without ELSE", TEST_NORMAL, 0, 1},
-            {"empty_stack", "IF", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"no_else", ": TEST4 IF 42 THEN ; -1 TEST4 . CR", "Should work without ELSE", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "IF", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "ELSE", {
-            {"alone", "ELSE", "Should error outside IF", TEST_ERROR_CASE, 1, 1},
-            {"double", ": BAD IF 1 ELSE ELSE 2 THEN ;", "Should prevent double ELSE", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"alone", "ELSE", "Should error outside IF", TEST_ERROR_CASE, 1, 1, {0}},
+            {"double", ": BAD IF 1 ELSE ELSE 2 THEN ;", "Should prevent double ELSE", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "THEN", {
-            {"alone", "THEN", "Should error outside IF", TEST_ERROR_CASE, 1, 1},
-            {"extra", ": BAD IF 1 THEN THEN ;", "Should prevent extra THEN", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"alone", "THEN", "Should error outside IF", TEST_ERROR_CASE, 1, 1, {0}},
+            {"extra", ": BAD IF 1 THEN THEN ;", "Should prevent extra THEN", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "BEGIN", {
-            {"until", ": TEST5 0 BEGIN 1+ DUP 5 = UNTIL ; TEST5 . CR", "Should loop until true", TEST_NORMAL, 0, 1},
+            {"until", ": TEST5 0 BEGIN 1+ DUP 5 = UNTIL ; TEST5 . CR", "Should loop until true", TEST_NORMAL, 0, 1, {0}},
             {
-                "while", ": TEST6 0 BEGIN DUP 5 < WHILE 1+ REPEAT ; TEST6 . CR", "Should loop while true", TEST_NORMAL,
-                0, 1
+                "while", ": TEST6 0 BEGIN DUP 5 < WHILE 1+ REPEAT ; TEST6 . CR", "Should loop while true", TEST_NORMAL, 0, 1, {0}
             },
             /* TODO: Nested control flow - needs compiler refactoring for proper origin stack */
             /* {"nested", ": TEST7 0 BEGIN 1+ BEGIN DUP 3 < WHILE 1+ REPEAT DUP 5 = UNTIL ;", "Should handle nesting", TEST_NORMAL, 0, 1}, */
-            {"alone", "BEGIN", "Should error outside definition", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"alone", "BEGIN", "Should error outside definition", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "UNTIL", {
-            {"basic", ": TEST8 BEGIN DUP 1- DUP 0= UNTIL ; 5 TEST8 . CR", "Should count down", TEST_NORMAL, 0, 1},
-            {"immediate", ": TEST9 BEGIN 1 UNTIL ; IMMEDIATE", "Should be immediate", TEST_NORMAL, 0, 1},
-            {"no_begin", "UNTIL", "Should error without BEGIN", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", ": TEST8 BEGIN DUP 1- DUP 0= UNTIL ; 5 TEST8 . CR", "Should count down", TEST_NORMAL, 0, 1, {0}},
+            {"immediate", ": TEST9 BEGIN 1 UNTIL ; IMMEDIATE", "Should be immediate", TEST_NORMAL, 0, 1, {0}},
+            {"no_begin", "UNTIL", "Should error without BEGIN", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "WHILE", {
-            {"basic", ": TEST10 BEGIN DUP 5 < WHILE 1+ REPEAT ; 0 TEST10 . CR", "Should count up", TEST_NORMAL, 0, 1},
+            {"basic", ": TEST10 BEGIN DUP 5 < WHILE 1+ REPEAT ; 0 TEST10 . CR", "Should count up", TEST_NORMAL, 0, 1, {0}},
             {
                 "zero_times", ": TEST11 BEGIN DUP 0< WHILE 1+ REPEAT ; 0 TEST11 . CR", "Should handle zero iterations",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"no_begin", "WHILE", "Should error without BEGIN", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"no_begin", "WHILE", "Should error without BEGIN", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "REPEAT", {
             {
-                "basic", ": TEST12 BEGIN DUP 5 < WHILE 1+ REPEAT ; 0 TEST12 . CR", "Should terminate loop", TEST_NORMAL,
-                0, 1
+                "basic", ": TEST12 BEGIN DUP 5 < WHILE 1+ REPEAT ; 0 TEST12 . CR", "Should terminate loop", TEST_NORMAL, 0, 1, {0}
             },
-            {"no_while", "REPEAT", "Should error without WHILE", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"no_while", "REPEAT", "Should error without WHILE", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "DO", {
-            {"basic", ": TEST13 5 0 DO I . LOOP ; TEST13 CR", "Should count 0 to 4", TEST_NORMAL, 0, 1},
-            {"negative", ": TEST14 -1 -5 DO I . LOOP ; TEST14 CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"empty", ": TEST15 0 0 DO LOOP ;", "Should handle empty range", TEST_NORMAL, 0, 1},
+            {"basic", ": TEST13 5 0 DO I . LOOP ; TEST13 CR", "Should count 0 to 4", TEST_NORMAL, 0, 1, {0}},
+            {"negative", ": TEST14 -1 -5 DO I . LOOP ; TEST14 CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"empty", ": TEST15 0 0 DO LOOP ;", "Should handle empty range", TEST_NORMAL, 0, 1, {0}},
             {
-                "nested", ": TEST16 3 0 DO 3 0 DO J I + . LOOP LOOP ; TEST16 CR", "Should handle nesting", TEST_NORMAL,
-                0, 1
+                "nested", ": TEST16 3 0 DO 3 0 DO J I + . LOOP LOOP ; TEST16 CR", "Should handle nesting", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "?DO", {
-            {"basic", ": TEST17 5 0 ?DO I . LOOP ; TEST17 CR", "Should count 0 to 4", TEST_NORMAL, 0, 1},
-            {"skip", ": TEST18 1 1 ?DO I . LOOP ;", "Should skip when equal", TEST_NORMAL, 0, 1},
+            {"basic", ": TEST17 5 0 ?DO I . LOOP ; TEST17 CR", "Should count 0 to 4", TEST_NORMAL, 0, 1, {0}},
+            {"skip", ": TEST18 1 1 ?DO I . LOOP ;", "Should skip when equal", TEST_NORMAL, 0, 1, {0}},
             {
                 "nested", ": TEST19 3 0 ?DO 3 I ?DO J I + . LOOP LOOP ; TEST19 CR", "Should handle nesting",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "LOOP", {
-            {"basic", ": TEST20 5 0 DO I . LOOP ; TEST20 CR", "Should increment by 1", TEST_NORMAL, 0, 1},
-            {"no_do", "LOOP", "Should error without DO", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", ": TEST20 5 0 DO I . LOOP ; TEST20 CR", "Should increment by 1", TEST_NORMAL, 0, 1, {0}},
+            {"no_do", "LOOP", "Should error without DO", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "+LOOP", {
-            {"basic", ": TEST21 10 0 DO I . 2 +LOOP ; TEST21 CR", "Should count by 2", TEST_NORMAL, 0, 1},
-            {"negative", ": TEST22 0 10 DO I . -1 +LOOP ; TEST22 CR", "Should count down", TEST_NORMAL, 0, 1},
-            {"variable", ": TEST23 10 0 DO I . DUP +LOOP ; 3 TEST23 CR", "Should use stack value", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", ": TEST21 10 0 DO I . 2 +LOOP ; TEST21 CR", "Should count by 2", TEST_NORMAL, 0, 1, {0}},
+            {"negative", ": TEST22 0 10 DO I . -1 +LOOP ; TEST22 CR", "Should count down", TEST_NORMAL, 0, 1, {0}},
+            {"variable", ": TEST23 10 0 DO I . DUP +LOOP ; 3 TEST23 CR", "Should use stack value", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "I", {
-            {"basic",    ": TI 4 0 DO I . LOOP CR ; TI",        "Should print: 0 1 2 3", TEST_NORMAL, 0, 1},
-            {"single",   ": TI1 1 0 DO I . LOOP CR ; TI1",      "Should print: 0",        TEST_NORMAL, 0, 1},
-            {"offset",   ": TI2 5 3 DO I . LOOP CR ; TI2",      "Should print: 3 4",      TEST_NORMAL, 0, 1},
-            {"in_expr",  ": TI3 3 0 DO I 2 * . LOOP CR ; TI3",  "Should print: 0 2 4",    TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",    ": TI 4 0 DO I . LOOP CR ; TI",        "Should print: 0 1 2 3", TEST_NORMAL, 0, 1, {0}},
+            {"single",   ": TI1 1 0 DO I . LOOP CR ; TI1",      "Should print: 0",        TEST_NORMAL, 0, 1, {0}},
+            {"offset",   ": TI2 5 3 DO I . LOOP CR ; TI2",      "Should print: 3 4",      TEST_NORMAL, 0, 1, {0}},
+            {"in_expr",  ": TI3 3 0 DO I 2 * . LOOP CR ; TI3",  "Should print: 0 2 4",    TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "J", {
-            {"basic",  ": TJ 2 0 DO 3 0 DO J . LOOP LOOP CR ; TJ",     "Should print: 0 0 0 1 1 1", TEST_NORMAL, 0, 1},
-            {"paired", ": TJ2 2 0 DO 2 0 DO J I + . LOOP LOOP CR ; TJ2", "Should print: 0 1 1 2",   TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",  ": TJ 2 0 DO 3 0 DO J . LOOP LOOP CR ; TJ",     "Should print: 0 0 0 1 1 1", TEST_NORMAL, 0, 1, {0}},
+            {"paired", ": TJ2 2 0 DO 2 0 DO J I + . LOOP LOOP CR ; TJ2", "Should print: 0 1 1 2",   TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "EXIT", {
-            {"early_return",  ": TEX 5 EXIT 99 ; TEX . CR",                           "Should print: 5",    TEST_NORMAL, 0, 1},
-            {"cond_exit_pos", ": TEX2 DUP 0> IF EXIT THEN NEGATE ; 3 TEX2 . CR",      "Should print: 3",    TEST_NORMAL, 0, 1},
-            {"cond_exit_neg", ": TEX2 DUP 0> IF EXIT THEN NEGATE ; -4 TEX2 . CR",     "Should print: 4",    TEST_NORMAL, 0, 1},
-            {"no_skipped",    ": TEX3 1 2 EXIT 3 ; TEX3 . . CR",                      "Should print: 2 1",  TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"early_return",  ": TEX 5 EXIT 99 ; TEX . CR",                           "Should print: 5",    TEST_NORMAL, 0, 1, {0}},
+            {"cond_exit_pos", ": TEX2 DUP 0> IF EXIT THEN NEGATE ; 3 TEX2 . CR",      "Should print: 3",    TEST_NORMAL, 0, 1, {0}},
+            {"cond_exit_neg", ": TEX2 DUP 0> IF EXIT THEN NEGATE ; -4 TEX2 . CR",     "Should print: 4",    TEST_NORMAL, 0, 1, {0}},
+            {"no_skipped",    ": TEX3 1 2 EXIT 3 ; TEX3 . . CR",                      "Should print: 2 1",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "LEAVE", {
-            {"basic",    ": TLV 0 5 0 DO I 3 = IF LEAVE THEN 1+ LOOP ; TLV . CR",      "Should print: 3",  TEST_NORMAL, 0, 1},
-            {"at_start", ": TLV2 0 5 0 DO LEAVE 1+ LOOP ; TLV2 . CR",                  "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"qdloop",   ": TLV3 0 5 0 ?DO I 2 = IF LEAVE THEN 1+ LOOP ; TLV3 . CR",   "Should print: 2",  TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",    ": TLV 0 5 0 DO I 3 = IF LEAVE THEN 1+ LOOP ; TLV . CR",      "Should print: 3",  TEST_NORMAL, 0, 1, {0}},
+            {"at_start", ": TLV2 0 5 0 DO LEAVE 1+ LOOP ; TLV2 . CR",                  "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"qdloop",   ": TLV3 0 5 0 ?DO I 2 = IF LEAVE THEN 1+ LOOP ; TLV3 . CR",   "Should print: 2",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "UNLOOP", {
-            {"early_exit",  ": TUL 5 0 DO I 2 = IF UNLOOP 42 EXIT THEN LOOP 99 ; TUL . CR",  "Should print: 42", TEST_NORMAL, 0, 1},
-            {"full_loop",   ": TUL2 5 0 DO I 9 = IF UNLOOP 77 EXIT THEN LOOP 99 ; TUL2 . CR", "Should print: 99", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"early_exit",  ": TUL 5 0 DO I 2 = IF UNLOOP 42 EXIT THEN LOOP 99 ; TUL . CR",  "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"full_loop",   ": TUL2 5 0 DO I 9 = IF UNLOOP 77 EXIT THEN LOOP 99 ; TUL2 . CR", "Should print: 99", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "AGAIN", {
-            {"basic",    ": TAG 0 BEGIN 1+ DUP 3 = IF EXIT THEN AGAIN ; TAG . CR",     "Should print: 3",  TEST_NORMAL, 0, 1},
-            {"countdown",": CD 10 BEGIN 1- DUP 0= IF EXIT THEN AGAIN ; CD . CR",     "Should print: 0",  TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",    ": TAG 0 BEGIN 1+ DUP 3 = IF EXIT THEN AGAIN ; TAG . CR",     "Should print: 3",  TEST_NORMAL, 0, 1, {0}},
+            {"countdown",": CD 10 BEGIN 1- DUP 0= IF EXIT THEN AGAIN ; CD . CR",     "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "CASE", {
-            {"match_1",    ": TC CASE 1 OF 10 ENDOF 2 OF 20 ENDOF 99 SWAP ENDCASE . CR ; 1 TC", "Should print: 10", TEST_NORMAL, 0, 1},
-            {"match_2",    ": TC CASE 1 OF 10 ENDOF 2 OF 20 ENDOF 99 SWAP ENDCASE . CR ; 2 TC", "Should print: 20", TEST_NORMAL, 0, 1},
-            {"default",    ": TC CASE 1 OF 10 ENDOF 2 OF 20 ENDOF 99 SWAP ENDCASE . CR ; 5 TC", "Should print: 99", TEST_NORMAL, 0, 1},
-            {"zero_case",  ": TC CASE 0 OF 88 ENDOF 1 OF 77 ENDOF 66 SWAP ENDCASE . CR ; 0 TC", "Should print: 88", TEST_NORMAL, 0, 1},
-            {"neg_case",   ": TC CASE -1 OF 55 ENDOF 44 SWAP ENDCASE . CR ; -1 TC",             "Should print: 55", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"match_1",    ": TC CASE 1 OF 10 ENDOF 2 OF 20 ENDOF 99 SWAP ENDCASE . CR ; 1 TC", "Should print: 10", TEST_NORMAL, 0, 1, {0}},
+            {"match_2",    ": TC CASE 1 OF 10 ENDOF 2 OF 20 ENDOF 99 SWAP ENDCASE . CR ; 2 TC", "Should print: 20", TEST_NORMAL, 0, 1, {0}},
+            {"default",    ": TC CASE 1 OF 10 ENDOF 2 OF 20 ENDOF 99 SWAP ENDCASE . CR ; 5 TC", "Should print: 99", TEST_NORMAL, 0, 1, {0}},
+            {"zero_case",  ": TC CASE 0 OF 88 ENDOF 1 OF 77 ENDOF 66 SWAP ENDCASE . CR ; 0 TC", "Should print: 88", TEST_NORMAL, 0, 1, {0}},
+            {"neg_case",   ": TC CASE -1 OF 55 ENDOF 44 SWAP ENDCASE . CR ; -1 TC",             "Should print: 55", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /** @brief Executes all control words test suites
diff --git a/src/test_runner/modules/defining_words_tests.c b/src/test_runner/modules/defining_words_tests.c
index a3a9827..ad30852 100644
--- a/src/test_runner/modules/defining_words_tests.c
+++ b/src/test_runner/modules/defining_words_tests.c
@@ -50,128 +50,128 @@
 static WordTestSuite defining_word_suites[] = {
     {
         ":", {
-            {"basic", ": TEST1 42 ; TEST1 . CR", "Should define and execute", TEST_NORMAL, 0, 1},
-            {"empty_name", ":", "Should handle empty definition", TEST_ERROR_CASE, 1, 1},
-            {"nested", ": TEST3 : ;", "Should prevent nested definition", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", ": TEST1 42 ; TEST1 . CR", "Should define and execute", TEST_NORMAL, 0, 1, {0}},
+            {"empty_name", ":", "Should handle empty definition", TEST_ERROR_CASE, 1, 1, {0}},
+            {"nested", ": TEST3 : ;", "Should prevent nested definition", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         ";", {
-            {"alone", ";", "Should error outside definition", TEST_ERROR_CASE, 1, 1},
-            {"immediate", ": TEST4 42 ; IMMEDIATE TEST4 . CR", "Should handle immediate", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"alone", ";", "Should error outside definition", TEST_ERROR_CASE, 1, 1, {0}},
+            {"immediate", ": TEST4 42 ; IMMEDIATE TEST4 . CR", "Should handle immediate", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "CONSTANT", {
-            {"basic", "42 CONSTANT MEANING MEANING . CR", "Should create constant", TEST_NORMAL, 0, 1},
-            {"zero", "0 CONSTANT ZERO ZERO . CR", "Should handle zero", TEST_NORMAL, 0, 1},
-            {"negative", "-1 CONSTANT MINUS MINUS . CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"empty_stack", "CONSTANT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 CONSTANT MEANING MEANING . CR", "Should create constant", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 CONSTANT ZERO ZERO . CR", "Should handle zero", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-1 CONSTANT MINUS MINUS . CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "CONSTANT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "VARIABLE", {
-            {"basic", "VARIABLE VAR1 42 VAR1 ! VAR1 @ . CR", "Should create variable", TEST_NORMAL, 0, 1},
-            {"multiple", "VARIABLE VAR2 VARIABLE VAR3", "Should create multiple", TEST_NORMAL, 0, 1},
-            {"store_fetch", "VARIABLE VAR4 -99 VAR4 ! VAR4 @ . CR", "Should store/fetch", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "VARIABLE VAR1 42 VAR1 ! VAR1 @ . CR", "Should create variable", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "VARIABLE VAR2 VARIABLE VAR3", "Should create multiple", TEST_NORMAL, 0, 1, {0}},
+            {"store_fetch", "VARIABLE VAR4 -99 VAR4 ! VAR4 @ . CR", "Should store/fetch", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "CREATE", {
-            {"basic", "CREATE OBJ1", "Should create word", TEST_NORMAL, 0, 1},
-            {"with_data", "CREATE OBJ2 42 , OBJ2 @ . CR", "Should allow data", TEST_NORMAL, 0, 1},
-            {"empty_name", "CREATE", "Should handle empty name", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "CREATE OBJ1", "Should create word", TEST_NORMAL, 0, 1, {0}},
+            {"with_data", "CREATE OBJ2 42 , OBJ2 @ . CR", "Should allow data", TEST_NORMAL, 0, 1, {0}},
+            {"empty_name", "CREATE", "Should handle empty name", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "DOES>", {
             {
                 "basic", ": CONST CREATE , DOES> @ ; 42 CONST MEANING MEANING . CR", "Should define behavior",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "multiple", ": ARRAY CREATE DOES> SWAP CELLS + ; CREATE ARR 10 CELLS ALLOT", "Should work with arrays",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"outside", "DOES>", "Should error outside definition", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"outside", "DOES>", "Should error outside definition", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "[", {
-            {"basic", ": TEST5 [ 42 ] LITERAL ; TEST5 . CR", "Should enter interpret", TEST_NORMAL, 0, 1},
-            {"outside", "[", "Should be allowed outside definition (no error)", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", ": TEST5 [ 42 ] LITERAL ; TEST5 . CR", "Should enter interpret", TEST_NORMAL, 0, 1, {0}},
+            {"outside", "[", "Should be allowed outside definition (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "]", {
-            {"basic", "[ 42 ] . CR", "Should resume compile", TEST_NORMAL, 0, 1},
-            {"nested", ": TEST6 [ ] 42 ; TEST6 . CR", "Should handle nesting", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "[ 42 ] . CR", "Should resume compile", TEST_NORMAL, 0, 1, {0}},
+            {"nested", ": TEST6 [ ] 42 ; TEST6 . CR", "Should handle nesting", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "DEFER", {
-            {"basic",   "DEFER DF1 : DF1W 42 . CR ; ' DF1W IS DF1 DF1", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"uninit",  "DEFER DF2 DF2",  "Should error: uninitialized deferred word", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",   "DEFER DF1 : DF1W 42 . CR ; ' DF1W IS DF1 DF1", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"uninit",  "DEFER DF2 DF2",  "Should error: uninitialized deferred word", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "IS", {
-            {"basic",     "DEFER IS1 : IS1W 99 . CR ; ' IS1W IS IS1 IS1", "Should print: 99", TEST_NORMAL, 0, 1},
-            {"not_defer", "42 IS DUP",    "Should error: DUP is not a DEFER word", TEST_ERROR_CASE, 1, 1},
-            {"not_found", "42 IS NOSUCH", "Should error: word not found", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",     "DEFER IS1 : IS1W 99 . CR ; ' IS1W IS IS1 IS1", "Should print: 99", TEST_NORMAL, 0, 1, {0}},
+            {"not_defer", "42 IS DUP",    "Should error: DUP is not a DEFER word", TEST_ERROR_CASE, 1, 1, {0}},
+            {"not_found", "42 IS NOSUCH", "Should error: word not found", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "DEFER@", {
-            {"basic",     "DEFER DFA1 : DFA1W 7 . CR ; ' DFA1W IS DFA1 DEFER@ DFA1 0<> . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"not_found", "DEFER@ NOSUCH2", "Should error: word not found", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",     "DEFER DFA1 : DFA1W 7 . CR ; ' DFA1W IS DFA1 DEFER@ DFA1 0<> . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"not_found", "DEFER@ NOSUCH2", "Should error: word not found", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "[']", {
-            {"compile_xt", ": BKT1 ['] DUP ; 77 BKT1 EXECUTE . . CR", "Should print: 77 77", TEST_NORMAL, 0, 1},
-            {"pin_like",   ": BKT2 ['] DROP ; 1 2 BKT2 EXECUTE . CR",  "Should print: 1",    TEST_NORMAL, 0, 1},
-            {"not_found",  ": BKT3 ['] NOSUCHWORD ;",                   "Should error: word not found", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"compile_xt", ": BKT1 ['] DUP ; 77 BKT1 EXECUTE . . CR", "Should print: 77 77", TEST_NORMAL, 0, 1, {0}},
+            {"pin_like",   ": BKT2 ['] DROP ; 1 2 BKT2 EXECUTE . CR",  "Should print: 1",    TEST_NORMAL, 0, 1, {0}},
+            {"not_found",  ": BKT3 ['] NOSUCHWORD ;",                   "Should error: word not found", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /** @brief Executes all test suites for Forth defining words
diff --git a/src/test_runner/modules/dictionary_manipulation_words_test.c b/src/test_runner/modules/dictionary_manipulation_words_test.c
index f774d7f..7371457 100644
--- a/src/test_runner/modules/dictionary_manipulation_words_test.c
+++ b/src/test_runner/modules/dictionary_manipulation_words_test.c
@@ -47,106 +47,105 @@
 static WordTestSuite dict_manip_word_suites[] = {
     {
         "CREATE", {
-            {"basic", "CREATE test1 42 , test1 @ . CR", "Should create and store", TEST_NORMAL, 0, 1},
-            {"empty_name", "CREATE", "Should handle empty name", TEST_ERROR_CASE, 1, 1},
+            {"basic", "CREATE test1 42 , test1 @ . CR", "Should create and store", TEST_NORMAL, 0, 1, {0}},
+            {"empty_name", "CREATE", "Should handle empty name", TEST_ERROR_CASE, 1, 1, {0}},
             {
                 "redefine_shadows", "CREATE T 1 , CREATE T 2 , T @ . CR", "Newest definition should win (prints 2)",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"duplicate", "CREATE test2 CREATE test2", "Should allow redefinition (latest shadows)", TEST_NORMAL, 0, 1},
-            {"long_name", "CREATE abcdefghijklmnopqrstuvwxyz", "Should handle long name", TEST_EDGE_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"duplicate", "CREATE test2 CREATE test2", "Should allow redefinition (latest shadows)", TEST_NORMAL, 0, 1, {0}},
+            {"long_name", "CREATE abcdefghijklmnopqrstuvwxyz", "Should handle long name", TEST_EDGE_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "FORGET", {
-            {"basic", "CREATE temp1 FORGET temp1", "Should forget word", TEST_NORMAL, 0, 1},
-            {"nonexistent", "FORGET nonexistent", "Should handle missing word", TEST_ERROR_CASE, 1, 1},
-            {"protected", "FORGET FORGET", "Should protect system words", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "CREATE temp1 FORGET temp1", "Should forget word", TEST_NORMAL, 0, 1, {0}},
+            {"nonexistent", "FORGET nonexistent", "Should handle missing word", TEST_ERROR_CASE, 1, 1, {0}},
+            {"protected", "FORGET FORGET", "Should protect system words", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "IMMEDIATE", {
-            {"basic", ": test3 42 ; IMMEDIATE test3 . CR", "Should execute immediately", TEST_NORMAL, 0, 1},
+            {"basic", ": test3 42 ; IMMEDIATE test3 . CR", "Should execute immediately", TEST_NORMAL, 0, 1, {0}},
             {
-                "already_immediate", ": test4 43 ; IMMEDIATE IMMEDIATE", "Should handle double immediate", TEST_NORMAL,
-                0, 1
+                "already_immediate", ": test4 43 ; IMMEDIATE IMMEDIATE", "Should handle double immediate", TEST_NORMAL, 0, 1, {0}
             },
             /* TODO: IMMEDIATE outside definition - requires compile-state tracking in IMMEDIATE */
             /* {"outside_def", "IMMEDIATE", "Should error outside definition", TEST_ERROR_CASE, 1, 1}, */
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "FIND", {
-            {"existing", "FIND DUP . CR", "Should find system word", TEST_NORMAL, 0, 1},
-            {"user_word", ": test5 44 ; FIND test5 . CR", "Should find user word", TEST_NORMAL, 0, 1},
-            {"nonexistent", "FIND nonexistent . CR", "Should return 0", TEST_NORMAL, 0, 1},
-            {"empty", "FIND", "Should error (no token)", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"existing", "FIND DUP . CR", "Should find system word", TEST_NORMAL, 0, 1, {0}},
+            {"user_word", ": test5 44 ; FIND test5 . CR", "Should find user word", TEST_NORMAL, 0, 1, {0}},
+            {"nonexistent", "FIND nonexistent . CR", "Should return 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "FIND", "Should error (no token)", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "DEFINITIONS", {
-            {"basic", "FORTH DEFINITIONS", "Should set current to context", TEST_NORMAL, 0, 1},
-            {"multiple", "FORTH DEFINITIONS DEFINITIONS", "Should be idempotent", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "FORTH DEFINITIONS", "Should set current to context", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "FORTH DEFINITIONS DEFINITIONS", "Should be idempotent", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "SMUDGE", {
-            {"during_def", ": test6 SMUDGE 45 ;", "Should hide incomplete def", TEST_NORMAL, 0, 1},
-            {"outside_def", "SMUDGE", "Should error outside def", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"during_def", ": test6 SMUDGE 45 ;", "Should hide incomplete def", TEST_NORMAL, 0, 1, {0}},
+            {"outside_def", "SMUDGE", "Should error outside def", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "LATEST", {
-            {"basic", "LATEST @ . CR", "Should show latest word", TEST_NORMAL, 0, 1},
-            {"after_def", ": test7 46 ; LATEST @ . CR", "Should update after def", TEST_NORMAL, 0, 1},
+            {"basic", "LATEST @ . CR", "Should show latest word", TEST_NORMAL, 0, 1, {0}},
+            {"after_def", ": test7 46 ; LATEST @ . CR", "Should update after def", TEST_NORMAL, 0, 1, {0}},
             {
                 "after_forget", "CREATE test8 FORGET test8 LATEST @ . CR", "Should update after forget", TEST_NORMAL, 0,
-                1
+                1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         ">BODY", {
-            {"basic", "CREATE test9 ' test9 >BODY . CR", "Should get param field", TEST_NORMAL, 0, 1},
-            {"variable", "VARIABLE var1 ' var1 >BODY . CR", "Should get var storage", TEST_NORMAL, 0, 1},
-            {"nonexistent", "' NONEXISTENT >BODY", "Should handle missing word", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "CREATE test9 ' test9 >BODY . CR", "Should get param field", TEST_NORMAL, 0, 1, {0}},
+            {"variable", "VARIABLE var1 ' var1 >BODY . CR", "Should get var storage", TEST_NORMAL, 0, 1, {0}},
+            {"nonexistent", "' NONEXISTENT >BODY", "Should handle missing word", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "HIDDEN", {
-            {"basic", ": test10 HIDDEN 47 ;", "Should hide word", TEST_NORMAL, 0, 1},
-            {"outside_def", "HIDDEN", "Should error outside def", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", ": test10 HIDDEN 47 ;", "Should hide word", TEST_NORMAL, 0, 1, {0}},
+            {"outside_def", "HIDDEN", "Should error outside def", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/dictionary_words_test.c b/src/test_runner/modules/dictionary_words_test.c
index cb93d8c..7782d2e 100644
--- a/src/test_runner/modules/dictionary_words_test.c
+++ b/src/test_runner/modules/dictionary_words_test.c
@@ -47,147 +47,147 @@
 static WordTestSuite dictionary_word_suites[] = {
     {
         "HERE", {
-            {"basic", "HERE HERE = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"after_comma", "HERE 42 , HERE SWAP - 1 CELLS = 0 SWAP /", "Asserts HERE advances by exactly 1 CELLS (8 bytes on 64-bit)", TEST_NORMAL, 0, 1},
-            {"after_c_comma", "HERE 65 C, HERE SWAP - . CR", "Should print: 1", TEST_NORMAL, 0, 1},
-            {"after_allot", "HERE 10 ALLOT HERE SWAP - . CR", "Should print: 10", TEST_NORMAL, 0, 1},
-            {"stability", "HERE DUP HERE = . CR", "Should be stable", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE HERE = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"after_comma", "HERE 42 , HERE SWAP - 1 CELLS = 0 SWAP /", "Asserts HERE advances by exactly 1 CELLS (8 bytes on 64-bit)", TEST_NORMAL, 0, 1, {0}},
+            {"after_c_comma", "HERE 65 C, HERE SWAP - . CR", "Should print: 1", TEST_NORMAL, 0, 1, {0}},
+            {"after_allot", "HERE 10 ALLOT HERE SWAP - . CR", "Should print: 10", TEST_NORMAL, 0, 1, {0}},
+            {"stability", "HERE DUP HERE = . CR", "Should be stable", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "ALLOT", {
-            {"basic", "HERE 10 ALLOT HERE SWAP - . CR", "Should print: 10", TEST_NORMAL, 0, 1},
-            {"zero", "HERE 0 ALLOT HERE SWAP - . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "HERE -4 ALLOT HERE SWAP - . CR", "Should print: -4", TEST_NORMAL, 0, 1},
-            {"large", "HERE 100 ALLOT HERE SWAP - . CR", "Should print: 100", TEST_NORMAL, 0, 1},
-            {"after_use", "ALIGN HERE 10 ALLOT 42 OVER ! @ . CR", "Should store and retrieve", TEST_NORMAL, 0, 1},
-            {"empty_stack", "ALLOT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE 10 ALLOT HERE SWAP - . CR", "Should print: 10", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "HERE 0 ALLOT HERE SWAP - . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "HERE -4 ALLOT HERE SWAP - . CR", "Should print: -4", TEST_NORMAL, 0, 1, {0}},
+            {"large", "HERE 100 ALLOT HERE SWAP - . CR", "Should print: 100", TEST_NORMAL, 0, 1, {0}},
+            {"after_use", "ALIGN HERE 10 ALLOT 42 OVER ! @ . CR", "Should store and retrieve", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "ALLOT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         ",", {
-            {"basic", "42 , HERE 1 CELLS - @ . CR", "Should compile 42", TEST_NORMAL, 0, 1},
-            {"negative", "-999 , HERE 1 CELLS - @ . CR", "Should compile -999", TEST_NORMAL, 0, 1},
-            {"zero", "0 , HERE 1 CELLS - @ . CR", "Should compile 0", TEST_NORMAL, 0, 1},
-            {"max_int", "2147483647 , HERE 1 CELLS - @ . CR", "Should compile max int", TEST_EDGE_CASE, 0, 1},
-            {"min_int", "-2147483648 , HERE 1 CELLS - @ . CR", "Should compile min int", TEST_EDGE_CASE, 0, 1},
-            {"multiple", "10 , 20 , HERE 1 CELLS - @ . HERE 1 CELLS - @ . CR", "Should compile multiple", TEST_NORMAL, 0, 1},
-            {"empty_stack", ",", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 , HERE 1 CELLS - @ . CR", "Should compile 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-999 , HERE 1 CELLS - @ . CR", "Should compile -999", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 , HERE 1 CELLS - @ . CR", "Should compile 0", TEST_NORMAL, 0, 1, {0}},
+            {"max_int", "2147483647 , HERE 1 CELLS - @ . CR", "Should compile max int", TEST_EDGE_CASE, 0, 1, {0}},
+            {"min_int", "-2147483648 , HERE 1 CELLS - @ . CR", "Should compile min int", TEST_EDGE_CASE, 0, 1, {0}},
+            {"multiple", "10 , 20 , HERE 1 CELLS - @ . HERE 1 CELLS - @ . CR", "Should compile multiple", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", ",", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "C,", {
-            {"basic", "65 C, HERE 1 - C@ . CR", "Should compile byte 65", TEST_NORMAL, 0, 1},
-            {"zero", "0 C, HERE 1 - C@ . CR", "Should compile byte 0", TEST_NORMAL, 0, 1},
-            {"high_byte", "255 C, HERE 1 - C@ . CR", "Should compile byte 255", TEST_NORMAL, 0, 1},
-            {"truncation", "256 C, HERE 1 - C@ . CR", "Should truncate to 0", TEST_NORMAL, 0, 1},
-            {"negative", "-1 C, HERE 1 - C@ . CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"multiple", "65 C, 66 C, HERE 2 - C@ . HERE 1 - C@ . CR", "Should compile multiple", TEST_NORMAL, 0, 1},
-            {"empty_stack", "C,", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "65 C, HERE 1 - C@ . CR", "Should compile byte 65", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 C, HERE 1 - C@ . CR", "Should compile byte 0", TEST_NORMAL, 0, 1, {0}},
+            {"high_byte", "255 C, HERE 1 - C@ . CR", "Should compile byte 255", TEST_NORMAL, 0, 1, {0}},
+            {"truncation", "256 C, HERE 1 - C@ . CR", "Should truncate to 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-1 C, HERE 1 - C@ . CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "65 C, 66 C, HERE 2 - C@ . HERE 1 - C@ . CR", "Should compile multiple", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "C,", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "2,", {
-            {"basic", "12345 67890 2, HERE 2 CELLS - 2@ . . CR", "Should compile double", TEST_NORMAL, 0, 1},
-            {"zero", "0 0 2, HERE 2 CELLS - 2@ . . CR", "Should compile zero double", TEST_NORMAL, 0, 1},
-            {"negative", "-1000 -2000 2, HERE 2 CELLS - 2@ . . CR", "Should compile negative double", TEST_NORMAL, 0, 1},
-            {"large", "2147483647 -1 2, HERE 2 CELLS - 2@ . . CR", "Should compile large double", TEST_EDGE_CASE, 0, 1},
-            {"one_item", "42 2,", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "2,", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "12345 67890 2, HERE 2 CELLS - 2@ . . CR", "Should compile double", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 0 2, HERE 2 CELLS - 2@ . . CR", "Should compile zero double", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-1000 -2000 2, HERE 2 CELLS - 2@ . . CR", "Should compile negative double", TEST_NORMAL, 0, 1, {0}},
+            {"large", "2147483647 -1 2, HERE 2 CELLS - 2@ . . CR", "Should compile large double", TEST_EDGE_CASE, 0, 1, {0}},
+            {"one_item", "42 2,", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "2,", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
     {
         "PAD", {
-            {"basic", "PAD PAD = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"different_from_here", "PAD HERE = . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"stability", "PAD DUP PAD = . CR", "Should be stable", TEST_NORMAL, 0, 1},
-            {"usable", "PAD 42 OVER ! @ . CR", "Should be usable memory", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "PAD PAD = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"different_from_here", "PAD HERE = . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"stability", "PAD DUP PAD = . CR", "Should be stable", TEST_NORMAL, 0, 1, {0}},
+            {"usable", "PAD 42 OVER ! @ . CR", "Should be usable memory", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SP@", {
             // DISABLED: flaky on some architectures, non-deterministic
-            {"basic", "SP@ SP@ = . CR", "Should print: 0 (different after push)", TEST_NORMAL, 0, 0},
-            {"depth_effect", "42 SP@ SWAP DROP SP@ = . CR", "Should show stack effect", TEST_NORMAL, 0, 1},
-            {"empty_stack", "DEPTH 0= SP@ AND . CR", "Should work on empty stack", TEST_NORMAL, 0, 1},
+            {"basic", "SP@ SP@ = . CR", "Should print: 0 (different after push)", TEST_NORMAL, 0, 0, {0}},
+            {"depth_effect", "42 SP@ SWAP DROP SP@ = . CR", "Should show stack effect", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "DEPTH 0= SP@ AND . CR", "Should work on empty stack", TEST_NORMAL, 0, 1, {0}},
             {
                 "multiple_items", "1 2 3 SP@ SWAP DROP SWAP DROP SWAP DROP SP@ = . CR", "Should track changes",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SP!", {
-            {"basic_restore", "1 2 3 SP@ 4 5 6 DROP DROP DROP SP! DEPTH .", "Should restore stack", TEST_NORMAL, 0, 1},
-            {"invalid_addr", "0 SP!", "Should cause error", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "SP!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic_restore", "1 2 3 SP@ 4 5 6 DROP DROP DROP SP! DEPTH .", "Should restore stack", TEST_NORMAL, 0, 1, {0}},
+            {"invalid_addr", "0 SP!", "Should cause error", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "SP!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "LATEST", {
-            {"basic", "LATEST LATEST = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"stability", "LATEST DUP LATEST = . CR", "Should be stable", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "LATEST LATEST = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"stability", "LATEST DUP LATEST = . CR", "Should be stable", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "COMPILATION", {
             {
                 "here_comma_sequence", "HERE 10 , 20 , 30 , HERE SWAP - 12 = . CR", "Should advance HERE by 12",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "mixed_compilation", "HERE 42 , 65 C, 100 200 2, HERE SWAP - 13 = . CR", "Should advance correctly",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             }, // MAY FAIL on non-4-byte platforms
             {
                 "allot_comma_combo", "HERE 10 ALLOT 99 , HERE SWAP - 14 = . CR", "Should combine allot and comma",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"pad_isolation", "PAD 999 OVER ! HERE 42 , PAD @ 999 = . CR", "PAD should be isolated", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"pad_isolation", "PAD 999 OVER ! HERE 42 , PAD @ 999 = . CR", "PAD should be isolated", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "STACK_MGMT", {
-            {"sp_round_trip", "42 43 SP@ >R 44 45 R> SP! . . CR", "Should print: 43 42", TEST_NORMAL, 0, 1},
+            {"sp_round_trip", "42 43 SP@ >R 44 45 R> SP! . . CR", "Should print: 43 42", TEST_NORMAL, 0, 1, {0}},
             {
                 "depth_preservation", "1 2 3 DEPTH >R SP@ >R 4 5 6 R> SP! R> DEPTH = . CR", "Should preserve depth",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/double_words_test.c b/src/test_runner/modules/double_words_test.c
index 6375ac6..da3684a 100644
--- a/src/test_runner/modules/double_words_test.c
+++ b/src/test_runner/modules/double_words_test.c
@@ -47,244 +47,244 @@
 static WordTestSuite double_word_suites[] = {
     {
         "2DROP", {
-            {"basic", "1 2 3 4 2DROP . . CR", "Should print: 1 2", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 42 99 2DROP . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"negative", "-1 -2 100 200 2DROP . . CR", "Should print: -1 -2", TEST_NORMAL, 0, 1},
-            {"exact_four", "10 20 30 40 2DROP DEPTH . CR", "Should print: 2", TEST_NORMAL, 0, 1},
-            {"empty_stack", "2DROP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 2DROP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 2 3 4 2DROP . . CR", "Should print: 1 2", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 42 99 2DROP . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-1 -2 100 200 2DROP . . CR", "Should print: -1 -2", TEST_NORMAL, 0, 1, {0}},
+            {"exact_four", "10 20 30 40 2DROP DEPTH . CR", "Should print: 2", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "2DROP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 2DROP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "2DUP", {
-            {"basic", "100 200 2DUP . . . . CR", "Should print: 100 200 100 200", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 2DUP . . . . CR", "Should print: 0 0 0 0", TEST_NORMAL, 0, 1},
-            {"negative", "-100 -200 2DUP . . . . CR", "Should duplicate negatives", TEST_NORMAL, 0, 1},
-            {"depth_check", "10 20 2DUP DEPTH . CR", "Should print: 4", TEST_NORMAL, 0, 1},
-            {"empty_stack", "2DUP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 2DUP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "100 200 2DUP . . . . CR", "Should print: 100 200 100 200", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 2DUP . . . . CR", "Should print: 0 0 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-100 -200 2DUP . . . . CR", "Should duplicate negatives", TEST_NORMAL, 0, 1, {0}},
+            {"depth_check", "10 20 2DUP DEPTH . CR", "Should print: 4", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "2DUP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 2DUP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "2OVER", {
-            {"basic", "10 20 30 40 2OVER . . . . . . CR", "Should print: 10 20 30 40 10 20", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 99 88 2OVER . . . . . . CR", "Should print: 0 0 99 88 0 0", TEST_NORMAL, 0, 1},
-            {"mixed", "-1 2 -3 4 2OVER . . . . . . CR", "Should handle mixed signs", TEST_NORMAL, 0, 1},
-            {"depth_check", "1 2 3 4 2OVER DEPTH . CR", "Should print: 6", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 2OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "2OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "10 20 30 40 2OVER . . . . . . CR", "Should print: 10 20 30 40 10 20", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 99 88 2OVER . . . . . . CR", "Should print: 0 0 99 88 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"mixed", "-1 2 -3 4 2OVER . . . . . . CR", "Should handle mixed signs", TEST_NORMAL, 0, 1, {0}},
+            {"depth_check", "1 2 3 4 2OVER DEPTH . CR", "Should print: 6", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 2OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "2OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "2SWAP", {
-            {"basic", "10 20 30 40 2SWAP . . . . CR", "Should print: 30 40 10 20", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 99 88 2SWAP . . . . CR", "Should print: 99 88 0 0", TEST_NORMAL, 0, 1},
-            {"same_pairs", "42 42 42 42 2SWAP . . . . CR", "Should print: 42 42 42 42", TEST_NORMAL, 0, 1},
-            {"negative", "-10 -20 30 40 2SWAP . . . . CR", "Should print: 30 40 -10 -20", TEST_NORMAL, 0, 1},
-            {"depth_check", "1 2 3 4 2SWAP DEPTH . CR", "Should print: 4", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 2SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "2SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "10 20 30 40 2SWAP . . . . CR", "Should print: 30 40 10 20", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 99 88 2SWAP . . . . CR", "Should print: 99 88 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"same_pairs", "42 42 42 42 2SWAP . . . . CR", "Should print: 42 42 42 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-10 -20 30 40 2SWAP . . . . CR", "Should print: 30 40 -10 -20", TEST_NORMAL, 0, 1, {0}},
+            {"depth_check", "1 2 3 4 2SWAP DEPTH . CR", "Should print: 4", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 2SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "2SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "2ROT", {
-            {"basic", "10 20 30 40 50 60 2ROT . . . . . . CR", "Should print: 30 40 50 60 10 20", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 1 1 2 2 2ROT . . . . . . CR", "Should rotate with zeros", TEST_NORMAL, 0, 1},
-            {"negative", "-1 -2 3 4 -5 -6 2ROT . . . . . . CR", "Should handle negatives", TEST_NORMAL, 0, 1},
-            {"depth_check", "1 2 3 4 5 6 2ROT DEPTH . CR", "Should print: 6", TEST_NORMAL, 0, 1},
-            {"five_items", "1 2 3 4 5 2ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "2ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "10 20 30 40 50 60 2ROT . . . . . . CR", "Should print: 30 40 50 60 10 20", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 1 1 2 2 2ROT . . . . . . CR", "Should rotate with zeros", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-1 -2 3 4 -5 -6 2ROT . . . . . . CR", "Should handle negatives", TEST_NORMAL, 0, 1, {0}},
+            {"depth_check", "1 2 3 4 5 6 2ROT DEPTH . CR", "Should print: 6", TEST_NORMAL, 0, 1, {0}},
+            {"five_items", "1 2 3 4 5 2ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "2ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "D+", {
-            {"basic", "100 200 300 400 D+ . . CR", "Should print: 400 600", TEST_NORMAL, 0, 1},
-            {"zero_add", "42 99 0 0 D+ . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1},
-            {"negative", "-100 -200 50 75 D+ . . CR", "Should handle negatives", TEST_NORMAL, 0, 1},
-            {"carry", "2147483647 0 1 0 D+ . . CR", "Should handle carry", TEST_EDGE_CASE, 0, 1},
-            {"both_negative", "-100 -200 -300 -400 D+ . . CR", "Should add negatives", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 D+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "D+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "100 200 300 400 D+ . . CR", "Should print: 400 600", TEST_NORMAL, 0, 1, {0}},
+            {"zero_add", "42 99 0 0 D+ . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-100 -200 50 75 D+ . . CR", "Should handle negatives", TEST_NORMAL, 0, 1, {0}},
+            {"carry", "2147483647 0 1 0 D+ . . CR", "Should handle carry", TEST_EDGE_CASE, 0, 1, {0}},
+            {"both_negative", "-100 -200 -300 -400 D+ . . CR", "Should add negatives", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 D+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "D+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "D-", {
-            {"basic", "500 600 100 200 D- . . CR", "Should print: 400 400", TEST_NORMAL, 0, 1},
-            {"zero_sub", "42 99 0 0 D- . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1},
-            {"from_zero", "0 0 100 200 D- . . CR", "Should print: -100 -200", TEST_NORMAL, 0, 1},
-            {"negative", "100 200 -50 -75 D- . . CR", "Should handle negatives", TEST_NORMAL, 0, 1},
-            {"borrow", "0 0 1 0 D- . . CR", "Should handle borrow", TEST_EDGE_CASE, 0, 1},
-            {"same_values", "100 200 100 200 D- . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 D-", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "D-", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "500 600 100 200 D- . . CR", "Should print: 400 400", TEST_NORMAL, 0, 1, {0}},
+            {"zero_sub", "42 99 0 0 D- . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1, {0}},
+            {"from_zero", "0 0 100 200 D- . . CR", "Should print: -100 -200", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "100 200 -50 -75 D- . . CR", "Should handle negatives", TEST_NORMAL, 0, 1, {0}},
+            {"borrow", "0 0 1 0 D- . . CR", "Should handle borrow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"same_values", "100 200 100 200 D- . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 D-", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "D-", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "DNEGATE", {
-            {"positive", "100 200 DNEGATE . . CR", "Should negate positive double", TEST_NORMAL, 0, 1},
-            {"negative", "-100 -200 DNEGATE . . CR", "Should negate negative double", TEST_NORMAL, 0, 1},
-            {"zero", "0 0 DNEGATE . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"max_positive", "2147483647 0 DNEGATE . . CR", "Should negate max positive", TEST_EDGE_CASE, 0, 1},
-            {"one_item", "42 DNEGATE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "DNEGATE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive", "100 200 DNEGATE . . CR", "Should negate positive double", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-100 -200 DNEGATE . . CR", "Should negate negative double", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 0 DNEGATE . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"max_positive", "2147483647 0 DNEGATE . . CR", "Should negate max positive", TEST_EDGE_CASE, 0, 1, {0}},
+            {"one_item", "42 DNEGATE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "DNEGATE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "DABS", {
-            {"positive", "100 200 DABS . . CR", "Should print: 100 200", TEST_NORMAL, 0, 1},
-            {"negative", "-100 -200 DABS . . CR", "Should print: 100 200", TEST_NORMAL, 0, 1},
-            {"zero", "0 0 DABS . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"mixed_sign", "100 -1 DABS . . CR", "Should handle mixed sign", TEST_NORMAL, 0, 1},
-            {"min_double", "-2147483648 -1 DABS . . CR", "Should handle min double", TEST_EDGE_CASE, 0, 1},
-            {"one_item", "42 DABS", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "DABS", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive", "100 200 DABS . . CR", "Should print: 100 200", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-100 -200 DABS . . CR", "Should print: 100 200", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 0 DABS . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"mixed_sign", "100 -1 DABS . . CR", "Should handle mixed sign", TEST_NORMAL, 0, 1, {0}},
+            {"min_double", "-2147483648 -1 DABS . . CR", "Should handle min double", TEST_EDGE_CASE, 0, 1, {0}},
+            {"one_item", "42 DABS", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "DABS", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "DMIN", {
-            {"basic", "100 200 300 400 DMIN . . CR", "Should print: 100 200", TEST_NORMAL, 0, 1},
-            {"equal", "42 99 42 99 DMIN . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1},
-            {"negative", "-100 -200 -50 -75 DMIN . . CR", "Should find min negative", TEST_NORMAL, 0, 1},
-            {"mixed", "-100 -1 100 0 DMIN . . CR", "Should handle mixed signs", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 DMIN", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "DMIN", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "100 200 300 400 DMIN . . CR", "Should print: 100 200", TEST_NORMAL, 0, 1, {0}},
+            {"equal", "42 99 42 99 DMIN . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-100 -200 -50 -75 DMIN . . CR", "Should find min negative", TEST_NORMAL, 0, 1, {0}},
+            {"mixed", "-100 -1 100 0 DMIN . . CR", "Should handle mixed signs", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 DMIN", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "DMIN", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "DMAX", {
-            {"basic", "100 200 300 400 DMAX . . CR", "Should print: 300 400", TEST_NORMAL, 0, 1},
-            {"equal", "42 99 42 99 DMAX . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1},
-            {"negative", "-300 -400 -100 -200 DMAX . . CR", "Should find max negative", TEST_NORMAL, 0, 1},
-            {"mixed", "-100 -1 100 0 DMAX . . CR", "Should handle mixed signs", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 DMAX", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "DMAX", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "100 200 300 400 DMAX . . CR", "Should print: 300 400", TEST_NORMAL, 0, 1, {0}},
+            {"equal", "42 99 42 99 DMAX . . CR", "Should print: 42 99", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-300 -400 -100 -200 DMAX . . CR", "Should find max negative", TEST_NORMAL, 0, 1, {0}},
+            {"mixed", "-100 -1 100 0 DMAX . . CR", "Should handle mixed signs", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 DMAX", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "DMAX", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "D=", {
-            {"equal", "100 200 100 200 D= . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"not_equal_low", "100 200 101 200 D= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"not_equal_high", "100 200 100 201 D= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"zero_equal", "0 0 0 0 D= . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative_equal", "-100 -200 -100 -200 D= . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 D=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "D=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"equal", "100 200 100 200 D= . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"not_equal_low", "100 200 101 200 D= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"not_equal_high", "100 200 100 201 D= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"zero_equal", "0 0 0 0 D= . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative_equal", "-100 -200 -100 -200 D= . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 D=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "D=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "D<", {
-            {"less_than", "100 200 300 400 D< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"greater_than", "300 400 100 200 D< . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"equal", "100 200 100 200 D< . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative_positive", "-100 -1 100 0 D< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative_negative", "-300 -1 -100 -1 D< . CR", "Should compare negatives", TEST_NORMAL, 0, 1},
-            {"high_word_diff", "100 200 100 300 D< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"three_items", "1 2 3 D<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "D<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"less_than", "100 200 300 400 D< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"greater_than", "300 400 100 200 D< . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"equal", "100 200 100 200 D< . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative_positive", "-100 -1 100 0 D< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative_negative", "-300 -1 -100 -1 D< . CR", "Should compare negatives", TEST_NORMAL, 0, 1, {0}},
+            {"high_word_diff", "100 200 100 300 D< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"three_items", "1 2 3 D<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "D<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "D0=", {
-            {"zero", "0 0 D0= . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"positive", "100 200 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "-100 -200 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"zero_high", "0 100 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"zero_low", "100 0 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"one_item", "42 D0=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "D0=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"zero", "0 0 D0= . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"positive", "100 200 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-100 -200 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"zero_high", "0 100 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"zero_low", "100 0 D0= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "42 D0=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "D0=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "D0<", {
-            {"negative", "-100 -1 D0< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"zero", "0 0 D0< . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"positive", "100 0 D0< . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative_high_only", "100 -1 D0< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"large_negative", "-1 -1 D0< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"one_item", "42 D0<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "D0<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"negative", "-100 -1 D0< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 0 D0< . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"positive", "100 0 D0< . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative_high_only", "100 -1 D0< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"large_negative", "-1 -1 D0< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "42 D0<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "D0<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "S>D", {
-            {"positive",    "5 S>D . . CR",          "Should sign-extend positive: 0 5",         TEST_NORMAL,     0, 1},
-            {"negative",    "-5 S>D . . CR",         "Should sign-extend negative: -1 -5",       TEST_NORMAL,     0, 1},
-            {"zero",        "0 S>D . . CR",          "Should sign-extend zero: 0 0",             TEST_NORMAL,     0, 1},
-            {"max_int",     "2147483647 S>D . . CR", "Should extend max int: 0 2147483647",      TEST_EDGE_CASE,  0, 1},
-            {"min_int",     "-2147483648 S>D . . CR","Should extend min int: -1 -2147483648",    TEST_EDGE_CASE,  0, 1},
-            {"empty_stack", "S>D",                   "Should cause stack underflow",             TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive",    "5 S>D . . CR",          "Should sign-extend positive: 0 5",         TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-5 S>D . . CR",         "Should sign-extend negative: -1 -5",       TEST_NORMAL,     0, 1, {0}},
+            {"zero",        "0 S>D . . CR",          "Should sign-extend zero: 0 0",             TEST_NORMAL,     0, 1, {0}},
+            {"max_int",     "2147483647 S>D . . CR", "Should extend max int: 0 2147483647",      TEST_EDGE_CASE,  0, 1, {0}},
+            {"min_int",     "-2147483648 S>D . . CR","Should extend min int: -1 -2147483648",    TEST_EDGE_CASE,  0, 1, {0}},
+            {"empty_stack", "S>D",                   "Should cause stack underflow",             TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "D2*", {
-            {"basic",       "5 0 D2* . . CR",     "Should double 5: 0 10",               TEST_NORMAL,     0, 1},
-            {"zero",        "0 0 D2* . . CR",     "Should double zero: 0 0",             TEST_NORMAL,     0, 1},
-            {"negative",    "-1 -1 D2* . . CR",   "Should double -1: -1 -2",            TEST_NORMAL,     0, 1},
-            {"carry",       "0 1 D2* . . CR",     "Should shift high cell: 0 2",        TEST_EDGE_CASE,  0, 1},
-            {"empty_stack", "D2*",                "Should cause stack underflow",        TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "5 0 D2* . . CR",     "Should double 5: 0 10",               TEST_NORMAL,     0, 1, {0}},
+            {"zero",        "0 0 D2* . . CR",     "Should double zero: 0 0",             TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-1 -1 D2* . . CR",   "Should double -1: -1 -2",            TEST_NORMAL,     0, 1, {0}},
+            {"carry",       "0 1 D2* . . CR",     "Should shift high cell: 0 2",        TEST_EDGE_CASE,  0, 1, {0}},
+            {"empty_stack", "D2*",                "Should cause stack underflow",        TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "D2/", {
-            {"basic",       "10 0 D2/ . . CR",   "Should halve 10: 0 5",                TEST_NORMAL,     0, 1},
-            {"negative",    "-2 -1 D2/ . . CR",  "Should halve -2: -1 -1",             TEST_NORMAL,     0, 1},
-            {"zero",        "0 0 D2/ . . CR",    "Should halve zero: 0 0",              TEST_NORMAL,     0, 1},
-            {"odd",         "3 0 D2/ . . CR",    "Should truncate toward zero: 0 1",    TEST_EDGE_CASE,  0, 1},
-            {"empty_stack", "D2/",               "Should cause stack underflow",         TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "10 0 D2/ . . CR",   "Should halve 10: 0 5",                TEST_NORMAL,     0, 1, {0}},
+            {"negative",    "-2 -1 D2/ . . CR",  "Should halve -2: -1 -1",             TEST_NORMAL,     0, 1, {0}},
+            {"zero",        "0 0 D2/ . . CR",    "Should halve zero: 0 0",              TEST_NORMAL,     0, 1, {0}},
+            {"odd",         "3 0 D2/ . . CR",    "Should truncate toward zero: 0 1",    TEST_EDGE_CASE,  0, 1, {0}},
+            {"empty_stack", "D2/",               "Should cause stack underflow",         TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
@@ -293,36 +293,36 @@ static WordTestSuite double_word_suites[] = {
          * inside a colon definition, it would increment rsp and the loop would
          * dereference the pushed data value as a pointer — same model as >R tests. */
         "2>R", {
-            {"roundtrip",   "10 20 2>R 2R> . . CR",              "Should store and retrieve: 20 10",  TEST_NORMAL,     0, 1},
-            {"depth_after", "1 2 2>R DEPTH . 2R> DROP DROP CR",  "Should empty data stack: 0",        TEST_NORMAL,     0, 1},
-            {"empty_stack", "2>R",                                "Should cause stack underflow",      TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"roundtrip",   "10 20 2>R 2R> . . CR",              "Should store and retrieve: 20 10",  TEST_NORMAL,     0, 1, {0}},
+            {"depth_after", "1 2 2>R DEPTH . 2R> DROP DROP CR",  "Should empty data stack: 0",        TEST_NORMAL,     0, 1, {0}},
+            {"empty_stack", "2>R",                                "Should cause stack underflow",      TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "2R>", {
-            {"roundtrip",   "5 6 2>R 2R> . . CR",           "Should retrieve double: 6 5",              TEST_NORMAL,     0, 1},
-            {"depth",       "9 8 2>R 2R> DEPTH . CR",       "Should push 2 items to data stack: 2",     TEST_NORMAL,     0, 1},
-            {"empty_rstack","2R>",                           "Should cause return stack underflow",      TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"roundtrip",   "5 6 2>R 2R> . . CR",           "Should retrieve double: 6 5",              TEST_NORMAL,     0, 1, {0}},
+            {"depth",       "9 8 2>R 2R> DEPTH . CR",       "Should push 2 items to data stack: 2",     TEST_NORMAL,     0, 1, {0}},
+            {"empty_rstack","2R>",                           "Should cause return stack underflow",      TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "2R@", {
-            {"peek",            "3 4 2>R 2R@ . . 2R> DROP DROP CR",     "Should peek: 4 3",             TEST_NORMAL,     0, 1},
-            {"non_destructive", "7 8 2>R 2R@ DROP DROP 2R> . . CR",     "Should leave rstack intact",   TEST_NORMAL,     0, 1},
-            {"empty_rstack",    "2R@",                                   "Should cause return stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"peek",            "3 4 2>R 2R@ . . 2R> DROP DROP CR",     "Should peek: 4 3",             TEST_NORMAL,     0, 1, {0}},
+            {"non_destructive", "7 8 2>R 2R@ DROP DROP 2R> . . CR",     "Should leave rstack intact",   TEST_NORMAL,     0, 1, {0}},
+            {"empty_rstack",    "2R@",                                   "Should cause return stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/format_words_test.c b/src/test_runner/modules/format_words_test.c
index f279790..5d9270e 100644
--- a/src/test_runner/modules/format_words_test.c
+++ b/src/test_runner/modules/format_words_test.c
@@ -50,107 +50,107 @@
 static WordTestSuite format_word_suites[] = {
     {
         "BASE", {
-            {"decimal", "DECIMAL 42 . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"hex", "HEX FF . CR", "Should print: FF", TEST_NORMAL, 0, 1},
-            {"octal", "OCTAL 52 . CR", "Should print: 52", TEST_NORMAL, 0, 1},
-            {"base_store", "16 BASE ! 255 . CR", "Should print: FF", TEST_NORMAL, 0, 1},
-            {"base_fetch", "BASE @ . CR", "Should print current base", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"decimal", "DECIMAL 42 . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"hex", "HEX FF . CR", "Should print: FF", TEST_NORMAL, 0, 1, {0}},
+            {"octal", "OCTAL 52 . CR", "Should print: 52", TEST_NORMAL, 0, 1, {0}},
+            {"base_store", "16 BASE ! 255 . CR", "Should print: FF", TEST_NORMAL, 0, 1, {0}},
+            {"base_fetch", "BASE @ . CR", "Should print current base", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "DECIMAL", {
-            {"from_hex", "HEX FF DECIMAL . CR", "Should print: 255", TEST_NORMAL, 0, 1},
-            {"from_octal", "OCTAL 52 DECIMAL . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"state_persist", "DECIMAL 42 . CR 42 . CR HEX 42 . CR", "Should maintain base", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"from_hex", "HEX FF DECIMAL . CR", "Should print: 255", TEST_NORMAL, 0, 1, {0}},
+            {"from_octal", "OCTAL 52 DECIMAL . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"state_persist", "DECIMAL 42 . CR 42 . CR HEX 42 . CR", "Should maintain base", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "HEX", {
-            {"from_decimal", "DECIMAL 255 HEX . CR", "Should print: FF", TEST_NORMAL, 0, 1},
-            {"from_octal", "OCTAL 52 HEX . CR", "Should print: 2A", TEST_NORMAL, 0, 1},
-            {"state_persist", "HEX FF . CR DECIMAL 255 . CR", "Should maintain base", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"from_decimal", "DECIMAL 255 HEX . CR", "Should print: FF", TEST_NORMAL, 0, 1, {0}},
+            {"from_octal", "OCTAL 52 HEX . CR", "Should print: 2A", TEST_NORMAL, 0, 1, {0}},
+            {"state_persist", "HEX FF . CR DECIMAL 255 . CR", "Should maintain base", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "OCTAL", {
-            {"from_decimal", "DECIMAL 42 OCTAL . CR", "Should print: 52", TEST_NORMAL, 0, 1},
-            {"from_hex", "HEX 2A OCTAL . CR", "Should print: 52", TEST_NORMAL, 0, 1},
-            {"state_persist", "DECIMAL 42 . CR OCTAL 52 . CR", "Should maintain base", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"from_decimal", "DECIMAL 42 OCTAL . CR", "Should print: 52", TEST_NORMAL, 0, 1, {0}},
+            {"from_hex", "HEX 2A OCTAL . CR", "Should print: 52", TEST_NORMAL, 0, 1, {0}},
+            {"state_persist", "DECIMAL 42 . CR OCTAL 52 . CR", "Should maintain base", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "<#", {
-            {"basic", "DECIMAL 42 S>D <# #S #> TYPE CR", "Should format number", TEST_NORMAL, 0, 1},
-            {"empty", "0 <# #> TYPE CR", "Should handle zero", TEST_NORMAL, 0, 1},
-            {"negative", "-42 <# #S #> TYPE CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "DECIMAL 42 S>D <# #S #> TYPE CR", "Should format number", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "0 <# #> TYPE CR", "Should handle zero", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 <# #S #> TYPE CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "#", {
-            {"single_digit", "15 <# # #> TYPE CR", "Should print rightmost digit", TEST_NORMAL, 0, 1},
-            {"multiple", "15 <# # # #> TYPE CR", "Should print digits right to left", TEST_NORMAL, 0, 1},
-            {"zero_pad", "5 <# # 0 # #> TYPE CR", "Should handle zero padding", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"single_digit", "15 <# # #> TYPE CR", "Should print rightmost digit", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "15 <# # # #> TYPE CR", "Should print digits right to left", TEST_NORMAL, 0, 1, {0}},
+            {"zero_pad", "5 <# # 0 # #> TYPE CR", "Should handle zero padding", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "#S", {
-            {"basic", "42 <# #S #> TYPE CR", "Should convert all digits", TEST_NORMAL, 0, 1},
-            {"zero", "0 <# #S #> TYPE CR", "Should handle zero", TEST_NORMAL, 0, 1},
-            {"large", "1234567890 <# #S #> TYPE CR", "Should handle large numbers", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 <# #S #> TYPE CR", "Should convert all digits", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 <# #S #> TYPE CR", "Should handle zero", TEST_NORMAL, 0, 1, {0}},
+            {"large", "1234567890 <# #S #> TYPE CR", "Should handle large numbers", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "SIGN", {
-            {"negative", "-42 ABS <# #S SIGN #> TYPE CR", "Should add minus", TEST_NORMAL, 0, 1},
-            {"positive", "42 <# #S SIGN #> TYPE CR", "Should not add sign", TEST_NORMAL, 0, 1},
-            {"zero", "0 <# #S SIGN #> TYPE CR", "Should handle zero", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"negative", "-42 ABS <# #S SIGN #> TYPE CR", "Should add minus", TEST_NORMAL, 0, 1, {0}},
+            {"positive", "42 <# #S SIGN #> TYPE CR", "Should not add sign", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 <# #S SIGN #> TYPE CR", "Should handle zero", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "#>", {
-            {"normal", "42 <# #S #> TYPE CR", "Should terminate formatting", TEST_NORMAL, 0, 1},
-            {"empty", "0 <# #> TYPE CR", "Should handle empty format", TEST_NORMAL, 0, 1},
-            {"stack_effect", "42 <# #S #> SWAP . . CR", "Should leave addr u", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"normal", "42 <# #S #> TYPE CR", "Should terminate formatting", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "0 <# #> TYPE CR", "Should handle empty format", TEST_NORMAL, 0, 1, {0}},
+            {"stack_effect", "42 <# #S #> SWAP . . CR", "Should leave addr u", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "HOLD", {
-            {"basic", "42 <# 46 HOLD #S #> TYPE CR", "Should insert dot", TEST_NORMAL, 0, 1},
-            {"overflow", "<# 257 HOLD #>", "Should handle overflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 <# 46 HOLD #S #> TYPE CR", "Should insert dot", TEST_NORMAL, 0, 1, {0}},
+            {"overflow", "<# 257 HOLD #>", "Should handle overflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/integration_tests.c b/src/test_runner/modules/integration_tests.c
index 888be8c..02df1fb 100644
--- a/src/test_runner/modules/integration_tests.c
+++ b/src/test_runner/modules/integration_tests.c
@@ -69,7 +69,7 @@ static WordTestSuite integration_suites[] = {
                 "; "
                 "17 PRIME? . CR",
                 "Prime number checker",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "array_sum",
@@ -89,7 +89,7 @@ static WordTestSuite integration_suites[] = {
                 "; "
                 "STORE-NUMS SUM-NUMS . CR",
                 "Array sum program",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "fizzbuzz_mini",
@@ -103,7 +103,7 @@ static WordTestSuite integration_suites[] = {
                 "; "
                 "15 FIZZBUZZ CR",
                 "FizzBuzz for 15",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "calculator",
@@ -116,11 +116,11 @@ static WordTestSuite integration_suites[] = {
                 "; "
                 "CALC",
                 "Simple calculator",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
     {
         "DATA_STRUCTURES", {
@@ -146,7 +146,7 @@ static WordTestSuite integration_suites[] = {
                 "30 NODE DROP "
                 "PRINT-LIST",
                 "Simple linked list",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "stack_min_max",
@@ -164,11 +164,11 @@ static WordTestSuite integration_suites[] = {
                 "99 UPDATE-MINMAX "
                 "MIN @ . MAX @ . CR",
                 "Min/Max tracker",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
     {
         "ALGORITHMS", {
@@ -186,7 +186,7 @@ static WordTestSuite integration_suites[] = {
                 "A B SWAP-IF-NEEDED "
                 "A @ . B @ . CR",
                 "Swap if needed (sort helper)",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "gcd",
@@ -197,11 +197,11 @@ static WordTestSuite integration_suites[] = {
                 "; "
                 "48 18 GCD . CR",
                 "Greatest Common Divisor",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 };
 
diff --git a/src/test_runner/modules/io_words_test.c b/src/test_runner/modules/io_words_test.c
index 991e71e..b6aa018 100644
--- a/src/test_runner/modules/io_words_test.c
+++ b/src/test_runner/modules/io_words_test.c
@@ -51,220 +51,220 @@
 static WordTestSuite io_word_suites[] = {
     {
         ".", {
-            {"positive", "42 . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"negative", "-42 . CR", "Should print: -42", TEST_NORMAL, 0, 1},
-            {"zero", "0 . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"max_int", "2147483647 . CR", "Should print: 2147483647", TEST_EDGE_CASE, 0, 1},
-            {"min_int", "-2147483648 . CR", "Should print: -2147483648", TEST_EDGE_CASE, 0, 1},
-            {"multiple", "1 2 3 . . . CR", "Should print: 3 2 1", TEST_NORMAL, 0, 1},
-            {"empty_stack", ".", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive", "42 . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 . CR", "Should print: -42", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"max_int", "2147483647 . CR", "Should print: 2147483647", TEST_EDGE_CASE, 0, 1, {0}},
+            {"min_int", "-2147483648 . CR", "Should print: -2147483648", TEST_EDGE_CASE, 0, 1, {0}},
+            {"multiple", "1 2 3 . . . CR", "Should print: 3 2 1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", ".", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "CR", {
-            {"basic", "42 . CR 43 . CR", "Should print on separate lines", TEST_NORMAL, 0, 1},
-            {"multiple", "CR CR CR", "Should print multiple newlines", TEST_NORMAL, 0, 1},
-            {"no_stack_effect", "DEPTH CR DEPTH = . CR", "Should not affect stack", TEST_NORMAL, 0, 1},
-            {"after_output", "1 2 3 . . . CR", "Should work after output", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 . CR 43 . CR", "Should print on separate lines", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "CR CR CR", "Should print multiple newlines", TEST_NORMAL, 0, 1, {0}},
+            {"no_stack_effect", "DEPTH CR DEPTH = . CR", "Should not affect stack", TEST_NORMAL, 0, 1, {0}},
+            {"after_output", "1 2 3 . . . CR", "Should work after output", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SPACE", {
-            {"basic", "42 . SPACE 43 . CR", "Should add space between numbers", TEST_NORMAL, 0, 1},
-            {"multiple", "SPACE SPACE SPACE", "Should print multiple spaces", TEST_NORMAL, 0, 1},
-            {"no_stack_effect", "DEPTH SPACE DEPTH = . CR", "Should not affect stack", TEST_NORMAL, 0, 1},
-            {"with_text", "65 EMIT SPACE 66 EMIT CR", "Should space between chars", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 . SPACE 43 . CR", "Should add space between numbers", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "SPACE SPACE SPACE", "Should print multiple spaces", TEST_NORMAL, 0, 1, {0}},
+            {"no_stack_effect", "DEPTH SPACE DEPTH = . CR", "Should not affect stack", TEST_NORMAL, 0, 1, {0}},
+            {"with_text", "65 EMIT SPACE 66 EMIT CR", "Should space between chars", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SPACES", {
-            {"zero", "0 SPACES", "Should print no spaces", TEST_NORMAL, 0, 1},
-            {"one", "1 SPACES", "Should print one space", TEST_NORMAL, 0, 1},
-            {"multiple", "5 SPACES", "Should print five spaces", TEST_NORMAL, 0, 1},
-            {"large", "20 SPACES", "Should print twenty spaces", TEST_NORMAL, 0, 1},
-            {"negative", "-5 SPACES", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"with_output", "42 . 3 SPACES 43 . CR", "Should space output", TEST_NORMAL, 0, 1},
-            {"empty_stack", "SPACES", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"zero", "0 SPACES", "Should print no spaces", TEST_NORMAL, 0, 1, {0}},
+            {"one", "1 SPACES", "Should print one space", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "5 SPACES", "Should print five spaces", TEST_NORMAL, 0, 1, {0}},
+            {"large", "20 SPACES", "Should print twenty spaces", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-5 SPACES", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"with_output", "42 . 3 SPACES 43 . CR", "Should space output", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "SPACES", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "EMIT", {
-            {"letter_A", "65 EMIT CR", "Should print: A", TEST_NORMAL, 0, 1},
-            {"letter_Z", "90 EMIT CR", "Should print: Z", TEST_NORMAL, 0, 1},
-            {"digit", "48 EMIT CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"space_char", "32 EMIT CR", "Should print space", TEST_NORMAL, 0, 1},
-            {"newline", "10 EMIT", "Should print newline", TEST_NORMAL, 0, 1},
-            {"high_ascii", "127 EMIT CR", "Should print DEL char", TEST_NORMAL, 0, 1},
-            {"truncation", "321 EMIT CR", "Should truncate to low byte", TEST_NORMAL, 0, 1},
-            {"negative", "-1 EMIT CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"sequence", "72 EMIT 73 EMIT 10 EMIT", "Should print: HI", TEST_NORMAL, 0, 1},
-            {"empty_stack", "EMIT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"letter_A", "65 EMIT CR", "Should print: A", TEST_NORMAL, 0, 1, {0}},
+            {"letter_Z", "90 EMIT CR", "Should print: Z", TEST_NORMAL, 0, 1, {0}},
+            {"digit", "48 EMIT CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"space_char", "32 EMIT CR", "Should print space", TEST_NORMAL, 0, 1, {0}},
+            {"newline", "10 EMIT", "Should print newline", TEST_NORMAL, 0, 1, {0}},
+            {"high_ascii", "127 EMIT CR", "Should print DEL char", TEST_NORMAL, 0, 1, {0}},
+            {"truncation", "321 EMIT CR", "Should truncate to low byte", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-1 EMIT CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"sequence", "72 EMIT 73 EMIT 10 EMIT", "Should print: HI", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "EMIT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        10
+        10, {0}
     },
 
     {
         "KEY", {
-            {"basic_test", "KEY DROP", "Should wait for keypress", TEST_NORMAL, 0, 0},
-            {"echo_test", "KEY DUP EMIT CR", "Should echo keypresses", TEST_NORMAL, 0, 0},
-            {"multiple", "KEY KEY KEY DROP DROP DROP", "Should read multiple keys", TEST_NORMAL, 0, 0},
-            {"no_stack_underflow", "KEY . CR", "Should push key to stack", TEST_NORMAL, 0, 0},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic_test", "KEY DROP", "Should wait for keypress", TEST_NORMAL, 0, 0, {0}},
+            {"echo_test", "KEY DUP EMIT CR", "Should echo keypresses", TEST_NORMAL, 0, 0, {0}},
+            {"multiple", "KEY KEY KEY DROP DROP DROP", "Should read multiple keys", TEST_NORMAL, 0, 0, {0}},
+            {"no_stack_underflow", "KEY . CR", "Should push key to stack", TEST_NORMAL, 0, 0, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "?KEY", {
-            {"available_test", "?KEY . CR", "Should test key availability", TEST_NORMAL, 0, 0},
-            {"no_wait", "?KEY IF KEY EMIT THEN CR", "Should not wait", TEST_NORMAL, 0, 0},
-            {"multiple_check", "?KEY ?KEY OR . CR", "Should check availability", TEST_NORMAL, 0, 0},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"available_test", "?KEY . CR", "Should test key availability", TEST_NORMAL, 0, 0, {0}},
+            {"no_wait", "?KEY IF KEY EMIT THEN CR", "Should not wait", TEST_NORMAL, 0, 0, {0}},
+            {"multiple_check", "?KEY ?KEY OR . CR", "Should check availability", TEST_NORMAL, 0, 0, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "TYPE", {
             {
                 "basic_string", "HERE S\" Hello\" DUP >R HERE SWAP CMOVE HERE R> TYPE CR", "Should print: Hello",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"empty_string", "HERE 0 TYPE CR", "Should print nothing", TEST_NORMAL, 0, 1},
-            {"single_char", "HERE 65 OVER C! 1 TYPE CR", "Should print: A", TEST_NORMAL, 0, 1},
+            {"empty_string", "HERE 0 TYPE CR", "Should print nothing", TEST_NORMAL, 0, 1, {0}},
+            {"single_char", "HERE 65 OVER C! 1 TYPE CR", "Should print: A", TEST_NORMAL, 0, 1, {0}},
             {
                 "numbers", "HERE S\" 12345\" DUP >R HERE SWAP CMOVE HERE R> TYPE CR", "Should print: 12345",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"zero_length", "PAD 0 TYPE", "Should handle zero length", TEST_NORMAL, 0, 1},
-            {"one_item", "PAD TYPE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "TYPE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"zero_length", "PAD 0 TYPE", "Should handle zero length", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "PAD TYPE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "TYPE", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "COUNT", {
             {
                 "basic", "HERE S\" Test\" DROP C@ HERE 1+ SWAP COUNT . . CR", "Should show length and addr+1",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"empty", "HERE 0 OVER C! COUNT . . CR", "Should handle empty string", TEST_NORMAL, 0, 1},
-            {"max_length", "HERE 255 OVER C! COUNT . . CR", "Should handle max length", TEST_NORMAL, 0, 1},
-            {"zero_addr_plus_one", "HERE COUNT SWAP 1- = . CR", "Should increment address", TEST_NORMAL, 0, 1},
-            {"empty_stack", "COUNT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"empty", "HERE 0 OVER C! COUNT . . CR", "Should handle empty string", TEST_NORMAL, 0, 1, {0}},
+            {"max_length", "HERE 255 OVER C! COUNT . . CR", "Should handle max length", TEST_NORMAL, 0, 1, {0}},
+            {"zero_addr_plus_one", "HERE COUNT SWAP 1- = . CR", "Should increment address", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "COUNT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "EXPECT", {
-            {"basic_input", "PAD 10 EXPECT", "Should read up to 10 chars", TEST_NORMAL, 0, 0},
-            {"max_length", "PAD 80 EXPECT", "Should read up to 80 chars", TEST_NORMAL, 0, 0},
-            {"zero_length", "PAD 0 EXPECT", "Should handle zero length", TEST_NORMAL, 0, 1},
-            {"one_item", "PAD EXPECT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "EXPECT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic_input", "PAD 10 EXPECT", "Should read up to 10 chars", TEST_NORMAL, 0, 0, {0}},
+            {"max_length", "PAD 80 EXPECT", "Should read up to 80 chars", TEST_NORMAL, 0, 0, {0}},
+            {"zero_length", "PAD 0 EXPECT", "Should handle zero length", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "PAD EXPECT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "EXPECT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "SPAN", {
-            {"after_expect", "PAD 10 EXPECT SPAN @ . CR", "Should show chars read", TEST_NORMAL, 0, 0},
-            {"zero_input", "PAD 0 EXPECT SPAN @ . CR", "Should show zero", TEST_NORMAL, 0, 1},
-            {"variable_test", "SPAN @ SPAN @ = . CR", "Should be consistent", TEST_NORMAL, 0, 1},
-            {"address_test", "SPAN 0<> . CR", "Should be valid address", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"after_expect", "PAD 10 EXPECT SPAN @ . CR", "Should show chars read", TEST_NORMAL, 0, 0, {0}},
+            {"zero_input", "PAD 0 EXPECT SPAN @ . CR", "Should show zero", TEST_NORMAL, 0, 1, {0}},
+            {"variable_test", "SPAN @ SPAN @ = . CR", "Should be consistent", TEST_NORMAL, 0, 1, {0}},
+            {"address_test", "SPAN 0<> . CR", "Should be valid address", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "WORD", {
             /* Basic functionality */
-            {"basic_parse", "BL WORD COUNT TYPE CR", "Should parse next word", TEST_NORMAL, 0, 0},
-            {"delimiter_test", "44 WORD COUNT TYPE CR", "Should use comma delimiter", TEST_NORMAL, 0, 0},
-            {"empty_input", "BL WORD COUNT . CR", "Should handle empty input", TEST_NORMAL, 0, 1},
+            {"basic_parse", "BL WORD COUNT TYPE CR", "Should parse next word", TEST_NORMAL, 0, 0, {0}},
+            {"delimiter_test", "44 WORD COUNT TYPE CR", "Should use comma delimiter", TEST_NORMAL, 0, 0, {0}},
+            {"empty_input", "BL WORD COUNT . CR", "Should handle empty input", TEST_NORMAL, 0, 1, {0}},
 
             /* Different delimiters */
-            {"space_delim", "32 WORD DROP", "Should use space as delimiter", TEST_NORMAL, 0, 1},
-            {"newline_delim", "10 WORD DROP", "Should use newline as delimiter", TEST_NORMAL, 0, 1},
-            {"tab_delim", "9 WORD DROP", "Should use tab as delimiter", TEST_NORMAL, 0, 1},
-            {"comma_delim", "44 WORD DROP", "Should use comma as delimiter", TEST_NORMAL, 0, 1},
+            {"space_delim", "32 WORD DROP", "Should use space as delimiter", TEST_NORMAL, 0, 1, {0}},
+            {"newline_delim", "10 WORD DROP", "Should use newline as delimiter", TEST_NORMAL, 0, 1, {0}},
+            {"tab_delim", "9 WORD DROP", "Should use tab as delimiter", TEST_NORMAL, 0, 1, {0}},
+            {"comma_delim", "44 WORD DROP", "Should use comma as delimiter", TEST_NORMAL, 0, 1, {0}},
 
             /* Leading delimiters */
-            {"skip_leading", "BL WORD DROP", "Should skip leading spaces", TEST_NORMAL, 0, 1},
+            {"skip_leading", "BL WORD DROP", "Should skip leading spaces", TEST_NORMAL, 0, 1, {0}},
 
             /* Word length tests */
-            {"single_char", "BL WORD COUNT . CR", "Should parse single character", TEST_NORMAL, 0, 1},
-            {"long_word", "BL WORD COUNT 0 > . CR", "Should parse long word", TEST_NORMAL, 0, 1},
+            {"single_char", "BL WORD COUNT . CR", "Should parse single character", TEST_NORMAL, 0, 1, {0}},
+            {"long_word", "BL WORD COUNT 0 > . CR", "Should parse long word", TEST_NORMAL, 0, 1, {0}},
 
             /* Edge cases */
-            {"zero_delim", "0 WORD DROP", "Should handle null delimiter", TEST_NORMAL, 0, 1},
-            {"high_ascii", "127 WORD DROP", "Should handle DEL delimiter", TEST_NORMAL, 0, 1},
+            {"zero_delim", "0 WORD DROP", "Should handle null delimiter", TEST_NORMAL, 0, 1, {0}},
+            {"high_ascii", "127 WORD DROP", "Should handle DEL delimiter", TEST_NORMAL, 0, 1, {0}},
 
             /* Count-prefixed string */
-            {"count_format", "BL WORD C@ . CR", "Should have count byte", TEST_NORMAL, 0, 1},
-            {"count_value", "BL WORD COUNT SWAP DROP . CR", "Should return count", TEST_NORMAL, 0, 1},
+            {"count_format", "BL WORD C@ . CR", "Should have count byte", TEST_NORMAL, 0, 1, {0}},
+            {"count_value", "BL WORD COUNT SWAP DROP . CR", "Should return count", TEST_NORMAL, 0, 1, {0}},
 
             /* Error cases */
-            {"empty_stack", "WORD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
+            {"empty_stack", "WORD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
 
             /* Consecutive delimiters */
-            {"multi_delim", "BL WORD DROP BL WORD DROP", "Should handle multiple parses", TEST_NORMAL, 0, 1},
+            {"multi_delim", "BL WORD DROP BL WORD DROP", "Should handle multiple parses", TEST_NORMAL, 0, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        17
+        17, {0}
     },
 
     /* Base conversion and formatting tests */
     {
         "BASE_OUTPUT", {
-            {"decimal", "10 BASE ! 255 . CR", "Should print: 255", TEST_NORMAL, 0, 1},
-            {"hex", "16 BASE ! 255 . CR", "Should print: FF", TEST_NORMAL, 0, 1},
-            {"octal", "8 BASE ! 64 . CR", "Should print: 100", TEST_NORMAL, 0, 1},
-            {"binary", "5 2 BASE ! . CR", "Should print: 101", TEST_NORMAL, 0, 1},
+            {"decimal", "10 BASE ! 255 . CR", "Should print: 255", TEST_NORMAL, 0, 1, {0}},
+            {"hex", "16 BASE ! 255 . CR", "Should print: FF", TEST_NORMAL, 0, 1, {0}},
+            {"octal", "8 BASE ! 64 . CR", "Should print: 100", TEST_NORMAL, 0, 1, {0}},
+            {"binary", "5 2 BASE ! . CR", "Should print: 101", TEST_NORMAL, 0, 1, {0}},
             {
                 "base_restore", "BASE @  DECIMAL  255  16 BASE !  .  BASE !  CR", "Should restore base", TEST_NORMAL, 0,
-                1
+                1, {0}
             },
-            {"reset_decimal", "DECIMAL", "Reset base to DECIMAL for subsequent tests", TEST_NORMAL, 0, 0},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"reset_decimal", "DECIMAL", "Reset base to DECIMAL for subsequent tests", TEST_NORMAL, 0, 0, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     /* Output formatting combinations */
     {
         "FORMAT_COMBO", {
-            {"number_space_number", "DECIMAL 42 . SPACE 43 . CR", "Should format: 42 43", TEST_NORMAL, 0, 1},
-            {"multi_line", "DECIMAL 1 . CR 2 . CR 3 . CR", "Should print on separate lines", TEST_NORMAL, 0, 1},
-            {"indented", "DECIMAL 5 SPACES 42 . CR", "Should indent number", TEST_NORMAL, 0, 1},
-            {"table_format", "DECIMAL 1 . 3 SPACES 10 . 3 SPACES 100 . CR", "Should format table", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"number_space_number", "DECIMAL 42 . SPACE 43 . CR", "Should format: 42 43", TEST_NORMAL, 0, 1, {0}},
+            {"multi_line", "DECIMAL 1 . CR 2 . CR 3 . CR", "Should print on separate lines", TEST_NORMAL, 0, 1, {0}},
+            {"indented", "DECIMAL 5 SPACES 42 . CR", "Should indent number", TEST_NORMAL, 0, 1, {0}},
+            {"table_format", "DECIMAL 1 . 3 SPACES 10 . 3 SPACES 100 . CR", "Should format table", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/logical_words_test.c b/src/test_runner/modules/logical_words_test.c
index 771d6e6..37bcc08 100644
--- a/src/test_runner/modules/logical_words_test.c
+++ b/src/test_runner/modules/logical_words_test.c
@@ -47,242 +47,242 @@
 static WordTestSuite logical_word_suites[] = {
     {
         "AND", {
-            {"both_true", "-1 -1 AND . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"first_false", "0 -1 AND . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"second_false", "-1 0 AND . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"both_false", "0 0 AND . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"bitwise", "85 51 AND . CR", "Should print: 17", TEST_NORMAL, 0, 1},
-            {"empty_stack", "AND", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 AND", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"both_true", "-1 -1 AND . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"first_false", "0 -1 AND . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"second_false", "-1 0 AND . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"both_false", "0 0 AND . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"bitwise", "85 51 AND . CR", "Should print: 17", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "AND", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 AND", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "OR", {
-            {"both_true", "-1 -1 OR . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"first_false", "0 -1 OR . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"second_false", "-1 0 OR . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"both_false", "0 0 OR . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"bitwise", "85 51 OR . CR", "Should print: 119", TEST_NORMAL, 0, 1},
-            {"empty_stack", "OR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 OR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"both_true", "-1 -1 OR . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"first_false", "0 -1 OR . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"second_false", "-1 0 OR . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"both_false", "0 0 OR . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"bitwise", "85 51 OR . CR", "Should print: 119", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "OR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 OR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "XOR", {
-            {"both_true", "-1 -1 XOR . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"first_false", "0 -1 XOR . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"second_false", "-1 0 XOR . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"both_false", "0 0 XOR . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"bitwise", "85 51 XOR . CR", "Should print: 102", TEST_NORMAL, 0, 1},
-            {"empty_stack", "XOR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 XOR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"both_true", "-1 -1 XOR . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"first_false", "0 -1 XOR . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"second_false", "-1 0 XOR . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"both_false", "0 0 XOR . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"bitwise", "85 51 XOR . CR", "Should print: 102", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "XOR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 XOR", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "NOT", {
-            {"true", "-1 NOT . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"false", "0 NOT . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"positive", "42 NOT . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "-42 NOT . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"empty_stack", "NOT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"true", "-1 NOT . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"false", "0 NOT . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"positive", "42 NOT . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 NOT . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "NOT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "=", {
-            {"equal", "42 42 = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"not_equal", "42 43 = . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"zero_equal", "0 0 = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative_equal", "-42 -42 = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative_positive", "-42 42 = . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"empty_stack", "=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 =", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"equal", "42 42 = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"not_equal", "42 43 = . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"zero_equal", "0 0 = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative_equal", "-42 -42 = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative_positive", "-42 42 = . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 =", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "<>", {
-            {"not_equal", "42 43 <> . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"equal", "42 42 <> . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"zero_equal", "0 0 <> . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "-42 42 <> . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack", "<>", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 <>", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"not_equal", "42 43 <> . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"equal", "42 42 <> . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"zero_equal", "0 0 <> . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 42 <> . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "<>", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 <>", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "<", {
-            {"less_than", "5 7 < . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"greater_than", "7 5 < . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"equal", "5 5 < . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative_positive", "-5 5 < . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative_negative", "-7 -5 < . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack", "<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 <", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"less_than", "5 7 < . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"greater_than", "7 5 < . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"equal", "5 5 < . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative_positive", "-5 5 < . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative_negative", "-7 -5 < . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 <", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         ">", {
-            {"greater_than", "7 5 > . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"less_than", "5 7 > . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"equal", "5 5 > . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"positive_negative", "5 -5 > . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative_negative", "-5 -7 > . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack", ">", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 >", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"greater_than", "7 5 > . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"less_than", "5 7 > . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"equal", "5 5 > . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"positive_negative", "5 -5 > . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative_negative", "-5 -7 > . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", ">", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 >", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "0=", {
-            {"zero", "0 0= . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"positive", "42 0= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "-42 0= . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"empty_stack", "0=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"zero", "0 0= . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"positive", "42 0= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 0= . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "0=", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "0<", {
-            {"negative", "-42 0< . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"zero", "0 0< . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"positive", "42 0< . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"empty_stack", "0<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"negative", "-42 0< . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 0< . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"positive", "42 0< . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "0<", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "0>", {
-            {"positive", "42 0> . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"zero", "0 0> . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "-42 0> . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"empty_stack", "0>", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"positive", "42 0> . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 0> . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 0> . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "0>", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "0<>", {
-            {"nonzero_pos", "42 0<> . CR",     "Should print: -1", TEST_NORMAL, 0, 1},
-            {"nonzero_neg", "-1 0<> . CR",     "Should print: -1", TEST_NORMAL, 0, 1},
-            {"zero",        "0 0<> . CR",      "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"empty_stack", "0<>",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"nonzero_pos", "42 0<> . CR",     "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"nonzero_neg", "-1 0<> . CR",     "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"zero",        "0 0<> . CR",      "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "0<>",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "U<", {
-            {"less",        "3 5 U< . CR",     "Should print: -1", TEST_NORMAL, 0, 1},
-            {"equal",       "5 5 U< . CR",     "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"greater",     "7 5 U< . CR",     "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"zero_one",    "0 1 U< . CR",     "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack", "U<",              "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"less",        "3 5 U< . CR",     "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"equal",       "5 5 U< . CR",     "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"greater",     "7 5 U< . CR",     "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"zero_one",    "0 1 U< . CR",     "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "U<",              "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "U>", {
-            {"greater",     "5 3 U> . CR",     "Should print: -1", TEST_NORMAL, 0, 1},
-            {"equal",       "5 5 U> . CR",     "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"less",        "3 5 U> . CR",     "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"one_zero",    "1 0 U> . CR",     "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack", "U>",              "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"greater",     "5 3 U> . CR",     "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"equal",       "5 5 U> . CR",     "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"less",        "3 5 U> . CR",     "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"one_zero",    "1 0 U> . CR",     "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "U>",              "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "WITHIN", {
-            {"in_range",    "3 1 5 WITHIN . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {"at_low",      "1 1 5 WITHIN . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {"at_high",     "5 1 5 WITHIN . CR",  "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"below",       "0 1 5 WITHIN . CR",  "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"above",       "6 1 5 WITHIN . CR",  "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"empty_stack", "WITHIN",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"in_range",    "3 1 5 WITHIN . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"at_low",      "1 1 5 WITHIN . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"at_high",     "5 1 5 WITHIN . CR",  "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"below",       "0 1 5 WITHIN . CR",  "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"above",       "6 1 5 WITHIN . CR",  "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "WITHIN",             "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "TRUE", {
-            {"value",    "TRUE . CR",           "Should print: -1", TEST_NORMAL, 0, 1},
-            {"as_flag",  "TRUE 0= . CR",        "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"in_and",   "TRUE TRUE AND . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"value",    "TRUE . CR",           "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"as_flag",  "TRUE 0= . CR",        "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"in_and",   "TRUE TRUE AND . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "FALSE", {
-            {"value",   "FALSE . CR",           "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"as_flag", "FALSE 0= . CR",        "Should print: -1", TEST_NORMAL, 0, 1},
-            {"in_or",   "TRUE FALSE OR . CR",   "Should print: -1", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"value",   "FALSE . CR",           "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"as_flag", "FALSE 0= . CR",        "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"in_or",   "TRUE FALSE OR . CR",   "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         ">=", {
-            {"less",       "3 5 >= . CR",  "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"greater",    "5 3 >= . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {"equal",      "3 3 >= . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative",   "-1 0 >= . CR", "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"neg_neg",    "-1 -2 >= . CR","Should print: -1", TEST_NORMAL, 0, 1},
-            {"underflow",  ">=",           "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"less",       "3 5 >= . CR",  "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"greater",    "5 3 >= . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"equal",      "3 3 >= . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative",   "-1 0 >= . CR", "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"neg_neg",    "-1 -2 >= . CR","Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"underflow",  ">=",           "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "<=", {
-            {"less",       "3 5 <= . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {"greater",    "5 3 <= . CR",  "Should print: 0",  TEST_NORMAL, 0, 1},
-            {"equal",      "3 3 <= . CR",  "Should print: -1", TEST_NORMAL, 0, 1},
-            {"negative",   "-1 0 <= . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"neg_neg",    "-2 -1 <= . CR","Should print: -1", TEST_NORMAL, 0, 1},
-            {"underflow",  "<=",           "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"less",       "3 5 <= . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"greater",    "5 3 <= . CR",  "Should print: 0",  TEST_NORMAL, 0, 1, {0}},
+            {"equal",      "3 3 <= . CR",  "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"negative",   "-1 0 <= . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"neg_neg",    "-2 -1 <= . CR","Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"underflow",  "<=",           "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/mama_forth_words_test.c b/src/test_runner/modules/mama_forth_words_test.c
index 819478c..6dce2dd 100644
--- a/src/test_runner/modules/mama_forth_words_test.c
+++ b/src/test_runner/modules/mama_forth_words_test.c
@@ -54,21 +54,17 @@ static WordTestSuite mama_word_suites[] = {
                 "basic",
                 "CAPSULE-COUNT . CR",
                 "Should print number of capsules",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "non_negative",
                 "CAPSULE-COUNT 0 >= . CR",
                 "Should be >= 0",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
@@ -78,29 +74,23 @@ static WordTestSuite mama_word_suites[] = {
                 "first_capsule",
                 "0 CAPSULE@ . CR",
                 "Should return first descriptor address",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "out_of_bounds",
                 "9999 CAPSULE@ . CR",
                 "Should return 0 for invalid index",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "empty_stack",
                 "CAPSULE@",
                 "Should cause stack underflow",
-                TEST_ERROR_CASE,
-                1,
-                MAMA_IMPLEMENTED
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
@@ -110,29 +100,23 @@ static WordTestSuite mama_word_suites[] = {
                 "basic",
                 "0 CAPSULE@ CAPSULE-FLAGS@ . CR",
                 "Should return flags from descriptor",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "null_desc",
                 "0 CAPSULE-FLAGS@ . CR",
                 "Should handle null descriptor",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "empty_stack",
                 "CAPSULE-FLAGS@",
                 "Should cause stack underflow",
-                TEST_ERROR_CASE,
-                1,
-                MAMA_IMPLEMENTED
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
@@ -142,21 +126,17 @@ static WordTestSuite mama_word_suites[] = {
                 "basic",
                 "0 CAPSULE@ CAPSULE-LEN@ . CR",
                 "Should return payload length",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "empty_stack",
                 "CAPSULE-LEN@",
                 "Should cause stack underflow",
-                TEST_ERROR_CASE,
-                1,
-                MAMA_IMPLEMENTED
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
@@ -166,21 +146,17 @@ static WordTestSuite mama_word_suites[] = {
                 "basic",
                 "0 CAPSULE@ CAPSULE-HASH@ . CR",
                 "Should return content hash",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "empty_stack",
                 "CAPSULE-HASH@",
                 "Should cause stack underflow",
-                TEST_ERROR_CASE,
-                1,
-                MAMA_IMPLEMENTED
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
@@ -190,21 +166,17 @@ static WordTestSuite mama_word_suites[] = {
                 "always_zero",
                 "MAMA-VM-ID . CR",
                 "Should always print 0",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "equals_zero",
                 "MAMA-VM-ID 0 = . CR",
                 "Should equal 0",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
@@ -214,21 +186,17 @@ static WordTestSuite mama_word_suites[] = {
                 "at_least_one",
                 "VM-COUNT . CR",
                 "Should be at least 1 (Mama)",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "positive",
                 "VM-COUNT 0 > . CR",
                 "Should be positive",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
@@ -238,21 +206,17 @@ static WordTestSuite mama_word_suites[] = {
                 "invalid_id",
                 "9999999 CAPSULE-BIRTH . CR",
                 "Should return -1 for invalid capsule ID",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
             {
                 "empty_stack",
                 "CAPSULE-BIRTH",
                 "Should cause stack underflow",
-                TEST_ERROR_CASE,
-                1,
-                MAMA_IMPLEMENTED
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
@@ -262,13 +226,11 @@ static WordTestSuite mama_word_suites[] = {
                 "empty_stack",
                 "CAPSULE-RUN",
                 "Should cause stack underflow",
-                TEST_ERROR_CASE,
-                1,
-                MAMA_IMPLEMENTED
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        1
+        1, {0}
     },
 
     {
@@ -278,16 +240,14 @@ static WordTestSuite mama_word_suites[] = {
                 "basic",
                 "CAPSULE-TEST",
                 "Should print diagnostic message",
-                TEST_NORMAL,
-                0,
-                MAMA_IMPLEMENTED
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        1
+        1, {0}
     },
 
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}  /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}  /* End marker */
 };
 
 /**
diff --git a/src/test_runner/modules/memory_words_test.c b/src/test_runner/modules/memory_words_test.c
index 295a6cc..a9c1ee4 100644
--- a/src/test_runner/modules/memory_words_test.c
+++ b/src/test_runner/modules/memory_words_test.c
@@ -47,177 +47,177 @@
 static WordTestSuite memory_word_suites[] = {
     {
         "!", {
-            {"basic", "42 HERE ! HERE @ . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"zero", "0 HERE ! HERE @ . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "-999 HERE ! HERE @ . CR", "Should print: -999", TEST_NORMAL, 0, 1},
-            {"overwrite", "111 HERE ! 222 HERE ! HERE @ . CR", "Should print: 222", TEST_NORMAL, 0, 1},
-            {"max_int", "2147483647 HERE ! HERE @ . CR", "Should store max int", TEST_EDGE_CASE, 0, 1},
-            {"min_int", "-2147483648 HERE ! HERE @ . CR", "Should store min int", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 !", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 HERE ! HERE @ . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 HERE ! HERE @ . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-999 HERE ! HERE @ . CR", "Should print: -999", TEST_NORMAL, 0, 1, {0}},
+            {"overwrite", "111 HERE ! 222 HERE ! HERE @ . CR", "Should print: 222", TEST_NORMAL, 0, 1, {0}},
+            {"max_int", "2147483647 HERE ! HERE @ . CR", "Should store max int", TEST_EDGE_CASE, 0, 1, {0}},
+            {"min_int", "-2147483648 HERE ! HERE @ . CR", "Should store min int", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 !", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "@", {
-            {"after_store", "123 HERE ! HERE @ . CR", "Should print: 123", TEST_NORMAL, 0, 1},
-            {"multiple_reads", "456 HERE ! HERE @ HERE @ = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_stack", "@", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"after_store", "123 HERE ! HERE @ . CR", "Should print: 123", TEST_NORMAL, 0, 1, {0}},
+            {"multiple_reads", "456 HERE ! HERE @ HERE @ = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "@", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "C!", {
-            {"basic", "65 HERE C! HERE C@ . CR", "Should print: 65", TEST_NORMAL, 0, 1},
-            {"zero", "0 HERE C! HERE C@ . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"high_byte", "255 HERE C! HERE C@ . CR", "Should print: 255", TEST_NORMAL, 0, 1},
-            {"truncation", "256 HERE C! HERE C@ . CR", "Should print: 0 (truncated)", TEST_EDGE_CASE, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "65 HERE C! HERE C@ . CR", "Should print: 65", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 HERE C! HERE C@ . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"high_byte", "255 HERE C! HERE C@ . CR", "Should print: 255", TEST_NORMAL, 0, 1, {0}},
+            {"truncation", "256 HERE C! HERE C@ . CR", "Should print: 0 (truncated)", TEST_EDGE_CASE, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "C@", {
-            {"after_cstore", "97 HERE C! HERE C@ . CR", "Should print: 97", TEST_NORMAL, 0, 1},
-            {"zero_byte", "0 HERE C! HERE C@ . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"after_cstore", "97 HERE C! HERE C@ . CR", "Should print: 97", TEST_NORMAL, 0, 1, {0}},
+            {"zero_byte", "0 HERE C! HERE C@ . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         ",", {
-            {"basic", "42 , HERE 8 - @ . CR", "Should compile 42", TEST_NORMAL, 0, 1},
-            {"negative", "-999 , HERE 8 - @ . CR", "Should compile -999", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 , HERE 8 - @ . CR", "Should compile 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-999 , HERE 8 - @ . CR", "Should compile -999", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "C,", {
-            {"basic", "65 C, HERE 1 - C@ . CR", "Should compile byte 65", TEST_NORMAL, 0, 1},
-            {"zero", "0 C, HERE 1 - C@ . CR", "Should compile byte 0", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "65 C, HERE 1 - C@ . CR", "Should compile byte 65", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 C, HERE 1 - C@ . CR", "Should compile byte 0", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "2,", {
             {
                 "roundtrip", "12345 67890 2, HERE 16 - 2@ . . CR", "Should print: 67890 12345",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "save-and-verify", "12345 67890 2, HERE 16 - 2@ 67890 = SWAP 12345 = AND . CR",
-                "Should print: -1", TEST_NORMAL, 0, 1
+                "Should print: -1", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "HERE", {
-            {"basic", "HERE HERE = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"after_comma", "HERE 42 , HERE SWAP - 1 CELLS = 0 SWAP /", "Asserts HERE advances by exactly 1 CELLS (8 bytes on 64-bit)", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE HERE = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"after_comma", "HERE 42 , HERE SWAP - 1 CELLS = 0 SWAP /", "Asserts HERE advances by exactly 1 CELLS (8 bytes on 64-bit)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "ALLOT", {
-            {"basic", "HERE 10 ALLOT HERE SWAP - . CR", "Should print: 10", TEST_NORMAL, 0, 1},
-            {"zero", "HERE 0 ALLOT HERE SWAP - . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"negative", "HERE -4 ALLOT HERE SWAP - . CR", "Should print: -4", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE 10 ALLOT HERE SWAP - . CR", "Should print: 10", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "HERE 0 ALLOT HERE SWAP - . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "HERE -4 ALLOT HERE SWAP - . CR", "Should print: -4", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "PAD", {
-            {"basic", "PAD PAD = . CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"different_from_here", "PAD HERE = . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "PAD PAD = . CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"different_from_here", "PAD HERE = . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "+!", {
-            {"basic",       "10 HERE ! 5 HERE +! HERE @ . CR",                       "Should print: 15",  TEST_NORMAL, 0, 1},
-            {"by_zero",     "42 HERE ! 0 HERE +! HERE @ . CR",                       "Should print: 42",  TEST_NORMAL, 0, 1},
-            {"negative",    "10 HERE ! -3 HERE +! HERE @ . CR",                      "Should print: 7",   TEST_NORMAL, 0, 1},
-            {"accumulate",  "0 HERE ! 1 HERE +! 2 HERE +! 3 HERE +! HERE @ . CR",   "Should print: 6",   TEST_NORMAL, 0, 1},
-            {"empty_stack", "+!",                                                     "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "10 HERE ! 5 HERE +! HERE @ . CR",                       "Should print: 15",  TEST_NORMAL, 0, 1, {0}},
+            {"by_zero",     "42 HERE ! 0 HERE +! HERE @ . CR",                       "Should print: 42",  TEST_NORMAL, 0, 1, {0}},
+            {"negative",    "10 HERE ! -3 HERE +! HERE @ . CR",                      "Should print: 7",   TEST_NORMAL, 0, 1, {0}},
+            {"accumulate",  "0 HERE ! 1 HERE +! 2 HERE +! 3 HERE +! HERE @ . CR",   "Should print: 6",   TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "+!",                                                     "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "-!", {
-            {"basic",       "10 HERE ! 3 HERE -! HERE @ . CR",      "Should print: 7",   TEST_NORMAL, 0, 1},
-            {"by_zero",     "42 HERE ! 0 HERE -! HERE @ . CR",      "Should print: 42",  TEST_NORMAL, 0, 1},
-            {"negative",    "10 HERE ! -5 HERE -! HERE @ . CR",     "Should print: 15",  TEST_NORMAL, 0, 1},
-            {"empty_stack", "-!",                                    "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "10 HERE ! 3 HERE -! HERE @ . CR",      "Should print: 7",   TEST_NORMAL, 0, 1, {0}},
+            {"by_zero",     "42 HERE ! 0 HERE -! HERE @ . CR",      "Should print: 42",  TEST_NORMAL, 0, 1, {0}},
+            {"negative",    "10 HERE ! -5 HERE -! HERE @ . CR",     "Should print: 15",  TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "-!",                                    "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "2!", {
-            {"basic",       "11 22 HERE 2! HERE @ . HERE 8 + @ . CR",  "Should print: 22 11",  TEST_NORMAL, 0, 1},
-            {"zeros",       "0 0 HERE 2! HERE @ . HERE 8 + @ . CR",    "Should print: 0 0",    TEST_NORMAL, 0, 1},
-            {"negative",    "-1 -2 HERE 2! HERE @ . HERE 8 + @ . CR",  "Should print: -2 -1",  TEST_NORMAL, 0, 1},
-            {"empty_stack", "2!",                                       "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "11 22 HERE 2! HERE @ . HERE 8 + @ . CR",  "Should print: 22 11",  TEST_NORMAL, 0, 1, {0}},
+            {"zeros",       "0 0 HERE 2! HERE @ . HERE 8 + @ . CR",    "Should print: 0 0",    TEST_NORMAL, 0, 1, {0}},
+            {"negative",    "-1 -2 HERE 2! HERE @ . HERE 8 + @ . CR",  "Should print: -2 -1",  TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "2!",                                       "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "FILL", {
-            {"basic",       "HERE 8 65 FILL HERE C@ . HERE 1+ C@ . CR", "Should print: 65 65", TEST_NORMAL, 0, 1},
-            {"zero_n",      "HERE 0 88 FILL",                            "Should do nothing",   TEST_NORMAL, 0, 1},
-            {"zero_byte",   "HERE 4 0 FILL HERE C@ . CR",                "Should print: 0",     TEST_NORMAL, 0, 1},
-            {"empty_stack", "FILL",                                      "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "HERE 8 65 FILL HERE C@ . HERE 1+ C@ . CR", "Should print: 65 65", TEST_NORMAL, 0, 1, {0}},
+            {"zero_n",      "HERE 0 88 FILL",                            "Should do nothing",   TEST_NORMAL, 0, 1, {0}},
+            {"zero_byte",   "HERE 4 0 FILL HERE C@ . CR",                "Should print: 0",     TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "FILL",                                      "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "MOVE", {
-            {"basic",       "HERE 65 OVER C! HERE 1+ 66 OVER C! HERE HERE 16 + 2 MOVE HERE 16 + C@ . HERE 17 + C@ . CR", "Should print: 65 66", TEST_NORMAL, 0, 1},
-            {"zero_n",      "HERE HERE 8 + 0 MOVE",                                  "Should do nothing",   TEST_NORMAL, 0, 1},
-            {"empty_stack", "MOVE",                                                   "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "HERE 65 OVER C! HERE 1+ 66 OVER C! HERE HERE 16 + 2 MOVE HERE 16 + C@ . HERE 17 + C@ . CR", "Should print: 65 66", TEST_NORMAL, 0, 1, {0}},
+            {"zero_n",      "HERE HERE 8 + 0 MOVE",                                  "Should do nothing",   TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "MOVE",                                                   "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "ERASE", {
-            {"basic",       "HERE 4 65 FILL HERE 4 ERASE HERE C@ . HERE 3 + C@ . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"zero_n",      "HERE 0 ERASE",                                            "Should do nothing",  TEST_NORMAL, 0, 1},
-            {"empty_stack", "ERASE",                                                   "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "HERE 4 65 FILL HERE 4 ERASE HERE C@ . HERE 3 + C@ . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"zero_n",      "HERE 0 ERASE",                                            "Should do nothing",  TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "ERASE",                                                   "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/mixed_arithmetic_words_test.c b/src/test_runner/modules/mixed_arithmetic_words_test.c
index a7aba1f..772763c 100644
--- a/src/test_runner/modules/mixed_arithmetic_words_test.c
+++ b/src/test_runner/modules/mixed_arithmetic_words_test.c
@@ -55,85 +55,85 @@ static WordTestSuite mixed_arithmetic_word_suites[] = {
     {
         "*/", {
             // ( n1 n2 n3 -- n4 )  n1 * n2 / n3 (integer math)
-            {"basic", "6 7 4 */ . CR", "Should print: 10 (6*7/4)", TEST_NORMAL, 0, 1},
-            {"exact_division", "12 5 3 */ . CR", "Should print: 20 (12*5/3)", TEST_NORMAL, 0, 1},
-            {"zero_multiply", "0 999 123 */ . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"by_one", "42 5 1 */ . CR", "Should print: 210 (42*5/1)", TEST_NORMAL, 0, 1},
-            {"truncation", "7 3 2 */ . CR", "Should print: 10 (21/2 truncated)", TEST_NORMAL, 0, 1},
-            {"negative_multiply", "-6 7 4 */ . CR", "Should print: -10", TEST_NORMAL, 0, 1},
-            {"negative_divisor", "6 7 -4 */ . CR", "Should print: -10", TEST_NORMAL, 0, 1},
-            {"div_by_zero", "6 7 0 */", "Should cause division by zero", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "*/", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"two_items", "1 2 */", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "6 7 4 */ . CR", "Should print: 10 (6*7/4)", TEST_NORMAL, 0, 1, {0}},
+            {"exact_division", "12 5 3 */ . CR", "Should print: 20 (12*5/3)", TEST_NORMAL, 0, 1, {0}},
+            {"zero_multiply", "0 999 123 */ . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "42 5 1 */ . CR", "Should print: 210 (42*5/1)", TEST_NORMAL, 0, 1, {0}},
+            {"truncation", "7 3 2 */ . CR", "Should print: 10 (21/2 truncated)", TEST_NORMAL, 0, 1, {0}},
+            {"negative_multiply", "-6 7 4 */ . CR", "Should print: -10", TEST_NORMAL, 0, 1, {0}},
+            {"negative_divisor", "6 7 -4 */ . CR", "Should print: -10", TEST_NORMAL, 0, 1, {0}},
+            {"div_by_zero", "6 7 0 */", "Should cause division by zero", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "*/", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"two_items", "1 2 */", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        10
+        10, {0}
     },
 
     {
         "*/MOD", {
             // ( n1 n2 n3 -- rem quot )  (n1*n2)/n3 -> quot, rem
-            {"basic", "17 3 5 */MOD . . CR", "Should print: 1 10 (51/5 = 10 rem 1)", TEST_NORMAL, 0, 1},
-            {"exact_division", "15 4 3 */MOD . . CR", "Should print: 0 20 (60/3 = 20 rem 0)", TEST_NORMAL, 0, 1},
-            {"zero_multiply", "0 999 123 */MOD . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"by_one", "42 5 1 */MOD . . CR", "Should print: 0 210", TEST_NORMAL, 0, 1},
-            {"remainder", "7 8 5 */MOD . . CR", "Should print: 1 11 (56/5 = 11 rem 1)", TEST_NORMAL, 0, 1},
-            {"negative", "-7 3 4 */MOD . . CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"div_by_zero", "6 7 0 */MOD", "Should cause division by zero", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "*/MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "17 3 5 */MOD . . CR", "Should print: 1 10 (51/5 = 10 rem 1)", TEST_NORMAL, 0, 1, {0}},
+            {"exact_division", "15 4 3 */MOD . . CR", "Should print: 0 20 (60/3 = 20 rem 0)", TEST_NORMAL, 0, 1, {0}},
+            {"zero_multiply", "0 999 123 */MOD . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "42 5 1 */MOD . . CR", "Should print: 0 210", TEST_NORMAL, 0, 1, {0}},
+            {"remainder", "7 8 5 */MOD . . CR", "Should print: 1 11 (56/5 = 11 rem 1)", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-7 3 4 */MOD . . CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"div_by_zero", "6 7 0 */MOD", "Should cause division by zero", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "*/MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "M+", {
             // ( d_lo d_hi n -- d_lo' d_hi' )  Add n to double d (low first, then high, then n)
-            {"basic", "0 100 200 M+ . . CR", "Should print: 200 100", TEST_NORMAL, 0, 1},
-            {"overflow", "0 2147483647 1 M+ . . CR", "Should handle overflow", TEST_EDGE_CASE, 0, 1},
-            {"negative", "0 -100 50 M+ . . CR", "Should print: 50 -100", TEST_NORMAL, 0, 1},
-            {"zero_add", "0 42 0 M+ . . CR", "Should print: 0 42", TEST_NORMAL, 0, 1},
-            {"both_negative", "0 -100 -200 M+ . . CR", "Should print: -200 -100", TEST_NORMAL, 0, 1},
-            {"empty_stack", "M+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 M+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "0 100 200 M+ . . CR", "Should print: 200 100", TEST_NORMAL, 0, 1, {0}},
+            {"overflow", "0 2147483647 1 M+ . . CR", "Should handle overflow", TEST_EDGE_CASE, 0, 1, {0}},
+            {"negative", "0 -100 50 M+ . . CR", "Should print: 50 -100", TEST_NORMAL, 0, 1, {0}},
+            {"zero_add", "0 42 0 M+ . . CR", "Should print: 0 42", TEST_NORMAL, 0, 1, {0}},
+            {"both_negative", "0 -100 -200 M+ . . CR", "Should print: -200 -100", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "M+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 M+", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "M*", {
             // ( n1 n2 -- d_lo d_hi )  signed multiply, returns double (lo first, hi second)
-            {"basic", "123 456 M* . . CR", "Should print: 56088 0", TEST_NORMAL, 0, 1},
-            {"by_zero", "999 0 M* . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"by_one", "42 1 M* . . CR", "Should print: 42 0", TEST_NORMAL, 0, 1},
-            {"negative", "-123 456 M* . . CR", "Should print: -56088 -1", TEST_NORMAL, 0, 1},
-            {"large_multiply", "65536 65536 M* . . CR", "Should handle large result", TEST_EDGE_CASE, 0, 1},
-            {"both_negative", "-100 -200 M* . . CR", "Should print: 20000 0", TEST_NORMAL, 0, 1},
-            {"empty_stack", "M*", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 M*", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "123 456 M* . . CR", "Should print: 56088 0", TEST_NORMAL, 0, 1, {0}},
+            {"by_zero", "999 0 M* . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "42 1 M* . . CR", "Should print: 42 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-123 456 M* . . CR", "Should print: -56088 -1", TEST_NORMAL, 0, 1, {0}},
+            {"large_multiply", "65536 65536 M* . . CR", "Should handle large result", TEST_EDGE_CASE, 0, 1, {0}},
+            {"both_negative", "-100 -200 M* . . CR", "Should print: 20000 0", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "M*", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 M*", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "M/MOD", {
             // ( d_lo d_hi n -- rem quot )  double/single signed division (lo first, then hi, then n)
-            {"basic", "0 1000 100 M/MOD . . CR", "Should print: 0 10 (1000/100)", TEST_NORMAL, 0, 1},
-            {"with_remainder", "0 1234 100 M/MOD . . CR", "Should handle remainder", TEST_NORMAL, 0, 1},
-            {"double_dividend", "5001 0 10 M/MOD . . CR", "Should print: 1 500 (5001/10)", TEST_NORMAL, 0, 1},
-            {"by_one", "0 42 1 M/MOD . . CR", "Should print: 0 42", TEST_NORMAL, 0, 1},
-            {"negative_dividend", "-1 1000 100 M/MOD . . CR", "Should handle negative", TEST_NORMAL, 0, 1},
-            {"div_by_zero", "0 100 0 M/MOD", "Should cause division by zero", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "M/MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "0 1000 100 M/MOD . . CR", "Should print: 0 10 (1000/100)", TEST_NORMAL, 0, 1, {0}},
+            {"with_remainder", "0 1234 100 M/MOD . . CR", "Should handle remainder", TEST_NORMAL, 0, 1, {0}},
+            {"double_dividend", "5001 0 10 M/MOD . . CR", "Should print: 1 500 (5001/10)", TEST_NORMAL, 0, 1, {0}},
+            {"by_one", "0 42 1 M/MOD . . CR", "Should print: 0 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative_dividend", "-1 1000 100 M/MOD . . CR", "Should handle negative", TEST_NORMAL, 0, 1, {0}},
+            {"div_by_zero", "0 100 0 M/MOD", "Should cause division by zero", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "M/MOD", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/return_stack_words_test.c b/src/test_runner/modules/return_stack_words_test.c
index b560f2f..12fcc6f 100644
--- a/src/test_runner/modules/return_stack_words_test.c
+++ b/src/test_runner/modules/return_stack_words_test.c
@@ -51,38 +51,38 @@
 static WordTestSuite return_stack_word_suites[] = {
     {
         ">R", {
-            {"basic", "42 >R R@ . R> . CR", "Should print: 42 42", TEST_NORMAL, 0, 1},
-            {"zero", "0 >R R@ . R> . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"negative", "-123 >R R@ . R> . CR", "Should print: -123 -123", TEST_NORMAL, 0, 1},
-            {"multiple", "1 2 >R >R R@ . R> . R@ . R> . CR", "Should print: 2 2 1 1", TEST_NORMAL, 0, 1},
-            {"empty_stack", ">R", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 >R R@ . R> . CR", "Should print: 42 42", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 >R R@ . R> . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-123 >R R@ . R> . CR", "Should print: -123 -123", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "1 2 >R >R R@ . R> . R@ . R> . CR", "Should print: 2 2 1 1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", ">R", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "R>", {
-            {"basic", "42 >R R> . CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"lifo_order", "1 2 >R >R R> . R> . CR", "Should print: 2 1", TEST_NORMAL, 0, 1},
-            {"empty_rstack", "R>", "Should cause return stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 >R R> . CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"lifo_order", "1 2 >R >R R> . R> . CR", "Should print: 2 1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_rstack", "R>", "Should cause return stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "R@", {
-            {"basic", "42 >R R@ . R> DROP CR", "Should print: 42", TEST_NORMAL, 0, 1},
-            {"non_destructive", "99 >R R@ R@ = . R> DROP CR", "Should print: -1", TEST_NORMAL, 0, 1},
-            {"empty_rstack", "R@", "Should cause return stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "42 >R R@ . R> DROP CR", "Should print: 42", TEST_NORMAL, 0, 1, {0}},
+            {"non_destructive", "99 >R R@ R@ = . R> DROP CR", "Should print: -1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_rstack", "R@", "Should cause return stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/stack_words_test.c b/src/test_runner/modules/stack_words_test.c
index be5c6d0..07bbb19 100644
--- a/src/test_runner/modules/stack_words_test.c
+++ b/src/test_runner/modules/stack_words_test.c
@@ -57,143 +57,143 @@
 static WordTestSuite stack_word_suites[] = {
     {
         "DUP", {
-            {"basic", "5 DUP . . CR", "Should print: 5 5", TEST_NORMAL, 0, 1},
-            {"zero", "0 DUP . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1},
-            {"negative", "-42 DUP . . CR", "Should print: -42 -42", TEST_NORMAL, 0, 1},
-            {"max_int", "2147483647 DUP . . CR", "Should duplicate max int", TEST_EDGE_CASE, 0, 1},
-            {"min_int", "-2147483648 DUP . . CR", "Should duplicate min int", TEST_EDGE_CASE, 0, 1},
-            {"empty_stack", "DUP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "5 DUP . . CR", "Should print: 5 5", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "0 DUP . . CR", "Should print: 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-42 DUP . . CR", "Should print: -42 -42", TEST_NORMAL, 0, 1, {0}},
+            {"max_int", "2147483647 DUP . . CR", "Should duplicate max int", TEST_EDGE_CASE, 0, 1, {0}},
+            {"min_int", "-2147483648 DUP . . CR", "Should duplicate min int", TEST_EDGE_CASE, 0, 1, {0}},
+            {"empty_stack", "DUP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "DROP", {
             /* Basic functionality */
-            {"basic", "5 7 DROP . CR", "Should print: 5", TEST_NORMAL, 0, 1},
-            {"zero", "42 0 DROP . CR", "Should drop zero, print 42", TEST_NORMAL, 0, 1},
-            {"negative", "10 -5 DROP . CR", "Should drop negative, print 10", TEST_NORMAL, 0, 1},
+            {"basic", "5 7 DROP . CR", "Should print: 5", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "42 0 DROP . CR", "Should drop zero, print 42", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "10 -5 DROP . CR", "Should drop negative, print 10", TEST_NORMAL, 0, 1, {0}},
 
             /* Multiple drops */
-            {"double_drop", "1 2 3 DROP DROP . CR", "Should print: 1", TEST_NORMAL, 0, 1},
-            {"triple_drop", "1 2 3 4 DROP DROP DROP . CR", "Should print: 1", TEST_NORMAL, 0, 1},
-            {"sequential", "5 DROP 6 DROP 7 . CR", "Should print: 7", TEST_NORMAL, 0, 1},
+            {"double_drop", "1 2 3 DROP DROP . CR", "Should print: 1", TEST_NORMAL, 0, 1, {0}},
+            {"triple_drop", "1 2 3 4 DROP DROP DROP . CR", "Should print: 1", TEST_NORMAL, 0, 1, {0}},
+            {"sequential", "5 DROP 6 DROP 7 . CR", "Should print: 7", TEST_NORMAL, 0, 1, {0}},
 
             /* Stack depth effects */
-            {"single_item", "99 DROP DEPTH . CR", "Should empty stack, depth=0", TEST_NORMAL, 0, 1},
-            {"depth_change", "DEPTH 1 2 DROP DEPTH SWAP - . CR", "Should change depth by 1", TEST_NORMAL, 0, 1},
-            {"preserve_depth", "DEPTH 5 6 DROP DROP DEPTH = . CR", "Should preserve net depth", TEST_NORMAL, 0, 1},
+            {"single_item", "99 DROP DEPTH . CR", "Should empty stack, depth=0", TEST_NORMAL, 0, 1, {0}},
+            {"depth_change", "DEPTH 1 2 DROP DEPTH SWAP - . CR", "Should change depth by 1", TEST_NORMAL, 0, 1, {0}},
+            {"preserve_depth", "DEPTH 5 6 DROP DROP DEPTH = . CR", "Should preserve net depth", TEST_NORMAL, 0, 1, {0}},
 
             /* Edge cases */
-            {"max_int", "2147483647 DROP DEPTH . CR", "Should drop max int", TEST_NORMAL, 0, 1},
-            {"min_int", "-2147483648 DROP DEPTH . CR", "Should drop min int", TEST_NORMAL, 0, 1},
+            {"max_int", "2147483647 DROP DEPTH . CR", "Should drop max int", TEST_NORMAL, 0, 1, {0}},
+            {"min_int", "-2147483648 DROP DEPTH . CR", "Should drop min int", TEST_NORMAL, 0, 1, {0}},
 
             /* Chaining with other operations */
-            {"with_dup", "5 DUP DROP . CR", "Should duplicate then drop", TEST_NORMAL, 0, 1},
-            {"with_swap", "1 2 SWAP DROP . CR", "Should swap then drop", TEST_NORMAL, 0, 1},
-            {"complex", "1 2 3 ROT DROP SWAP DROP . CR", "Should handle complex sequence", TEST_NORMAL, 0, 1},
+            {"with_dup", "5 DUP DROP . CR", "Should duplicate then drop", TEST_NORMAL, 0, 1, {0}},
+            {"with_swap", "1 2 SWAP DROP . CR", "Should swap then drop", TEST_NORMAL, 0, 1, {0}},
+            {"complex", "1 2 3 ROT DROP SWAP DROP . CR", "Should handle complex sequence", TEST_NORMAL, 0, 1, {0}},
 
             /* Error case */
-            {"empty_stack", "DROP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
+            {"empty_stack", "DROP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        15
+        15, {0}
     },
 
     {
         "SWAP", {
-            {"basic", "5 7 SWAP . . CR", "Should print: 7 5", TEST_NORMAL, 0, 1},
-            {"same_values", "42 42 SWAP . . CR", "Should print: 42 42", TEST_NORMAL, 0, 1},
-            {"zero_nonzero", "0 99 SWAP . . CR", "Should print: 99 0", TEST_NORMAL, 0, 1},
-            {"negative", "-5 10 SWAP . . CR", "Should print: 10 -5", TEST_NORMAL, 0, 1},
-            {"one_item", "42 SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "5 7 SWAP . . CR", "Should print: 7 5", TEST_NORMAL, 0, 1, {0}},
+            {"same_values", "42 42 SWAP . . CR", "Should print: 42 42", TEST_NORMAL, 0, 1, {0}},
+            {"zero_nonzero", "0 99 SWAP . . CR", "Should print: 99 0", TEST_NORMAL, 0, 1, {0}},
+            {"negative", "-5 10 SWAP . . CR", "Should print: 10 -5", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "42 SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "SWAP", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "OVER", {
-            {"basic", "5 7 OVER . . . CR", "Should print: 5 7 5", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 OVER . . . CR", "Should print: 0 0 0", TEST_NORMAL, 0, 1},
-            {"mixed", "-1 42 OVER . . . CR", "Should print: -1 42 -1", TEST_NORMAL, 0, 1},
-            {"one_item", "42 OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "5 7 OVER . . . CR", "Should print: 5 7 5", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 OVER . . . CR", "Should print: 0 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"mixed", "-1 42 OVER . . . CR", "Should print: -1 42 -1", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "42 OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "OVER", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "ROT", {
-            {"basic", "1 2 3 ROT . . . CR", "Should print: 2 3 1", TEST_NORMAL, 0, 1},
-            {"zeros", "0 0 0 ROT . . . CR", "Should print: 0 0 0", TEST_NORMAL, 0, 1},
-            {"mixed", "-1 0 1 ROT . . . CR", "Should print: 0 1 -1", TEST_NORMAL, 0, 1},
-            {"two_items", "1 2 ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"one_item", "42 ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "1 2 3 ROT . . . CR", "Should print: 2 3 1", TEST_NORMAL, 0, 1, {0}},
+            {"zeros", "0 0 0 ROT . . . CR", "Should print: 0 0 0", TEST_NORMAL, 0, 1, {0}},
+            {"mixed", "-1 0 1 ROT . . . CR", "Should print: 0 1 -1", TEST_NORMAL, 0, 1, {0}},
+            {"two_items", "1 2 ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_item", "42 ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "ROT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "DEPTH", {
-            {"empty", "DEPTH . CR", "Should print: 0", TEST_NORMAL, 0, 1},
-            {"one_item", "42 DEPTH . CR", "Should print: 1", TEST_NORMAL, 0, 1},
-            {"multiple", "1 2 3 DEPTH . CR", "Should print: 3", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"empty", "DEPTH . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {"one_item", "42 DEPTH . CR", "Should print: 1", TEST_NORMAL, 0, 1, {0}},
+            {"multiple", "1 2 3 DEPTH . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "PICK", {
-            {"pick_0", "1 2 3 0 PICK . CR", "Should print: 3", TEST_NORMAL, 0, 1},
-            {"pick_1", "1 2 3 1 PICK . CR", "Should print: 2", TEST_NORMAL, 0, 1},
-            {"pick_2", "1 2 3 2 PICK . CR", "Should print: 1", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"pick_0", "1 2 3 0 PICK . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {"pick_1", "1 2 3 1 PICK . CR", "Should print: 2", TEST_NORMAL, 0, 1, {0}},
+            {"pick_2", "1 2 3 2 PICK . CR", "Should print: 1", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "ROLL", {
-            {"roll_1", "1 2 3 1 ROLL . . . CR", "Should print: 1 3 2", TEST_NORMAL, 0, 1},
-            {"roll_2", "1 2 3 2 ROLL . . . CR", "Should print: 2 3 1", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"roll_1", "1 2 3 1 ROLL . . . CR", "Should print: 1 3 2", TEST_NORMAL, 0, 1, {0}},
+            {"roll_2", "1 2 3 2 ROLL . . . CR", "Should print: 2 3 1", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "?DUP", {
-            {"nonzero",     "42 ?DUP . . CR",     "Should print: 42 42",     TEST_NORMAL, 0, 1},
-            {"negative",    "-5 ?DUP . . CR",     "Should print: -5 -5",     TEST_NORMAL, 0, 1},
-            {"zero",        "0 ?DUP DEPTH . CR",  "Should not dup: depth 1", TEST_NORMAL, 0, 1},
-            {"empty_stack", "?DUP",               "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"nonzero",     "42 ?DUP . . CR",     "Should print: 42 42",     TEST_NORMAL, 0, 1, {0}},
+            {"negative",    "-5 ?DUP . . CR",     "Should print: -5 -5",     TEST_NORMAL, 0, 1, {0}},
+            {"zero",        "0 ?DUP DEPTH . CR",  "Should not dup: depth 1", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "?DUP",               "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "-ROT", {
-            {"basic",       "1 2 3 -ROT . . . CR",       "Should print: 1 3 2",              TEST_NORMAL, 0, 1},
-            {"zeros",       "0 0 0 -ROT . . . CR",       "Should print: 0 0 0",              TEST_NORMAL, 0, 1},
-            {"roundtrip",   "1 2 3 -ROT ROT . . . CR",   "Should restore original order",    TEST_NORMAL, 0, 1},
-            {"two_items",   "1 2 -ROT",                  "Should cause stack underflow",     TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "-ROT",                      "Should cause stack underflow",     TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic",       "1 2 3 -ROT . . . CR",       "Should print: 1 3 2",              TEST_NORMAL, 0, 1, {0}},
+            {"zeros",       "0 0 0 -ROT . . . CR",       "Should print: 0 0 0",              TEST_NORMAL, 0, 1, {0}},
+            {"roundtrip",   "1 2 3 -ROT ROT . . . CR",   "Should restore original order",    TEST_NORMAL, 0, 1, {0}},
+            {"two_items",   "1 2 -ROT",                  "Should cause stack underflow",     TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "-ROT",                      "Should cause stack underflow",     TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/starforth_words_test.c b/src/test_runner/modules/starforth_words_test.c
index 121c792..ed8b3cc 100644
--- a/src/test_runner/modules/starforth_words_test.c
+++ b/src/test_runner/modules/starforth_words_test.c
@@ -61,26 +61,26 @@ static WordTestSuite starforth_word_suites[] = {
             /* Basic functionality - ' returns xt (DictEntry*), NOT body address */
             {
                 "after_execution", ": TESTWORD 1 1 + DROP ; TESTWORD ' TESTWORD ENTROPY@ . CR",
-                "Should show execution count > 0", TEST_NORMAL, 0, 1
+                "Should show execution count > 0", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "zero_initial", ": NEWWORD ; ' NEWWORD ENTROPY@ . CR",
-                "Should show 0 for unused word", TEST_NORMAL, 0, 1
+                "Should show 0 for unused word", TEST_NORMAL, 0, 1, {0}
             },
 
             /* Multiple executions */
             {
                 "multiple_calls", ": ENTTEST 1 DROP ; ENTTEST ENTTEST ENTTEST ' ENTTEST ENTROPY@ . CR",
-                "Should increment with each call", TEST_NORMAL, 0, 1
+                "Should increment with each call", TEST_NORMAL, 0, 1, {0}
             },
 
             /* Error cases */
-            {"null_addr", "0 ENTROPY@", "Should handle null address", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "ENTROPY@", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
+            {"null_addr", "0 ENTROPY@", "Should handle null address", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "ENTROPY@", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
@@ -88,26 +88,26 @@ static WordTestSuite starforth_word_suites[] = {
             /* Basic functionality - ' returns xt (DictEntry*), NOT body address */
             {
                 "set_entropy", ": ENTSET ; 42 ' ENTSET ENTROPY! ' ENTSET ENTROPY@ . CR",
-                "Should set entropy to 42", TEST_NORMAL, 0, 1
+                "Should set entropy to 42", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "overwrite",
                 ": ENTOV ; 10 ' ENTOV ENTROPY! 20 ' ENTOV ENTROPY! ' ENTOV ENTROPY@ . CR",
-                "Should overwrite previous value", TEST_NORMAL, 0, 1
+                "Should overwrite previous value", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "zero_entropy", ": ENTZERO ; 0 ' ENTZERO ENTROPY! ' ENTZERO ENTROPY@ . CR",
-                "Should set entropy to 0", TEST_NORMAL, 0, 1
+                "Should set entropy to 0", TEST_NORMAL, 0, 1, {0}
             },
 
             /* Error cases */
-            {"null_addr", "42 0 ENTROPY!", "Should handle null address", TEST_ERROR_CASE, 1, 1},
-            {"one_arg", "42 ENTROPY!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {"empty_stack", "ENTROPY!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
+            {"null_addr", "42 0 ENTROPY!", "Should handle null address", TEST_ERROR_CASE, 1, 1, {0}},
+            {"one_arg", "42 ENTROPY!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {"empty_stack", "ENTROPY!", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
@@ -115,22 +115,22 @@ static WordTestSuite starforth_word_suites[] = {
             /* Basic functionality - WORD-ENTROPY just prints stats, no stack interaction */
             {
                 "display_all", "1 DUP DUP DUP DROP DROP DROP DROP WORD-ENTROPY",
-                "Should display all word entropy stats", TEST_NORMAL, 0, 1
+                "Should display all word entropy stats", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "after_execution", ": WDENT 1 2 + DROP ; WDENT WDENT WORD-ENTROPY",
-                "Should show defined word entropy", TEST_NORMAL, 0, 1
+                "Should show defined word entropy", TEST_NORMAL, 0, 1, {0}
             },
 
             /* No stack effect */
             {
                 "stack_preserved", "DEPTH WORD-ENTROPY DEPTH = . CR",
-                "Should not affect stack", TEST_NORMAL, 0, 1
+                "Should not affect stack", TEST_NORMAL, 0, 1, {0}
             },
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
@@ -138,21 +138,21 @@ static WordTestSuite starforth_word_suites[] = {
             /* Basic functionality */
             {
                 "reset_defined", ": RESETTEST 1 DROP ; RESETTEST RESETTEST RESETTEST RESET-ENTROPY",
-                "Should reset all entropy counters", TEST_NORMAL, 0, 1
+                "Should reset all entropy counters", TEST_NORMAL, 0, 1, {0}
             },
 
             /* Idempotent */
-            {"double_reset", "RESET-ENTROPY RESET-ENTROPY", "Should handle multiple resets", TEST_NORMAL, 0, 1},
+            {"double_reset", "RESET-ENTROPY RESET-ENTROPY", "Should handle multiple resets", TEST_NORMAL, 0, 1, {0}},
 
             /* Verify it runs without error */
             {
                 "after_usage", "1 DUP DUP DUP DROP DROP DROP DROP RESET-ENTROPY", "Should reset after word usage",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
@@ -160,47 +160,47 @@ static WordTestSuite starforth_word_suites[] = {
             /* Basic functionality - TOP-WORDS requires ( n -- ) stack parameter */
             {
                 "display_top5", ": TOPTEST 1 DROP ; TOPTEST TOPTEST TOPTEST TOPTEST TOPTEST 5 TOP-WORDS",
-                "Should display top 5 hot words", TEST_NORMAL, 0, 1
+                "Should display top 5 hot words", TEST_NORMAL, 0, 1, {0}
             },
-            {"display_top10", "10 TOP-WORDS", "Should display top 10 words", TEST_NORMAL, 0, 1},
-            {"after_reset", "RESET-ENTROPY 5 TOP-WORDS", "Should handle display after reset", TEST_NORMAL, 0, 1},
+            {"display_top10", "10 TOP-WORDS", "Should display top 10 words", TEST_NORMAL, 0, 1, {0}},
+            {"after_reset", "RESET-ENTROPY 5 TOP-WORDS", "Should handle display after reset", TEST_NORMAL, 0, 1, {0}},
 
             /* Different counts */
-            {"single_word", "1 TOP-WORDS", "Should display top 1 word", TEST_NORMAL, 0, 1},
-            {"large_count", "100 TOP-WORDS", "Should handle large count", TEST_NORMAL, 0, 1},
+            {"single_word", "1 TOP-WORDS", "Should display top 1 word", TEST_NORMAL, 0, 1, {0}},
+            {"large_count", "100 TOP-WORDS", "Should handle large count", TEST_NORMAL, 0, 1, {0}},
 
             /* Error cases */
-            {"zero_count", "0 TOP-WORDS", "Should handle zero count", TEST_NORMAL, 0, 1},
-            {"negative_count", "-5 TOP-WORDS", "Should handle negative count", TEST_NORMAL, 0, 1},
-            {"empty_stack", "TOP-WORDS", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
+            {"zero_count", "0 TOP-WORDS", "Should handle zero count", TEST_NORMAL, 0, 1, {0}},
+            {"negative_count", "-5 TOP-WORDS", "Should handle negative count", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "TOP-WORDS", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        8
+        8, {0}
     },
 
     {
         "(-", {
             /* Basic functionality */
-            {"comment_line", "(- This is a comment\n1 2 + . CR", "Should ignore rest of line", TEST_NORMAL, 0, 1},
-            {"mid_line", "1 (- comment here\n2 + . CR", "Should work mid-expression", TEST_NORMAL, 0, 1},
+            {"comment_line", "(- This is a comment\n1 2 + . CR", "Should ignore rest of line", TEST_NORMAL, 0, 1, {0}},
+            {"mid_line", "1 (- comment here\n2 + . CR", "Should work mid-expression", TEST_NORMAL, 0, 1, {0}},
 
             /* Stack preservation */
-            {"no_stack_effect", "DEPTH (- comment\nDEPTH = . CR", "Should not affect stack", TEST_NORMAL, 0, 1},
+            {"no_stack_effect", "DEPTH (- comment\nDEPTH = . CR", "Should not affect stack", TEST_NORMAL, 0, 1, {0}},
 
             /* Multiple comments */
-            {"multiple", "1 (- first\n2 (- second\n+ . CR", "Should handle multiple comments", TEST_NORMAL, 0, 1},
+            {"multiple", "1 (- first\n2 (- second\n+ . CR", "Should handle multiple comments", TEST_NORMAL, 0, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     /* INIT intentionally not tested here - it's a startup operation that loads
      * and executes init.4th. Running it during POST would cause double-initialization. */
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/stress_tests.c b/src/test_runner/modules/stress_tests.c
index 5a3b433..aac890c 100644
--- a/src/test_runner/modules/stress_tests.c
+++ b/src/test_runner/modules/stress_tests.c
@@ -76,24 +76,24 @@ static WordTestSuite stress_suites[] = {
     /* ===== 1. STACK DEPTH TESTS ===== */
     {
         "STACK_DEPTH", {
-            {"deep_push", ": PUSH-100 0 100 0 DO I LOOP ; PUSH-100 DEPTH . CR", "Push 100 items", TEST_NORMAL, 0, 1},
-            {"deep_math", ": MATH-STRESS 1 100 0 DO 1+ LOOP . CR ; MATH-STRESS", "100 additions", TEST_NORMAL, 0, 1},
+            {"deep_push", ": PUSH-100 0 100 0 DO I LOOP ; PUSH-100 DEPTH . CR", "Push 100 items", TEST_NORMAL, 0, 1, {0}},
+            {"deep_math", ": MATH-STRESS 1 100 0 DO 1+ LOOP . CR ; MATH-STRESS", "100 additions", TEST_NORMAL, 0, 1, {0}},
             {
                 "dup_stress", ": DUP-STRESS 42 50 0 DO DUP LOOP DEPTH . CR 51 0 DO DROP LOOP ; DUP-STRESS", "50 DUPs",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "deep_push_200",
                 ": PUSH-200 0 200 0 DO I LOOP ; : CLR-200 200 0 DO DROP LOOP ; PUSH-200 DEPTH . CR CLR-200",
-                "Push 200 items", TEST_NORMAL, 0, 1
+                "Push 200 items", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "mixed_ops", ": MIXED 1 2 3 4 5 6 7 8 9 10 50 0 DO SWAP ROT LOOP 10 0 DO DROP LOOP ; MIXED",
-                "Mixed stack ops", TEST_NORMAL, 0, 1
+                "Mixed stack ops", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     /* ===== 2. STACK BOUNDARY TESTS ===== */
@@ -102,24 +102,24 @@ static WordTestSuite stress_suites[] = {
             {
                 "near_limit_900",
                 ": PUSH-900 0 900 0 DO I LOOP ; : CLR-900 900 0 DO DROP LOOP ; PUSH-900 DEPTH . CR CLR-900 FORGET CLR-900",
-                "Push 900 items (near 1024 limit)", TEST_EDGE_CASE, 0, 1
+                "Push 900 items (near 1024 limit)", TEST_EDGE_CASE, 0, 1, {0}
             },
-            {"underflow_detect", "DROP", "Stack underflow detection", TEST_ERROR_CASE, 1, 1},
-            {"dup_underflow", "DUP", "DUP underflow detection", TEST_ERROR_CASE, 1, 1},
-            {"swap_underflow", "1 SWAP", "SWAP underflow detection", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"underflow_detect", "DROP", "Stack underflow detection", TEST_ERROR_CASE, 1, 1, {0}},
+            {"dup_underflow", "DUP", "DUP underflow detection", TEST_ERROR_CASE, 1, 1, {0}},
+            {"swap_underflow", "1 SWAP", "SWAP underflow detection", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     /* ===== 3. RETURN STACK STRESS ===== */
     {
         "RETURN_STACK", {
-            {"basic_to_r", "1 2 3 >R >R >R R> R> R> + + . CR", "Basic >R/R> test", TEST_NORMAL, 0, 1},
-            {"r_fetch", "42 >R R@ . CR R> DROP", "R@ test", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic_to_r", "1 2 3 >R >R >R R> R> R> + + . CR", "Basic >R/R> test", TEST_NORMAL, 0, 1, {0}},
+            {"r_fetch", "42 >R R@ . CR R> DROP", "R@ test", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* ===== 4. DEEP NESTING TESTS ===== */
@@ -128,58 +128,58 @@ static WordTestSuite stress_suites[] = {
             {
                 "nested_if_5",
                 ": NEST5 DUP 0> IF DUP 10 > IF DUP 20 > IF DUP 30 > IF DUP 40 > IF 5 ELSE 4 THEN ELSE 3 THEN ELSE 2 THEN ELSE 1 THEN ELSE 0 THEN . CR ; 45 NEST5",
-                "5-level IF nesting", TEST_NORMAL, 0, 1
+                "5-level IF nesting", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "nested_loops_4", ": NEST-4 0 2 0 DO 2 0 DO 2 0 DO 2 0 DO 1+ LOOP LOOP LOOP LOOP . CR ; NEST-4",
-                "4-level DO loop nesting", TEST_NORMAL, 0, 1
+                "4-level DO loop nesting", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "mixed_if_do", ": MIX-NEST 0 10 0> IF 5 0 DO 1+ LOOP ELSE 3 0 DO 2 + LOOP THEN . CR ; MIX-NEST",
-                "IF with DO inside", TEST_NORMAL, 0, 1
+                "IF with DO inside", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "begin_simple", ": BEGIN-TEST 5 BEGIN 1- DUP 0= UNTIL DROP ; BEGIN-TEST",
-                "Simple BEGIN/UNTIL loop", TEST_NORMAL, 0, 1
+                "Simple BEGIN/UNTIL loop", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     /* ===== 5. CONTROL FLOW EDGE CASES ===== */
     {
         "CONTROL_EDGE", {
-            {"empty_loop", ": EMPTY-LOOP 0 0 DO LOOP ; EMPTY-LOOP", "Empty loop body", TEST_NORMAL, 0, 1},
-            {"single_iter", ": SINGLE 1 0 DO 42 . LOOP CR ; SINGLE", "Single iteration", TEST_NORMAL, 0, 1},
-            {"large_count", ": BIG-LOOP 0 10000 0 DO 1+ LOOP . CR ; BIG-LOOP", "10000 iterations", TEST_NORMAL, 0, 1},
+            {"empty_loop", ": EMPTY-LOOP 0 0 DO LOOP ; EMPTY-LOOP", "Empty loop body", TEST_NORMAL, 0, 1, {0}},
+            {"single_iter", ": SINGLE 1 0 DO 42 . LOOP CR ; SINGLE", "Single iteration", TEST_NORMAL, 0, 1, {0}},
+            {"large_count", ": BIG-LOOP 0 10000 0 DO 1+ LOOP . CR ; BIG-LOOP", "10000 iterations", TEST_NORMAL, 0, 1, {0}},
             {
                 "nested_exit", ": NEST-EXIT 10 0 DO I 5 = IF EXIT THEN I . LOOP CR ; NEST-EXIT", "EXIT in nested loop",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
             {
                 "begin_while", ": B-W-R 10 BEGIN DUP 0> WHILE DUP . 1- REPEAT DROP CR ; B-W-R", "BEGIN WHILE REPEAT",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     /* ===== 6. NUMERIC BOUNDARIES ===== */
     {
         "NUMERIC_BOUNDARY", {
-            {"max_int", ": MAX-TEST 2147483647 DUP . 1+ . CR ; MAX-TEST", "Max int boundary", TEST_EDGE_CASE, 0, 1},
-            {"min_int", ": MIN-TEST -2147483648 DUP . 1- . CR ; MIN-TEST", "Min int boundary", TEST_EDGE_CASE, 0, 1},
-            {"large_mult", ": BIG-MULT 10000 10000 * . CR ; BIG-MULT", "Large multiplication", TEST_NORMAL, 0, 1},
+            {"max_int", ": MAX-TEST 2147483647 DUP . 1+ . CR ; MAX-TEST", "Max int boundary", TEST_EDGE_CASE, 0, 1, {0}},
+            {"min_int", ": MIN-TEST -2147483648 DUP . 1- . CR ; MIN-TEST", "Min int boundary", TEST_EDGE_CASE, 0, 1, {0}},
+            {"large_mult", ": BIG-MULT 10000 10000 * . CR ; BIG-MULT", "Large multiplication", TEST_NORMAL, 0, 1, {0}},
             {
                 "div_edge", ": DIV-TEST 100 1 / 100 2 / 100 3 / . . . CR ; DIV-TEST", "Division edge cases",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"mod_edge", ": MOD-TEST 100 7 MOD 100 3 MOD . . CR ; MOD-TEST", "Modulo operations", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"mod_edge", ": MOD-TEST 100 7 MOD 100 3 MOD . . CR ; MOD-TEST", "Modulo operations", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     /* ===== 7. WORD EXECUTION CHAINS ===== */
@@ -188,16 +188,16 @@ static WordTestSuite stress_suites[] = {
             {
                 "chain_10",
                 ": C1 1 ; : C2 C1 1+ ; : C3 C2 1+ ; : C4 C3 1+ ; : C5 C4 1+ ; : C6 C5 1+ ; : C7 C6 1+ ; : C8 C7 1+ ; : C9 C8 1+ ; : C10 C9 1+ ; C10 . CR",
-                "10-word call chain", TEST_NORMAL, 0, 1
+                "10-word call chain", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "chain_20",
                 ": D1 1 ; : D2 D1 1+ ; : D3 D2 1+ ; : D4 D3 1+ ; : D5 D4 1+ ; : D6 D5 1+ ; : D7 D6 1+ ; : D8 D7 1+ ; : D9 D8 1+ ; : D10 D9 1+ ; : D11 D10 1+ ; : D12 D11 1+ ; : D13 D12 1+ ; : D14 D13 1+ ; : D15 D14 1+ ; : D16 D15 1+ ; : D17 D16 1+ ; : D18 D17 1+ ; : D19 D18 1+ ; : D20 D19 1+ ; D20 . CR",
-                "20-word call chain", TEST_NORMAL, 0, 1
+                "20-word call chain", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* ===== 8. LARGE DEFINITIONS ===== */
@@ -206,16 +206,16 @@ static WordTestSuite stress_suites[] = {
             {
                 "long_sequence_50",
                 ": LONG50 1 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ 1+ . CR ; LONG50",
-                "50+ operations", TEST_NORMAL, 0, 1
+                "50+ operations", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "many_literals",
                 ": LITS 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 + + + + + + + + + + + + + + + + + + + . CR ; LITS",
-                "20 literals", TEST_NORMAL, 0, 1
+                "20 literals", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* ===== 9. DICTIONARY PRESSURE ===== */
@@ -224,58 +224,57 @@ static WordTestSuite stress_suites[] = {
             {
                 "many_defs",
                 ": T1 1 ; : T2 2 ; : T3 3 ; : T4 4 ; : T5 5 ; : T6 6 ; : T7 7 ; : T8 8 ; : T9 9 ; : T10 10 ; : T11 11 ; : T12 12 ; : T13 13 ; : T14 14 ; : T15 15 ; : T16 16 ; : T17 17 ; : T18 18 ; : T19 19 ; : T20 20 ; T20 . CR",
-                "20 word definitions", TEST_NORMAL, 0, 1
+                "20 word definitions", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "long_name", ": VERY-LONG-WORD-NAME-TEST-MAX 42 . CR ; VERY-LONG-WORD-NAME-TEST-MAX",
-                "Long word name (31 chars)", TEST_NORMAL, 0, 1
+                "Long word name (31 chars)", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* ===== 10. MEMORY ALLOCATION STRESS ===== */
     {
         "MEMORY_STRESS", {
             {
-                "allot_100", ": ALLOT-100 HERE 100 ALLOT HERE SWAP - . CR ; ALLOT-100", "ALLOT 100 bytes", TEST_NORMAL,
-                0, 1
+                "allot_100", ": ALLOT-100 HERE 100 ALLOT HERE SWAP - . CR ; ALLOT-100", "ALLOT 100 bytes", TEST_NORMAL, 0, 1, {0}
             },
-            {"allot_1000", ": ALLOT-1K HERE 1000 ALLOT HERE SWAP - . CR ; ALLOT-1K", "ALLOT 1KB", TEST_NORMAL, 0, 1},
-            {"allot_8k", ": ALLOT-8K HERE 8192 ALLOT HERE SWAP - . CR ; ALLOT-8K", "ALLOT 8KB", TEST_NORMAL, 0, 1},
+            {"allot_1000", ": ALLOT-1K HERE 1000 ALLOT HERE SWAP - . CR ; ALLOT-1K", "ALLOT 1KB", TEST_NORMAL, 0, 1, {0}},
+            {"allot_8k", ": ALLOT-8K HERE 8192 ALLOT HERE SWAP - . CR ; ALLOT-8K", "ALLOT 8KB", TEST_NORMAL, 0, 1, {0}},
             {
                 "multiple_allots", ": MULTI-ALLOT HERE 10 ALLOT 20 ALLOT 30 ALLOT HERE SWAP - . CR ; MULTI-ALLOT",
-                "Multiple ALLOTs", TEST_NORMAL, 0, 1
+                "Multiple ALLOTs", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "allot_pattern", ": PATTERN 5 0 DO HERE 100 ALLOT DROP LOOP ; PATTERN", "Repeated allot pattern",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     /* ===== 11. ERROR RECOVERY ===== */
     {
         "ERROR_RECOVERY", {
-            {"abort_recovery", ": AB-TEST 1 2 3 ABORT ; AB-TEST DEPTH . CR", "ABORT clears stacks", TEST_NORMAL, 0, 1},
-            {"continue_after_abort", "ABORT 42 . CR", "Can continue after ABORT", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"abort_recovery", ": AB-TEST 1 2 3 ABORT ; AB-TEST DEPTH . CR", "ABORT clears stacks", TEST_NORMAL, 0, 1, {0}},
+            {"continue_after_abort", "ABORT 42 . CR", "Can continue after ABORT", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* ===== 12. DOUBLE NUMBER STRESS ===== */
     {
         "DOUBLE_STRESS", {
-            {"large_double_add", "1000000 0 2000000 0 D+ . . CR", "Large double addition", TEST_NORMAL, 0, 1},
-            {"double_chain", "100 200 2DUP D+ . . CR", "Double operation chain", TEST_NORMAL, 0, 1},
-            {"double_negate", "100 200 DNEGATE DNEGATE . . CR", "Double negate twice", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"large_double_add", "1000000 0 2000000 0 D+ . . CR", "Large double addition", TEST_NORMAL, 0, 1, {0}},
+            {"double_chain", "100 200 2DUP D+ . . CR", "Double operation chain", TEST_NORMAL, 0, 1, {0}},
+            {"double_negate", "100 200 DNEGATE DNEGATE . . CR", "Double negate twice", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     /* ===== 13. MIXED COMPLEXITY ===== */
@@ -284,26 +283,26 @@ static WordTestSuite stress_suites[] = {
             {
                 "nested_if_do",
                 ": COMPLEX 10 0 DO I DUP 5 > IF 2 * ELSE 3 + THEN . LOOP CR ; COMPLEX",
-                "Mixed IF/DO", TEST_NORMAL, 0, 1
+                "Mixed IF/DO", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "nested_begin_do",
                 ": NB-DO 5 BEGIN DUP 0> WHILE DUP 3 0 DO I . LOOP CR 1- REPEAT DROP ; NB-DO",
-                "Nested BEGIN/DO", TEST_NORMAL, 0, 1
+                "Nested BEGIN/DO", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* ===== 14. STRING/BUFFER EDGE CASES ===== */
     {
         "STRING_EDGE", {
-            {"empty_def", ": EMPTY ; EMPTY", "Empty definition", TEST_NORMAL, 0, 1},
-            {"single_word", ": SINGLE DUP ; 42 SINGLE . . CR", "Single word def", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"empty_def", ": EMPTY ; EMPTY", "Empty definition", TEST_NORMAL, 0, 1, {0}},
+            {"single_word", ": SINGLE DUP ; 42 SINGLE . . CR", "Single word def", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 };
 
diff --git a/src/test_runner/modules/string_words_test.c b/src/test_runner/modules/string_words_test.c
index e45b3f0..8220bbf 100644
--- a/src/test_runner/modules/string_words_test.c
+++ b/src/test_runner/modules/string_words_test.c
@@ -47,157 +47,156 @@
 static WordTestSuite string_word_suites[] = {
     {
         "COUNT", {
-            {"basic", "HERE S\" Test\" DROP COUNT . . CR", "Should show length and addr+1", TEST_NORMAL, 0, 1},
-            {"empty", "HERE 0 OVER C! COUNT . . CR", "Should handle empty string", TEST_NORMAL, 0, 1},
-            {"max_length", "HERE 255 OVER C! COUNT . . CR", "Should handle max length", TEST_NORMAL, 0, 1},
-            {"string_bounds", "HERE COUNT SWAP 1- = . CR", "Should increment address", TEST_NORMAL, 0, 1},
-            {"empty_stack", "COUNT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE S\" Test\" DROP COUNT . . CR", "Should show length and addr+1", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "HERE 0 OVER C! COUNT . . CR", "Should handle empty string", TEST_NORMAL, 0, 1, {0}},
+            {"max_length", "HERE 255 OVER C! COUNT . . CR", "Should handle max length", TEST_NORMAL, 0, 1, {0}},
+            {"string_bounds", "HERE COUNT SWAP 1- = . CR", "Should increment address", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "COUNT", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "-TRAILING", {
-            {"basic", "HERE S\"  Test  \" -TRAILING TYPE CR", "Should trim spaces", TEST_NORMAL, 0, 1},
-            {"all_spaces", "HERE S\"     \" -TRAILING TYPE CR", "Should handle all spaces", TEST_NORMAL, 0, 1},
-            {"no_spaces", "HERE S\" Test\" -TRAILING TYPE CR", "Should handle no spaces", TEST_NORMAL, 0, 1},
-            {"empty", "HERE 0 -TRAILING TYPE CR", "Should handle empty string", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE S\"  Test  \" -TRAILING TYPE CR", "Should trim spaces", TEST_NORMAL, 0, 1, {0}},
+            {"all_spaces", "HERE S\"     \" -TRAILING TYPE CR", "Should handle all spaces", TEST_NORMAL, 0, 1, {0}},
+            {"no_spaces", "HERE S\" Test\" -TRAILING TYPE CR", "Should handle no spaces", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "HERE 0 -TRAILING TYPE CR", "Should handle empty string", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "CMOVE", {
-            {"basic", "HERE S\" Test\" DUP >R HERE 10 + SWAP CMOVE CR", "Should copy string", TEST_NORMAL, 0, 1},
-            {"empty", "HERE HERE 10 + 0 CMOVE", "Should handle zero count", TEST_NORMAL, 0, 1},
-            {"overlap", "HERE DUP 1+ 5 CMOVE", "Should handle overlap", TEST_NORMAL, 0, 1},
-            {"bounds", "HERE PAD 1000 CMOVE", "Should check bounds", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE S\" Test\" DUP >R HERE 10 + SWAP CMOVE CR", "Should copy string", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "HERE HERE 10 + 0 CMOVE", "Should handle zero count", TEST_NORMAL, 0, 1, {0}},
+            {"overlap", "HERE DUP 1+ 5 CMOVE", "Should handle overlap", TEST_NORMAL, 0, 1, {0}},
+            {"bounds", "HERE PAD 1000 CMOVE", "Should check bounds", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "CMOVE>", {
-            {"basic", "HERE S\" Test\" DUP >R HERE 10 + SWAP CMOVE> CR", "Should copy backward", TEST_NORMAL, 0, 1},
-            {"empty", "HERE HERE 10 + 0 CMOVE>", "Should handle zero count", TEST_NORMAL, 0, 1},
-            {"overlap", "HERE DUP 1+ 5 CMOVE>", "Should handle overlap", TEST_NORMAL, 0, 1},
-            {"bounds", "HERE PAD 1000 CMOVE>", "Should check bounds", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE S\" Test\" DUP >R HERE 10 + SWAP CMOVE> CR", "Should copy backward", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "HERE HERE 10 + 0 CMOVE>", "Should handle zero count", TEST_NORMAL, 0, 1, {0}},
+            {"overlap", "HERE DUP 1+ 5 CMOVE>", "Should handle overlap", TEST_NORMAL, 0, 1, {0}},
+            {"bounds", "HERE PAD 1000 CMOVE>", "Should check bounds", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "COMPARE", {
-            {"equal", "HERE S\" Test\" HERE S\" Test\" COMPARE . CR", "Should return 0", TEST_NORMAL, 0, 1},
-            {"less", "HERE S\" Test1\" HERE S\" Test2\" COMPARE . CR", "Should return -1", TEST_NORMAL, 0, 1},
-            {"greater", "HERE S\" Test2\" HERE S\" Test1\" COMPARE . CR", "Should return 1", TEST_NORMAL, 0, 1},
+            {"equal", "HERE S\" Test\" HERE S\" Test\" COMPARE . CR", "Should return 0", TEST_NORMAL, 0, 1, {0}},
+            {"less", "HERE S\" Test1\" HERE S\" Test2\" COMPARE . CR", "Should return -1", TEST_NORMAL, 0, 1, {0}},
+            {"greater", "HERE S\" Test2\" HERE S\" Test1\" COMPARE . CR", "Should return 1", TEST_NORMAL, 0, 1, {0}},
             {
                 "different_lengths", "HERE S\" Test\" HERE S\" Testing\" COMPARE . CR", "Should handle lengths",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"empty", "HERE 0 HERE 0 COMPARE . CR", "Should handle empty", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"empty", "HERE 0 HERE 0 COMPARE . CR", "Should handle empty", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        5
+        5, {0}
     },
 
     {
         "SEARCH", {
-            {"found", "HERE S\" Testing\" HERE S\" Test\" SEARCH . . . CR", "Should find substring", TEST_NORMAL, 0, 1},
+            {"found", "HERE S\" Testing\" HERE S\" Test\" SEARCH . . . CR", "Should find substring", TEST_NORMAL, 0, 1, {0}},
             {
                 "not_found", "HERE S\" Testing\" HERE S\" Xyz\" SEARCH . . . CR", "Should return false", TEST_NORMAL, 0,
-                1
+                1, {0}
             },
             {
-                "empty_pattern", "HERE S\" Test\" HERE 0 SEARCH . . . CR", "Should handle empty pattern", TEST_NORMAL,
-                0, 1
+                "empty_pattern", "HERE S\" Test\" HERE 0 SEARCH . . . CR", "Should handle empty pattern", TEST_NORMAL, 0, 1, {0}
             },
-            {"empty_string", "HERE 0 HERE S\" Test\" SEARCH . . . CR", "Should handle empty string", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"empty_string", "HERE 0 HERE S\" Test\" SEARCH . . . CR", "Should handle empty string", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SCAN", {
-            {"basic", "HERE S\" Test,Data\" BL SCAN TYPE CR", "Should find space", TEST_NORMAL, 0, 1},
-            {"not_found", "HERE S\" TestData\" BL SCAN TYPE CR", "Should scan to end", TEST_NORMAL, 0, 1},
-            {"empty", "HERE 0 BL SCAN TYPE CR", "Should handle empty", TEST_NORMAL, 0, 1},
-            {"all_delims", "HERE S\"     \" BL SCAN TYPE CR", "Should handle all delims", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE S\" Test,Data\" BL SCAN TYPE CR", "Should find space", TEST_NORMAL, 0, 1, {0}},
+            {"not_found", "HERE S\" TestData\" BL SCAN TYPE CR", "Should scan to end", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "HERE 0 BL SCAN TYPE CR", "Should handle empty", TEST_NORMAL, 0, 1, {0}},
+            {"all_delims", "HERE S\"     \" BL SCAN TYPE CR", "Should handle all delims", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "SKIP", {
-            {"basic", "HERE S\"   Test\" BL SKIP TYPE CR", "Should skip spaces", TEST_NORMAL, 0, 1},
-            {"no_delims", "HERE S\" Test\" BL SKIP TYPE CR", "Should not skip", TEST_NORMAL, 0, 1},
-            {"empty", "HERE 0 BL SKIP TYPE CR", "Should handle empty", TEST_NORMAL, 0, 1},
-            {"all_delims", "HERE S\"     \" BL SKIP TYPE CR", "Should skip all", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "HERE S\"   Test\" BL SKIP TYPE CR", "Should skip spaces", TEST_NORMAL, 0, 1, {0}},
+            {"no_delims", "HERE S\" Test\" BL SKIP TYPE CR", "Should not skip", TEST_NORMAL, 0, 1, {0}},
+            {"empty", "HERE 0 BL SKIP TYPE CR", "Should handle empty", TEST_NORMAL, 0, 1, {0}},
+            {"all_delims", "HERE S\"     \" BL SKIP TYPE CR", "Should skip all", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        4
+        4, {0}
     },
 
     {
         "BLANK", {
-            {"basic", "HERE 5 BLANK HERE 5 TYPE CR", "Should fill with spaces", TEST_NORMAL, 0, 1},
-            {"zero", "HERE 0 BLANK HERE 0 TYPE CR", "Should handle zero count", TEST_NORMAL, 0, 1},
+            {"basic", "HERE 5 BLANK HERE 5 TYPE CR", "Should fill with spaces", TEST_NORMAL, 0, 1, {0}},
+            {"zero", "HERE 0 BLANK HERE 0 TYPE CR", "Should handle zero count", TEST_NORMAL, 0, 1, {0}},
             /* TODO: Bounds checking - memory subsystem doesn't yet enforce upper bounds */
             /* {"bounds", "HERE 2000000 BLANK", "Should check bounds", TEST_ERROR_CASE, 1, 1}, */
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "S\"", {
-            {"interpret_len",  "S\" hello\" . CR",                              "Should print: 5 (length)",  TEST_NORMAL, 0, 1},
-            {"interpret_type", "S\" hello\" TYPE CR",                           "Should print: hello",       TEST_NORMAL, 0, 1},
-            {"empty",          "S\" \" . CR",                                   "Should print: 0",           TEST_NORMAL, 0, 1},
-            {"compile_type",   ": TSQ S\" world\" TYPE CR ; TSQ",               "Should print: world",       TEST_NORMAL, 0, 1},
-            {"compile_len",    ": TSQ2 S\" forth\" SWAP DROP . CR ; TSQ2",       "Should print: 5",           TEST_NORMAL, 0, 1},
-            {"compile_twice",  ": TSQ3 S\" ab\" TYPE S\" cd\" TYPE CR ; TSQ3",  "Should print: abcd",        TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"interpret_len",  "S\" hello\" . CR",                              "Should print: 5 (length)",  TEST_NORMAL, 0, 1, {0}},
+            {"interpret_type", "S\" hello\" TYPE CR",                           "Should print: hello",       TEST_NORMAL, 0, 1, {0}},
+            {"empty",          "S\" \" . CR",                                   "Should print: 0",           TEST_NORMAL, 0, 1, {0}},
+            {"compile_type",   ": TSQ S\" world\" TYPE CR ; TSQ",               "Should print: world",       TEST_NORMAL, 0, 1, {0}},
+            {"compile_len",    ": TSQ2 S\" forth\" SWAP DROP . CR ; TSQ2",       "Should print: 5",           TEST_NORMAL, 0, 1, {0}},
+            {"compile_twice",  ": TSQ3 S\" ab\" TYPE S\" cd\" TYPE CR ; TSQ3",  "Should print: abcd",        TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        6
+        6, {0}
     },
 
     {
         "BL", {
-            {"value",    "BL . CR",              "Should print: 32",          TEST_NORMAL, 0, 1},
-            {"as_char",  "BL EMIT CR",           "Should emit a space",       TEST_NORMAL, 0, 1},
-            {"in_scan",  "HERE S\" a b\" BL SCAN SWAP DROP . CR", "Should find space at offset 1", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"value",    "BL . CR",              "Should print: 32",          TEST_NORMAL, 0, 1, {0}},
+            {"as_char",  "BL EMIT CR",           "Should emit a space",       TEST_NORMAL, 0, 1, {0}},
+            {"in_scan",  "HERE S\" a b\" BL SCAN SWAP DROP . CR", "Should find space at offset 1", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "SOURCE", {
-            {"returns_pair", "SOURCE SWAP DROP 0< NOT . CR",        "Should return non-negative length", TEST_NORMAL, 0, 1},
-            {"has_addr",     "SOURCE DROP 0<> . CR",         "Should return non-null address",    TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"returns_pair", "SOURCE SWAP DROP 0< NOT . CR",        "Should return non-negative length", TEST_NORMAL, 0, 1, {0}},
+            {"has_addr",     "SOURCE DROP 0<> . CR",         "Should return non-null address",    TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         ">IN", {
-            {"initial",    ">IN @ . CR",                   "Should return input offset",    TEST_NORMAL, 0, 1},
-            {"advances",   ": TWIN >IN @ >IN @ - . CR ; TWIN",           "Should print: 0 (no advance inside compiled word)", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"initial",    ">IN @ . CR",                   "Should return input offset",    TEST_NORMAL, 0, 1, {0}},
+            {"advances",   ": TWIN >IN @ >IN @ - . CR ; TWIN",           "Should print: 0 (no advance inside compiled word)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/system_words_test.c b/src/test_runner/modules/system_words_test.c
index 792f080..434e4af 100644
--- a/src/test_runner/modules/system_words_test.c
+++ b/src/test_runner/modules/system_words_test.c
@@ -51,65 +51,65 @@
 static WordTestSuite system_word_suites[] = {
     {
         "QUIT", {
-            {"basic", "QUIT", "Should reset stacks and state", TEST_NORMAL, 0, 0}, // Interactive
-            {"in_definition", ": BAD-WORD QUIT ;", "Should prevent compilation", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "QUIT", "Should reset stacks and state", TEST_NORMAL, 0, 0, {0}}, // Interactive
+            {"in_definition", ": BAD-WORD QUIT ;", "Should prevent compilation", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        2
+        2, {0}
     },
 
     {
         "ABORT", {
-            {"basic", "ABORT", "Should clear stacks and return to QUIT", TEST_NORMAL, 0, 1},
-            {"with_data", "1 2 3 ABORT DEPTH . CR", "Should clear stack", TEST_NORMAL, 0, 1},
+            {"basic", "ABORT", "Should clear stacks and return to QUIT", TEST_NORMAL, 0, 1, {0}},
+            {"with_data", "1 2 3 ABORT DEPTH . CR", "Should clear stack", TEST_NORMAL, 0, 1, {0}},
             {
                 "in_definition_runtime", ": BAD-WORD ABORT ;  123 BAD-WORD  DEPTH . CR",
-                "ABORT may appear in a definition; when executed it clears both stacks", TEST_NORMAL, 0, 1
+                "ABORT may appear in a definition; when executed it clears both stacks", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "ABORT\"", {
             {
                 "condition_true", "-1 ABORT\" Error\"", "Should abort with message (no error; stacks cleared to QUIT)",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"condition_false", "0 ABORT\" Error\"", "Should not abort", TEST_NORMAL, 0, 1},
-            {"empty_stack", "ABORT\"", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"condition_false", "0 ABORT\" Error\"", "Should not abort", TEST_NORMAL, 0, 1, {0}},
+            {"empty_stack", "ABORT\"", "Should cause stack underflow", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "BYE", {
-            {"basic", "BYE", "Should exit cleanly", TEST_NORMAL, 0, 0}, // Can't really test
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "BYE", "Should exit cleanly", TEST_NORMAL, 0, 0, {0}}, // Can't really test
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        1
+        1, {0}
     },
 
     {
         "COLD", {
-            {"basic", "COLD", "Should reset system", TEST_NORMAL, 0, 0}, // Dangerous to test
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "COLD", "Should reset system", TEST_NORMAL, 0, 0, {0}}, // Dangerous to test
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        1
+        1, {0}
     },
 
     {
         "WARM", {
-            {"basic", "WARM", "Should soft reset", TEST_NORMAL, 0, 0}, // Dangerous to test
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "WARM", "Should soft reset", TEST_NORMAL, 0, 0, {0}}, // Dangerous to test
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        1
+        1, {0}
     },
 
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /**
diff --git a/src/test_runner/modules/vocabulary_words_test.c b/src/test_runner/modules/vocabulary_words_test.c
index 73650a0..aee54dd 100644
--- a/src/test_runner/modules/vocabulary_words_test.c
+++ b/src/test_runner/modules/vocabulary_words_test.c
@@ -51,100 +51,99 @@ static WordTestSuite vocabulary_word_suites[] = {
     {
         "VOCABULARY", {
             /* Basic functionality */
-            {"basic", "VOCABULARY TEST-VOC1 TEST-VOC1 DEFINITIONS", "Should create vocabulary", TEST_NORMAL, 0, 1},
+            {"basic", "VOCABULARY TEST-VOC1 TEST-VOC1 DEFINITIONS", "Should create vocabulary", TEST_NORMAL, 0, 1, {0}},
             {
                 "create_and_switch", "VOCABULARY MYVOC MYVOC DEFINITIONS CONTEXT @ . CR", "Should create and switch",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
 
             /* Word isolation */
             {
                 "word_isolation", "VOCABULARY ISOLATED ISOLATED DEFINITIONS : ISOWORD 99 ; FORTH DEFINITIONS",
-                "Should create word in isolated vocab", TEST_NORMAL, 0, 1
+                "Should create word in isolated vocab", TEST_NORMAL, 0, 1, {0}
             },
             {
                 "cross_vocab_access", "VOCABULARY V1 V1 DEFINITIONS : V1WORD 11 ; FORTH V1WORD . CR",
-                "Should access word across vocabs", TEST_NORMAL, 0, 1
+                "Should access word across vocabs", TEST_NORMAL, 0, 1, {0}
             },
 
             /* Multiple vocabularies */
             {
                 "multiple_vocabs", "VOCABULARY VA VOCABULARY VB VOCABULARY VC VA DEFINITIONS",
-                "Should create multiple vocabs", TEST_NORMAL, 0, 1
+                "Should create multiple vocabs", TEST_NORMAL, 0, 1, {0}
             },
 
             /* Error cases */
             {
                 "duplicate", "VOCABULARY TESTVOC VOCABULARY TESTVOC", "Should handle duplicate", TEST_ERROR_CASE, 1,
-                1
+                1, {0}
             },
-            {"empty_name", "VOCABULARY", "Should handle empty name", TEST_ERROR_CASE, 1, 1},
+            {"empty_name", "VOCABULARY", "Should handle empty name", TEST_ERROR_CASE, 1, 1, {0}},
 
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        7
+        7, {0}
     },
 
     {
         "FORTH", {
-            {"basic", "FORTH DEFINITIONS", "Should select FORTH vocab", TEST_NORMAL, 0, 1},
-            {"persistence", "FORTH : TEST1 42 ; TEST1 . CR", "Should find word in FORTH", TEST_NORMAL, 0, 1},
-            {"from_other", "VOCABULARY OTHER-VOC OTHER-VOC FORTH", "Should return to FORTH", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "FORTH DEFINITIONS", "Should select FORTH vocab", TEST_NORMAL, 0, 1, {0}},
+            {"persistence", "FORTH : TEST1 42 ; TEST1 . CR", "Should find word in FORTH", TEST_NORMAL, 0, 1, {0}},
+            {"from_other", "VOCABULARY OTHER-VOC OTHER-VOC FORTH", "Should return to FORTH", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "DEFINITIONS", {
-            {"basic", "FORTH DEFINITIONS", "Should set current vocabulary", TEST_NORMAL, 0, 1},
-            {"new_vocab", "VOCABULARY TEST-VOC6 TEST-VOC6 DEFINITIONS", "Should set new current", TEST_NORMAL, 0, 1},
+            {"basic", "FORTH DEFINITIONS", "Should set current vocabulary", TEST_NORMAL, 0, 1, {0}},
+            {"new_vocab", "VOCABULARY TEST-VOC6 TEST-VOC6 DEFINITIONS", "Should set new current", TEST_NORMAL, 0, 1, {0}},
             {
                 "word_creation", "VOCABULARY TEST-VOC7 TEST-VOC7 DEFINITIONS : TEST2 43 ;",
-                "Should create in correct vocab", TEST_NORMAL, 0, 1
+                "Should create in correct vocab", TEST_NORMAL, 0, 1, {0}
             },
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "CONTEXT", {
-            {"basic", "CONTEXT @ . CR", "Should show current context", TEST_NORMAL, 0, 1},
-            {"modify", "CONTEXT @ 1+ CONTEXT !", "Should allow modification (impl-defined effect)", TEST_NORMAL, 0, 1},
-            {"initial", "FORTH CONTEXT @ . CR", "Should show FORTH vocab", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"basic", "CONTEXT @ . CR", "Should show current context", TEST_NORMAL, 0, 1, {0}},
+            {"modify", "CONTEXT @ 1+ CONTEXT !", "Should allow modification (impl-defined effect)", TEST_NORMAL, 0, 1, {0}},
+            {"initial", "FORTH CONTEXT @ . CR", "Should show FORTH vocab", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "CURRENT", {
-            {"basic", "CURRENT @ . CR", "Should show current vocab", TEST_NORMAL, 0, 1},
+            {"basic", "CURRENT @ . CR", "Should show current vocab", TEST_NORMAL, 0, 1, {0}},
             {
                 "after_def", "VOCABULARY TEST-VOC8 TEST-VOC8 DEFINITIONS CURRENT @ . CR", "Should show new vocab",
-                TEST_NORMAL, 0, 1
+                TEST_NORMAL, 0, 1, {0}
             },
-            {"protect", "CURRENT @ 1+ CURRENT !", "Should allow modification (impl-defined effect)", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"protect", "CURRENT @ 1+ CURRENT !", "Should allow modification (impl-defined effect)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
 
     {
         "ORDER", {
-            {"basic", "ORDER", "Should list search order", TEST_NORMAL, 0, 1},
+            {"basic", "ORDER", "Should list search order", TEST_NORMAL, 0, 1, {0}},
             {
-                "multiple", "VOCABULARY TEST-VOC9 TEST-VOC9 DEFINITIONS ORDER", "Should show all vocabs", TEST_NORMAL,
-                0, 1
+                "multiple", "VOCABULARY TEST-VOC9 TEST-VOC9 DEFINITIONS ORDER", "Should show all vocabs", TEST_NORMAL, 0, 1, {0}
             },
-            {"after_forth", "TEST-VOC9 FORTH ORDER", "Should show FORTH only", TEST_NORMAL, 0, 1},
-            {NULL, NULL, NULL, TEST_NORMAL, 0, 0}
+            {"after_forth", "TEST-VOC9 FORTH ORDER", "Should show FORTH only", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
         },
-        3
+        3, {0}
     },
     /* End marker */
-    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0}}, 0}
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
 };
 
 /** @brief Executes all vocabulary word test suites