Reorganize source tree: kernel/, v3/, v4/ split and board infrastructure

Source tree reorganization: - Move StarForth v3 engine to v3/ (src/, include/, Makefile) - Move kernel to kernel/ (src/, include/, linker/, Makefile) - Create v4/ skeleton for F18-ISA golden model (DECOMPOSITION.md, JUSTIFICATION.md) - Move FABRIC-0..4.md to docs/fabric/ - Move ONTOLOGY.md and ROADMAP.md to docs/ Board infrastructure: - Add boards/ser5/, boards/raspi/, boards/milkv/, boards/zynq7020/ - Each board has board.mk (ISA, CPU flags, boot recipe) and README.md - Root Makefile becomes thin dispatcher: boot_image, all, clean, docs take TARGET - make boot_image TARGET=SER5|RASPI|MILKV builds one GPT/MBR image per board - ZYNQ7020 target exists but stops with clear error (ARMv7 port not built yet) - scripts/mkdiskimage.sh builds disk images for all boards Docs pipeline: - docs/book/ with LaTeX master (main.tex) and Makefile - pandoc converts Markdown to LaTeX at build time - Two Lua filters: table-widths.lua (wide tables wrap), code-breaks.lua (inline code breaks) - make docs builds single PDF (754 pages, 0 missing characters) - make docs TARGET=<board> adds board appendix - build/docs/<book|board>/meta.tex stamps git commit into PDF Bug fixes: - 42 include paths that only worked by accident now use correct relative paths - clang-18 hardcode replaced with configurable CC variable (fixed aarch64 build) - Pi 5: kernel_2712.img linked at 0x80000, .bss zeroed, memory reserved - Doxyfile, .clang-tidy, README.md, Kconfig paths updated Verified: - Hosted v3 build passes 1012 tests, 0 failures - SER5 image boots in QEMU (OVMF), POST passes, K exact (65536 = Q48_ONE) - Milk-V image boots in QEMU (OpenSBI + U-Boot + bootefi), POST passes - make clean TARGET=<board> removes only that board and its ISA objects - make all builds all boards, hosted v3, and docs in one run Co-authored-by: Junie <junie@jetbrains.com>
2026-10-01 15:40:09 -04:00
parent 3c709c115b
commit a8b70e88d3
630 changed files with 2646 additions and 2036 deletions
@@ -0,0 +1,17 @@
+# src/test_runner/
+
+Test harness for the hosted VM's test suite, run via
+`./starforth --run-tests`. Organized in POST (Power-On Self Test) order:
+unit tests → dictionary/word-category tests → integration/stress/
+adversarial tests.
+
+- `test_runner.c` — test harness orchestration (loads and runs all
+  modules in POST order).
+- `test_common.c` — shared test utilities.
+- `test_contracts.c` — contract-based testing infrastructure (pre/post
+  condition assertions around word execution).
+
+Subdirectories:
+- `include/` — public headers for this harness.
+- `modules/` — per-category test files; see
+  `src/test_runner/modules/README.md`.
@@ -0,0 +1,8 @@
+# src/test_runner/include/
+
+Public headers for the test harness.
+
+- `test_runner.h` — harness orchestration interface.
+- `test_common.h` — shared test utility declarations.
+- `test_contracts.h` — contract-based testing (pre/post-condition
+  assertion) interface.
@@ -0,0 +1,214 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+/**
+ * @file test_common.h
+ * @brief Common test utilities and structures for StarForth test runner
+ * @details This file contains test configuration, structures, and utility functions
+ * used throughout the StarForth test framework.
+ */
+
+#ifndef TEST_COMMON_H
+#define TEST_COMMON_H
+
+#include "../../../include/vm.h"
+#include "../../../include/log.h"
+#include "test_contracts.h"
+
+/** @name Test Configuration
+ * @{
+ */
+/** Maximum length of test output buffer */
+#define MAX_TEST_OUTPUT 1024
+/** Maximum length of test input buffer */
+#define MAX_TEST_INPUT 256
+/** Maximum number of test cases per word */
+#define MAX_TESTS_PER_WORD 20
+/** @} */
+
+/* fail fast */
+extern int fail_fast;
+
+/** @brief Types of test cases */
+typedef enum {
+    TEST_NORMAL = 0, /**< Standard test case */
+    TEST_EDGE_CASE = 1, /**< Edge case test */
+    TEST_ERROR_CASE = 2 /**< Error condition test */
+} TestType;
+
+/** @brief Structure representing a single test case */
+typedef struct {
+    const char *name; /**< Name of the test case */
+    const char *input; /**< Input Forth code */
+    const char *expected; /**< Expected output */
+    TestType type; /**< Type of test case */
+    int should_error; /**< Whether test should produce an error */
+    int implemented; /**< Whether the functionality is implemented */
+    WordContract contract; /**< Per-test contract override; zero = inherit from suite/module */
+} TestCase;
+
+/** @brief Collection of test cases for a single Forth word */
+typedef struct {
+    const char *word_name; /**< Name of the Forth word being tested */
+    TestCase tests[MAX_TESTS_PER_WORD]; /**< Array of test cases */
+    int test_count; /**< Number of tests in the suite */
+    WordContract suite_contract; /**< Suite-level contract; zero = inherit from module */
+} WordTestSuite;
+
+/** @name Core Test Execution Functions
+ * @{
+ */
+/*
+ * @brief Executes a single test case
+ * @param vm Pointer to the VM instance
+ * @param word_name Name of the word being tested
+ * @param test Test case to execute
+ * @return Test execution result
+ */
+TestResult run_single_test(VM *vm, const char *word_name, const TestCase *test);
+
+/*
+ * @brief Runs all tests in a test suite
+ * @param vm Pointer to the VM instance
+ * @param suite Test suite to execute
+ */
+void run_test_suite(VM *vm, const WordTestSuite *suite);
+
+/**
+ * @brief Runs all tests in a suite with an inherited module-level contract.
+ *
+ * Contract resolution order (first non-NONE wins):
+ *   test->contract > suite->suite_contract > module_contract
+ *
+ * When CONTRACTS_ENABLED=1, each passing TEST_NORMAL test is re-run under
+ * physics perturbation to witness A4' (word_physics_transparent).
+ *
+ * @param vm              Pointer to the VM instance
+ * @param suite           Test suite to execute
+ * @param module_contract Default contract for tests that don't specify one
+ */
+void run_test_suite_m(VM *vm, const WordTestSuite *suite, WordContract module_contract);
+
+/*
+ * @brief Prints test results_run_01_2025_12_08 summary for a module
+ * @param module_name Name of the module
+ * @param pass Number of passed tests
+ * @param fail Number of failed tests
+ * @param skip Number of skipped tests
+ * @param error Number of errors
+ */
+void print_module_summary(const char *module_name, int pass, int fail, int skip, int error);
+
+/** @} */
+
+/** @name Test Assertion Functions
+ * @{
+ */
+/*
+ * @brief Verifies the VM stack depth
+ * @param vm Pointer to the VM instance
+ * @param expected_depth Expected stack depth
+ * @return 1 if assertion passes, 0 otherwise
+ */
+int assert_stack_depth(VM *vm, int expected_depth);
+
+/*
+ * @brief Verifies the value at the top of the stack
+ * @param vm Pointer to the VM instance
+ * @param expected_value Expected value
+ * @return 1 if assertion passes, 0 otherwise
+ */
+int assert_stack_top(VM *vm, int expected_value);
+
+/*
+ * @brief Verifies VM error state
+ * @param vm Pointer to the VM instance
+ * @param should_have_error Expected error state
+ * @return 1 if assertion passes, 0 otherwise
+ */
+int assert_vm_error(VM *vm, int should_have_error);
+
+/** @} */
+
+/** @name VM State Management Functions
+ * @{
+ */
+/*
+ * @brief Saves current VM state
+ * @param vm Pointer to the VM instance
+ * @param dsp Pointer to store data stack pointer
+ * @param rsp Pointer to store return stack pointer
+ * @param error Pointer to store error state
+ * @param mode Pointer to store VM mode
+ */
+void save_vm_state(VM *vm, int *dsp, int *rsp, int *error, vm_mode_t *mode);
+
+/*
+ * @brief Restores VM state from saved values
+ * @param vm Pointer to the VM instance
+ * @param dsp Data stack pointer to restore
+ * @param rsp Return stack pointer to restore
+ * @param error Error state to restore
+ * @param mode VM mode to restore
+ */
+void restore_vm_state(VM *vm, int dsp, int rsp, int error, vm_mode_t mode);
+
+/*
+ * @brief Saves dictionary state before test execution
+ * @param vm Pointer to VM instance
+ * @param latest Pointer to store latest dictionary entry
+ * @param here Pointer to store HERE pointer
+ */
+void save_dict_state(VM * vm, DictEntry * *latest, size_t * here);
+
+/*
+ * @brief Restores dictionary state after test execution
+ * @param vm Pointer to VM instance
+ * @param latest Latest dictionary entry to restore
+ * @param here HERE pointer to restore
+ * @details Removes all words added during test by restoring dictionary pointers
+ */
+void restore_dict_state(VM *vm, DictEntry *latest, size_t here);
+
+/** @} */
+
+#endif /* TEST_COMMON_H */
@@ -0,0 +1,121 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  Licensed under the Starship License 1.0 (SL-1.0)
+*/
+
+#ifndef TEST_CONTRACTS_H
+#define TEST_CONTRACTS_H
+
+#include "vm.h"   /* resolved via -Iinclude */
+#include <stdint.h>
+#include <stddef.h>
+
+/* ============================================================================
+ * Word Contract System — Runtime witnesses for Isabelle/HOL axioms
+ *
+ * Two axioms require runtime verification:
+ *   A1  heartbeat_exec_neutral   — vm_tick() must not write exec-equiv fields
+ *   A4' word_physics_transparent — word results must be independent of physics state
+ *
+ * Contracts attach at three levels; resolution order (first non-NONE wins):
+ *   individual TestCase > WordTestSuite.suite_contract > module_contract arg
+ *
+ * Contract checks run unconditionally as part of POST.
+ * ============================================================================ */
+
+typedef uint32_t contract_flags_t;
+
+#define CONTRACT_NONE                 0u
+/* A4': re-run word with perturbed physics; assert identical exec result */
+#define CONTRACT_PHYSICS_TRANSPARENT  (1u << 0)
+/* A1: call vm_tick() and assert exec-equiv fields are unchanged */
+#define CONTRACT_HEARTBEAT_SAFE       (1u << 1)
+
+/* Number of physics perturbation rounds per test case (0 = use default) */
+#define CONTRACT_DEFAULT_FUZZ_ROUNDS  4
+
+typedef struct {
+    contract_flags_t flags;
+    int fuzz_rounds;  /* 0 = use CONTRACT_DEFAULT_FUZZ_ROUNDS */
+} WordContract;
+
+/* Exec-domain snapshot — exactly the four fields in exec_equiv */
+typedef struct {
+    cell_t stack[STACK_SIZE];
+    int    dsp;
+    int    rsp;
+    int    error;
+} ExecResult;
+
+/* Physics field snapshot for save/restore around A4' checks */
+typedef struct {
+    uint64_t decay_slope_q48;
+    uint32_t eff_window_size;
+    uint64_t tick_target_ns;
+    cell_t   heat_25th;
+    cell_t   heat_50th;
+    cell_t   heat_75th;
+    uint64_t prefetch_attempts;
+    uint64_t total_executions;
+} PhysicsSnapshot;
+
+/* Global counter incremented on each contract violation (CONTRACTS_ENABLED only) */
+extern int global_contract_violations;
+
+/*
+ * Accessor functions for global_contract_violations.
+ * Use these from other TUs — direct extern access generates GOTPCRELX which
+ * the PE linker does not relax, causing double-dereference bugs in -fPIC PE builds.
+ */
+int  contract_get_violation_count(void);
+void contract_reset_violation_count(void);
+
+/*
+ * capture_exec_result — snapshot the four exec-equiv fields from vm into r.
+ */
+void capture_exec_result(VM *vm, ExecResult *r);
+
+/*
+ * exec_results_equal — 1 if a and b agree on dsp, rsp, error, and live stack.
+ */
+int exec_results_equal(const ExecResult *a, const ExecResult *b);
+
+/*
+ * save_physics / restore_physics — snapshot and restore key physics scalars.
+ */
+void save_physics(VM *vm, PhysicsSnapshot *s);
+void restore_physics(VM *vm, const PhysicsSnapshot *s);
+
+/*
+ * perturb_physics — replace key physics scalars with fresh random values.
+ * round is used to vary the RNG seed across multiple rounds.
+ */
+void perturb_physics(VM *vm, int round);
+
+/*
+ * check_physics_transparent — A4' contract check for a single test case.
+ *
+ * Runs input with the current physics state (baseline), then runs it again
+ * fuzz_rounds times with physics perturbed, asserting identical ExecResult
+ * each time.  Returns 1 if all rounds match, 0 on first violation (which is
+ * also logged as an error).  Skips error-expected and unimplemented tests.
+ *
+ * NOTE: input must not define dictionary words; the dict is not snapshotted
+ * inside this function.  Callers that cover defining-words tests should
+ * save/restore dict state around this call.
+ */
+int check_physics_transparent(VM *vm, const char *word_name,
+                               const char *input,
+                               int should_error, int implemented,
+                               int fuzz_rounds);
+
+/*
+ * assert_heartbeat_safe — A1 contract check.
+ *
+ * Snapshots exec-equiv fields, calls vm_tick(), then asserts all four fields
+ * are unchanged.  Returns 1 if the assertion holds, 0 on violation.
+ */
+int assert_heartbeat_safe(VM *vm);
+
+#endif /* TEST_CONTRACTS_H */
@@ -0,0 +1,181 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#ifndef TEST_RUNNER_H
+#define TEST_RUNNER_H
+
+#include "../../../include/vm.h"
+#include <stdint.h>
+
+/**
+ * @brief Structure holding test execution statistics
+ */
+typedef struct {
+    int total_tests; /**< Total number of tests executed */
+    int total_pass; /**< Number of passed tests */
+    int total_fail; /**< Number of failed tests */
+    int total_skip; /**< Number of skipped tests */
+    int total_error; /**< Number of tests that resulted in errors */
+} TestStats;
+
+/**
+ * @brief Structure representing a test module
+ */
+typedef struct {
+    const char *module_name; /**< Name of the test module */
+    void *reserved; /**< Reserved for future use */
+    int reserved_int; /**< Reserved integer value */
+
+    void (*run_module_tests)(VM *vm); /**< Function pointer to run module tests */
+} TestModule;
+
+/* Global test statistics - extern declaration */
+extern TestStats global_test_stats;
+
+/*
+ * Same-TU accumulator — use instead of direct struct access from other TUs.
+ * Direct extern struct access generates R_X86_64_REX_GOTPCRELX which the
+ * PE linker does not relax, causing double-dereference in -fPIC PE builds.
+ */
+void test_stats_accumulate(int tests, int pass, int fail, int skip, int error);
+
+/*
+ * @brief Run tests for stack manipulation words
+ * @param vm Pointer to the VM instance
+ */
+void run_stack_words_tests(VM * vm);
+
+void run_return_stack_words_tests(VM * vm);
+void run_memory_words_tests(VM * vm);
+void run_arithmetic_words_tests(VM * vm);
+void run_logical_words_tests(VM * vm);
+void run_mixed_arithmetic_words_tests(VM * vm);
+void run_double_words_tests(VM * vm);
+void run_dictionary_words_tests(VM * vm);
+void run_io_words_tests(VM * vm);
+void run_format_words_tests(VM * vm);
+void run_string_words_tests(VM * vm);
+void run_dictionary_manipulation_words_tests(VM * vm);
+void run_vocabulary_words_tests(VM * vm);
+void run_block_words_tests(VM * vm);
+void run_system_words_tests(VM * vm);
+void run_defining_words_tests(VM * vm);
+void run_control_words_tests(VM * vm);
+void run_starforth_words_tests(VM * vm);
+void run_acl_words_tests(VM * vm);
+
+/*
+ * @brief Run tests for Q48.16 fixed-point words (Module 25)
+ * @param vm Pointer to the VM instance
+ */
+void run_q48_words_tests(VM * vm);
+
+/*
+ * @brief Run tests for the proof-covered subset of inference-engine words (Module 26)
+ * @param vm Pointer to the VM instance
+ */
+void run_inference_words_tests(VM * vm);
+
+/*
+ * @brief Run tests for the proof-covered subset of physics-freeze words (Module 27)
+ * @param vm Pointer to the VM instance
+ */
+void run_physics_freeze_words_tests(VM * vm);
+
+/*
+ * @brief Run tests for Mama FORTH vocabulary (capsule system M7.1)
+ * @param vm Pointer to the VM instance
+ *
+ * In hosted builds, all tests are skipped (Mama words are kernel-only).
+ * In kernel builds, tests validate capsule enumeration and VM birth.
+ */
+void run_mama_forth_words_tests(VM * vm);
+
+/*
+ * @brief Enable benchmark mode for performance testing
+ * @param iterations Number of iterations for benchmark tests
+ */
+void enable_benchmark_mode(int iterations);
+
+/*
+ * @brief Execute stress tests
+ * @param vm Pointer to the VM instance
+ */
+void run_stress_tests(VM * vm);
+
+/*
+ * @brief Execute integration tests
+ * @param vm Pointer to the VM instance
+ */
+void run_integration_tests(VM * vm);
+
+/*
+ * @brief Run all available tests
+ * @param vm Pointer to the VM instance
+ */
+void run_all_tests(VM * vm);
+
+/*
+ * @brief Run tests for a specific module
+ * @param vm Pointer to the VM instance
+ * @param module_name Name of the module to test
+ */
+void run_module_tests(VM *vm, const char *module_name);
+
+/*
+ * @brief Run tests for a specific word
+ * @param vm Pointer to the VM instance
+ * @param word_name Name of the word to test
+ */
+void run_word_tests(VM *vm, const char *word_name);
+
+/**
+ * @brief Run ultra-comprehensive break-me diagnostic suite
+ * @param vm Pointer to the VM instance
+ *
+ * Executes the most exhaustive test battery ever designed for StarForth,
+ * generates a detailed markdown report in docs/BREAK_ME_REPORT.md,
+ * and includes a surprise easter egg at the end.
+ */
+void run_break_me_tests(VM * vm);
+
+#endif /* TEST_RUNNER_H */
@@ -0,0 +1,26 @@
+# src/test_runner/modules/
+
+Per-category test files, one per FORTH-79 word category plus
+integration/stress/adversarial suites, run in this order by
+`test_runner.c` (POST order).
+
+**Word-category tests** (validate each `src/word_source/*.c` file):
+`arithmetic_words_test.c`, `mixed_arithmetic_words_test.c`,
+`stack_words_test.c`, `control_words_test.c`, `defining_words_tests.c`,
+`memory_words_test.c`, `return_stack_words_test.c`, `double_words_test.c`,
+`logical_words_test.c`, `io_words_test.c`, `string_words_test.c`,
+`block_words_test.c`, `format_words_test.c`, `system_words_test.c`,
+`dictionary_words_test.c`, `dictionary_manipulation_words_test.c`,
+`vocabulary_words_test.c`, `starforth_words_test.c`,
+`mama_forth_words_test.c`, `acl_words_test.c`.
+
+**Cross-cutting tests**:
+- `integration_tests.c` — multi-word interaction tests.
+- `stress_tests.c` — load/volume tests.
+- `break_me_tests.c` — adversarial/fuzzing tests.
+
+Note: not every `src/word_source/*.c` file has a dedicated test module
+here (e.g. `defer_words.c`, `log_words.c`, `inference_words.c`,
+`lifecycle_words_hosted.c`, `editor_words.c` are exercised indirectly via
+integration tests or the `tools/hermes_*.sh` smoke tests rather than a
+standalone `*_test.c` module).
@@ -0,0 +1,285 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Arithmetic Words Test Suites - Module 5 */
+static WordTestSuite arithmetic_word_suites[] = {
+    {
+        "+", {
+            {"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, {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, {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, {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, {0}
+    },
+
+    {
+        "MOD", {
+            {"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, {0}
+    },
+
+    {
+        "/MOD", {
+            {"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, {0}
+    },
+
+    {
+        "ABS", {
+            {"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, {0}
+    },
+
+    {
+        "NEGATE", {
+            {"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, {0}
+    },
+
+    {
+        "MIN", {
+            {"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, {0}
+    },
+
+    {
+        "MAX", {
+            {"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, {0}
+    },
+
+    {
+        "1+", {
+            {"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, {0}
+    },
+
+    {
+        "1-", {
+            {"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, {0}
+    },
+
+    {
+        "2+", {
+            {"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, {0}
+    },
+
+    {
+        "2-", {
+            {"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, {0}
+    },
+
+    {
+        "2*", {
+            {"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, {0}
+    },
+
+    {
+        "2/", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all arithmetic word test suites
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Runs through all test cases for arithmetic operations including
+ *          basic operations (+, -, *, /), modulo operations (MOD, /MOD),
+ *          and numeric functions (ABS, NEGATE, MIN, MAX)
+ */
+void run_arithmetic_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Arithmetic Words Tests (Module 5)...");
+
+    WordContract mod = {CONTRACT_PHYSICS_TRANSPARENT, 0};
+    for (int i = 0; arithmetic_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite_m(vm, &arithmetic_word_suites[i], mod);
+    }
+
+    print_module_summary("Arithmetic Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,213 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/**
+ * @brief Test suites for FORTH block words (Module 16)
+ *
+ * Contains test cases for the following FORTH words:
+ * - BLOCK: Block access
+ * - BUFFER: Buffer management
+ * - UPDATE: Block modification marking
+ * - SAVE-BUFFERS: Buffer flushing
+ * - EMPTY-BUFFERS: Buffer invalidation
+ * - FLUSH: Buffer saving and invalidation
+ * - LOAD: Block interpretation
+ * - LIST: Block display
+ * - SCR: Current block number
+ * - THRU: Load block range
+ * - -->: Continue to next block
+ */
+static WordTestSuite block_word_suites[] = {
+    {
+        "BLOCK", {
+            {"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, {0}
+    },
+
+    {
+        "BUFFER", {
+            {"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, {0}
+    },
+
+    {
+        "UPDATE", {
+            {"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, {0}
+    },
+
+    {
+        "SAVE-BUFFERS", {
+            {"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, {0}
+    },
+
+    {
+        "EMPTY-BUFFERS", {
+            {"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, {0}
+    },
+
+    {
+        "FLUSH", {
+            {"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, {0}
+    },
+
+    {
+        "LOAD", {
+            {"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, {0}
+    },
+
+    {
+        "LIST", {
+            {"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, {0}
+    },
+
+    {
+        "SCR", {
+            {"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, {0}
+    },
+
+    {
+        "THRU", {
+            /* Basic functionality */
+            {"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, {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, {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, {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, {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, {0}}
+        },
+        17, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all block words test suites
+ * @param vm Pointer to the FORTH virtual machine instance
+ *
+ * Runs through all test cases for block manipulation words, including
+ * block access, buffer management, and block I/O operations. Results
+ * are logged and summarized after completion.
+ */
+void run_block_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Block Words Tests (Module 16)...");
+
+    for (int i = 0; block_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &block_word_suites[i]);
+    }
+
+    print_module_summary("Block Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,202 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "test_runner.h"
+#include "../../../include/log.h"
+#include "../../../include/vm.h"
+
+/* Report file handle */
+static FILE *report_file = NULL;
+static time_t test_start_time;
+static time_t test_end_time;
+static int total_tests_run = 0;
+
+/**
+ * @brief Initialize markdown report file
+ */
+static int init_report(void) {
+    time(&test_start_time);
+
+    report_file = fopen("docs/BREAK_ME_REPORT.md", "w");
+    if (!report_file) {
+        log_message(LOG_ERROR, "Failed to create BREAK_ME_REPORT.md");
+        return -1;
+    }
+
+    char time_str[64];
+    struct tm *tm_info = localtime(&test_start_time);
+    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm_info);
+
+    fprintf(report_file, "# 🔥 STARFORTH BREAK-ME DIAGNOSTIC REPORT 🔥\n\n");
+    fprintf(report_file, "## Executive Summary\n\n");
+    fprintf(report_file, "**Generated:** %s\n\n", time_str);
+    fprintf(report_file, "**Test Mode:** ULTRA-COMPREHENSIVE DIAGNOSTIC\n\n");
+    fprintf(report_file, "**Purpose:** This report documents the results_run_01_2025_12_08 of the most exhaustive ");
+    fprintf(report_file, "testing suite ever run on StarForth. Every word, every edge case, ");
+    fprintf(report_file, "every pathological scenario has been tested to ensure rock-solid ");
+    fprintf(report_file, "reliability and FORTH-79 standard compliance.\n\n");
+    fprintf(report_file, "---\n\n");
+
+    return 0;
+}
+
+/**
+ * @brief Finalize report with system info and easter egg
+ */
+static void finalize_report(VM *vm) {
+    time(&test_end_time);
+
+    if (!report_file) return;
+
+    /* Performance metrics */
+    fprintf(report_file, "\n## 📊 Performance Metrics\n\n");
+    fprintf(report_file, "| Metric | Value |\n");
+    fprintf(report_file, "|--------|-------|\n");
+    fprintf(report_file, "| Test Duration | %.2f seconds |\n", difftime(test_end_time, test_start_time));
+    fprintf(report_file, "| Total Tests | %d |\n", total_tests_run);
+    fprintf(report_file, "| Tests/Second | %.2f |\n\n",
+            total_tests_run / difftime(test_end_time, test_start_time));
+
+    /* System info */
+    fprintf(report_file, "## 🖥️ System Information\n\n");
+    fprintf(report_file, "| Component | Specification |\n");
+    fprintf(report_file, "|-----------|---------------|\n");
+    fprintf(report_file, "| VM Architecture | Direct-threaded |\n");
+    fprintf(report_file, "| Standard | FORTH-79 + StarForth Extensions |\n");
+    fprintf(report_file, "| Cell Size | %zu bytes |\n", sizeof(cell_t));
+    fprintf(report_file, "| Stack Size | %d cells |\n", STACK_SIZE);
+    fprintf(report_file, "| Memory | %d bytes |\n\n", VM_MEMORY_SIZE);
+
+    /* Easter egg */
+    fprintf(report_file, "\n---\n\n");
+    fprintf(report_file, "## 🎉 EASTER EGG: THE STARFORTH CHALLENGE 🎉\n\n");
+    fprintf(report_file, "```\n");
+    fprintf(report_file, "     ⭐  C O N G R A T U L A T I O N S  ⭐\n\n");
+    fprintf(report_file, "  You've discovered the hidden StarForth challenge!\n\n");
+    fprintf(report_file, "  Your system just survived %d exhaustive tests.\n", total_tests_run);
+    fprintf(report_file, "  But can YOU survive the ULTIMATE FORTH CHALLENGE?\n\n");
+    fprintf(report_file, "  🏆 THE STARFORTH MASTER CHALLENGE 🏆\n\n");
+    fprintf(report_file, "  Write a Forth program that:\n");
+    fprintf(report_file, "  1. Prints the Fibonacci sequence up to 1000\n");
+    fprintf(report_file, "  2. Uses ONLY the following words:\n");
+    fprintf(report_file, "     : ; DUP OVER DROP SWAP . CR < IF THEN DO LOOP\n");
+    fprintf(report_file, "  3. Fits in exactly 79 characters (FORTH-79 tribute!)\n\n");
+    fprintf(report_file, "  Submit your solution to the StarForth community!\n\n");
+    fprintf(report_file, "  Hint: Think recursively, but remember FORTH-79\n");
+    fprintf(report_file, "        doesn't have RECURSE... 😉\n\n");
+    fprintf(report_file, "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n");
+    fprintf(report_file, "  BONUS SECRET: If you ran --break-me, you're already\n");
+    fprintf(report_file, "  in the top 1%% of Forth enthusiasts. Welcome to the\n");
+    fprintf(report_file, "  elite club! Your system just proved it can handle\n");
+    fprintf(report_file, "  anything you throw at it.\n\n");
+    fprintf(report_file, "  May your stacks be balanced and your words defined,\n");
+    fprintf(report_file, "         -- The StarForth Development Team ⭐\n");
+    fprintf(report_file, "```\n\n");
+
+    fprintf(report_file, "### 🎮 More Easter Eggs to Find:\n\n");
+    fprintf(report_file, "1. Try defining a word called `STARSHIP` and see what happens\n");
+    fprintf(report_file, "2. Run `42 ENTROPY@ .` to see the universe's favorite number\n");
+    fprintf(report_file, "3. Type `WORDS` and count how many contain 'STAR'\n");
+    fprintf(report_file, "4. Check what happens when you `FORGET FORGET` (just kidding, don't!)\n\n");
+
+    fprintf(report_file, "---\n\n");
+    fprintf(report_file, "*Generated by StarForth --break-me mode*\n");
+    fprintf(report_file, "*Copyright (c) 2025 Robert A. James - StarshipOS Forth Project*\n");
+
+    fclose(report_file);
+    report_file = NULL;
+}
+
+/**
+ * @brief Main entry point for --break-me mode
+ */
+void run_break_me_tests(VM *vm) {
+    if (!vm) return;
+
+    log_message(LOG_INFO, "");
+    log_message(LOG_INFO, "╔═══════════════════════════════════════════════════════════╗");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "║        🔥 BREAK-ME MODE ACTIVATED 🔥                     ║");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "║   Ultra-Comprehensive StarForth Diagnostic Suite         ║");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "║   Preparing to execute EXHAUSTIVE test battery...        ║");
+    log_message(LOG_INFO, "║   Generating detailed markdown report...                 ║");
+    log_message(LOG_INFO, "║   Surprise easter egg awaits at the end!                 ║");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "╚═══════════════════════════════════════════════════════════╝");
+    log_message(LOG_INFO, "");
+
+    /* Initialize report */
+    if (init_report() != 0) {
+        log_message(LOG_ERROR, "Failed to initialize report - aborting");
+        return;
+    }
+
+    /* Run ALL existing test suites */
+    log_message(LOG_INFO, "Running comprehensive test suite...");
+    run_all_tests(vm);
+
+    /* Update counter from global stats */
+    extern TestStats global_test_stats;
+    total_tests_run = global_test_stats.total_tests;
+
+    /* Finalize report */
+    finalize_report(vm);
+
+    log_message(LOG_INFO, "");
+    log_message(LOG_INFO, "╔═══════════════════════════════════════════════════════════╗");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "║        ✅ BREAK-ME COMPLETE ✅                           ║");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "║   StarForth survived %d tests!                       ║", total_tests_run);
+    log_message(LOG_INFO, "║   Check docs/BREAK_ME_REPORT.md for full details         ║");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "║   🎉 Don't forget to read the easter egg! 🎉            ║");
+    log_message(LOG_INFO, "║                                                           ║");
+    log_message(LOG_INFO, "╚═══════════════════════════════════════════════════════════╝");
+    log_message(LOG_INFO, "");
+}
@@ -0,0 +1,267 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/** @brief Test suites for FORTH control words
+ *  @details Contains test cases for all control flow words in Module 12,
+ *           including conditional branches and loop structures
+ */
+static WordTestSuite control_word_suites[] = {
+    {
+        "IF", {
+            {"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, {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, {0}
+    },
+
+    {
+        "ELSE", {
+            {"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, {0}
+    },
+
+    {
+        "THEN", {
+            {"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, {0}
+    },
+
+    {
+        "BEGIN", {
+            {"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, {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, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "UNTIL", {
+            {"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, {0}
+    },
+
+    {
+        "WHILE", {
+            {"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, {0}
+            },
+            {"no_begin", "WHILE", "Should error without BEGIN", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "REPEAT", {
+            {
+                "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, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "DO", {
+            {"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, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        4, {0}
+    },
+
+    {
+        "?DO", {
+            {"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, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "LOOP", {
+            {"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, {0}
+    },
+
+    {
+        "+LOOP", {
+            {"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, {0}
+    },
+
+    {
+        "I", {
+            {"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, {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, {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, {0}
+    },
+
+    {
+        "EXIT", {
+            {"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, {0}
+    },
+
+    {
+        "LEAVE", {
+            {"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, {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, {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, {0}
+    },
+
+    {
+        "AGAIN", {
+            {"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, {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, {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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/** @brief Executes all control words test suites
+ *  @param vm Pointer to the FORTH virtual machine instance
+ *  @details Runs through all defined test cases for control words,
+ *           testing conditional branches and loop constructs
+ */
+void run_control_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Control Words Tests (Module 12)...");
+
+    for (int i = 0; control_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &control_word_suites[i]);
+        run_test_suite(vm, &control_word_suites[i]);
+    }
+
+    print_module_summary("Control Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,191 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/** @brief Test suites for Forth defining words (Module 13)
+ *  @details Contains test cases for core defining words including:
+ *           :, ;, CONSTANT, VARIABLE, CREATE, DOES>, [, and ]
+ */
+static WordTestSuite defining_word_suites[] = {
+    {
+        ":", {
+            {"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, {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, {0}
+    },
+
+    {
+        "CONSTANT", {
+            {"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, {0}
+    },
+
+    {
+        "VARIABLE", {
+            {"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, {0}
+    },
+
+    {
+        "CREATE", {
+            {"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, {0}
+    },
+
+    {
+        "DOES>", {
+            {
+                "basic", ": CONST CREATE , DOES> @ ; 42 CONST MEANING MEANING . CR", "Should define behavior",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "multiple", ": ARRAY CREATE DOES> SWAP CELLS + ; CREATE ARR 10 CELLS ALLOT", "Should work with arrays",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {"outside", "DOES>", "Should error outside definition", TEST_ERROR_CASE, 1, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {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, {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, {0}
+    },
+
+    {
+        "DEFER", {
+            {"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, {0}
+    },
+
+    {
+        "IS", {
+            {"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, {0}
+    },
+
+    {
+        "DEFER@", {
+            {"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, {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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/** @brief Executes all test suites for Forth defining words
+ *  @param vm Pointer to the Forth virtual machine instance
+ *  @details Runs through each test suite in defining_word_suites array,
+ *           executing individual test cases and logging results_run_01_2025_12_08
+ */
+void run_defining_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Defining Words Tests (Module 13)...");
+
+    for (int i = 0; defining_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &defining_word_suites[i]);
+    }
+
+    print_module_summary("Defining Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,194 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Dictionary Manipulation Words Test Suites - Module 14 */
+static WordTestSuite dict_manip_word_suites[] = {
+    {
+        "CREATE", {
+            {"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, {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, {0}
+    },
+
+    {
+        "FORGET", {
+            {"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, {0}
+    },
+
+    {
+        /* FENCE ( -- ): raises the FORGET boundary to the current dictionary
+         * top. Added alongside a real bug fix in FORGET itself, caught while
+         * building this word -- forgetting the single newest word used to
+         * incorrectly destroy every other word back to the fence too (a
+         * use-after-free in the relink logic, not just an off-by-one), a
+         * SIGSEGV in the worst case. "forget_latest_keeps_predecessor" below
+         * is exactly the regression case that fix addresses. */
+        "FENCE", {
+            {
+                "basic", "CREATE fnc1 FENCE CREATE fnc2 FORGET fnc2",
+                "Should forget a word defined after FENCE", TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "protects_older", "CREATE fnc3 CREATE fnc4 FENCE FORGET fnc3",
+                "Should refuse to forget a word defined before FENCE", TEST_ERROR_CASE, 1, 1, {0}
+            },
+            {
+                "forget_latest_keeps_predecessor",
+                "CREATE fnc5 FENCE CREATE fnc6 CREATE fnc7 FORGET fnc7 fnc6 DROP",
+                "Forgetting the newest word must not disturb an older one still above FENCE",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "IMMEDIATE", {
+            {"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, {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, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "FIND", {
+            {"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, {0}
+    },
+
+    {
+        "DEFINITIONS", {
+            {"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, {0}
+    },
+
+    {
+        "SMUDGE", {
+            {"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, {0}
+    },
+
+    {
+        "LATEST", {
+            {"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, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        ">BODY", {
+            {"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, {0}
+    },
+
+    {
+        "HIDDEN", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all dictionary manipulation words test suites
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Runs through all test cases for CREATE, FORGET, IMMEDIATE, FIND,
+ *          DEFINITIONS, SMUDGE, LATEST, >BODY, and HIDDEN words
+ */
+void run_dictionary_manipulation_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Dictionary Manipulation Words Tests (Module 14)...");
+
+    for (int i = 0; dict_manip_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &dict_manip_word_suites[i]);
+    }
+
+    print_module_summary("Dictionary Manipulation Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,216 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Dictionary Words Test Suites - Module 4 */
+static WordTestSuite dictionary_word_suites[] = {
+    {
+        "HERE", {
+            {"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, {0}
+    },
+
+    {
+        "ALLOT", {
+            {"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, {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, {0}
+    },
+
+    {
+        "C,", {
+            {"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, {0}
+    },
+
+    {
+        "2,", {
+            {"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, {0}
+    },
+    {
+        "PAD", {
+            {"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, {0}
+    },
+
+    {
+        "SP@", {
+            // DISABLED: flaky on some architectures, non-deterministic
+            {"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, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        4, {0}
+    },
+
+    {
+        "SP!", {
+            {"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, {0}
+    },
+
+    {
+        "LATEST", {
+            {"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, {0}
+    },
+
+    {
+        "COMPILATION", {
+            {
+                "here_comma_sequence", "HERE 10 , 20 , 30 , HERE SWAP - 12 = . CR", "Should advance HERE by 12",
+                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, {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, {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, {0}
+    },
+
+    {
+        "STACK_MGMT", {
+            {"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, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all dictionary word test suites
+ *
+ * @param vm Pointer to the FORTH virtual machine instance
+ * 
+ * This function runs through all dictionary word test suites, including tests for:
+ * - HERE (dictionary pointer)
+ * - ALLOT (memory allocation)
+ * - Comma operations (, C, 2,)
+ * - PAD (scratch pad area)
+ * - Stack pointer operations (SP@ SP!)
+ * - LATEST (most recent dictionary entry)
+ * - Compilation sequences
+ * - Stack management operations
+ */
+void run_dictionary_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Dictionary Words Tests (Module 4)...");
+
+    for (int i = 0; dictionary_word_suites[i].word_name != NULL; i++) {
+        run_test_suite(vm, &dictionary_word_suites[i]);
+    }
+
+    print_module_summary("Dictionary Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,170 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/** 
+ * @brief Test suites for format words (Module 10)
+ * Contains test cases for number base conversion and formatting operations
+ */
+static WordTestSuite format_word_suites[] = {
+    {
+        "BASE", {
+            {"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, {0}
+    },
+
+    {
+        "DECIMAL", {
+            {"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, {0}
+    },
+
+    {
+        "HEX", {
+            {"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, {0}
+    },
+
+    {
+        "OCTAL", {
+            {"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, {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, {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, {0}
+    },
+
+    {
+        "#S", {
+            {"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, {0}
+    },
+
+    {
+        "SIGN", {
+            {"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, {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, {0}
+    },
+
+    {
+        "HOLD", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all format words test suites
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Runs through all test cases for number base manipulation and formatting words
+ */
+void run_format_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Format Words Tests (Module 10)...");
+
+    for (int i = 0; format_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &format_word_suites[i]);
+    }
+
+    print_module_summary("Format Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,139 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ */
+
+/*
+ * inference_words_test.c — POST tests for the SSM inference engine's
+ * proof-covered accessor/primitive words (Module 26)
+ *
+ * inference_words.c registers 20 words; only 8 are proof-covered per
+ * proof/COVERAGE.md ("5 accessors full; rest guard/shape") — this file
+ * covers exactly those 8, not the L8 Jacquard / Bayesian-posterior words,
+ * which COVERAGE.md does not claim coverage for. No test file existed for
+ * any word in this module before.
+ *
+ * The three array-based primitives (Q.VARIANCE/INFER-DECAY-SLOPE/
+ * INFER-WINDOW-WIDTH) need real data in VM memory — HERE is used as
+ * scratch, matching the idiom memory_words_test.c already uses. The four
+ * *-@  accessors and INFER-RUN are exercised in one suite (INFER-WINDOW@)
+ * that runs INFER-RUN first, since the accessors just read
+ * vm->last_inference_outputs and INFER-RUN is what populates it.
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Inference Engine Words Test Suites - Module 26 */
+static WordTestSuite inference_word_suites[] = {
+    {
+        "Q.VARIANCE", {
+            {"three_cells", "100 HERE ! 200 HERE 8 + ! 300 HERE 16 + ! HERE 3 Q.VARIANCE Q.TO-INT . CR",
+             "Should print population variance of {100,200,300} (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-DECAY-SLOPE", {
+            {"three_cells", "300 HERE ! 200 HERE 8 + ! 100 HERE 16 + ! HERE 3 INFER-DECAY-SLOPE Q.TO-INT . CR",
+             "Should print decay slope for a decreasing trajectory (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-WINDOW-WIDTH", {
+            {"three_cells", "100 HERE ! 200 HERE 8 + ! 300 HERE 16 + ! HERE 3 INFER-WINDOW-WIDTH . CR",
+             "Should print an inferred window width (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-RUN", {
+            {"basic", "INFER-RUN", "Should run without error", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-WINDOW@", {
+            {"after_run", "INFER-RUN INFER-WINDOW@ . CR", "Should print last adaptive_window_width (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-DECAY@", {
+            {"after_run", "INFER-RUN INFER-DECAY@ Q.TO-INT . CR", "Should print last adaptive_decay_slope (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-VARIANCE@", {
+            {"after_run", "INFER-RUN INFER-VARIANCE@ Q.TO-INT . CR", "Should print last window_variance_q48 (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-FIT@", {
+            {"after_run", "INFER-RUN INFER-FIT@ Q.TO-INT . CR", "Should print last slope_fit_quality_q48 (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "INFER-EARLY-EXIT@", {
+            {"after_run", "INFER-RUN INFER-EARLY-EXIT@ . CR", "Should print 0 or 1 (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes the proof-covered subset of inference-engine word test suites
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Covers the 8 words proof/COVERAGE.md marks as proof-covered in
+ *          inference_words.c: the three array-based primitives (Q.VARIANCE,
+ *          INFER-DECAY-SLOPE, INFER-WINDOW-WIDTH), INFER-RUN, and the four
+ *          *-@ output accessors (INFER-WINDOW@/DECAY@/VARIANCE@/FIT@) plus
+ *          INFER-EARLY-EXIT@. Does not cover the L8 Jacquard or Bayesian
+ *          posterior words in the same file — not claimed as proof-covered.
+ */
+void run_inference_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Inference Engine Words Tests (Module 26)...");
+
+    /* CONTRACT_NONE, not CONTRACT_PHYSICS_TRANSPARENT: these words read
+     * physics state (rolling window, dictionary heat) by design -- A4'
+     * transparency is a property they deliberately do not have. */
+    WordContract mod = {CONTRACT_NONE, 0};
+    for (int i = 0; inference_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite_m(vm, &inference_word_suites[i], mod);
+    }
+
+    print_module_summary("Inference Engine Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,233 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+/**
+ * @file integration_tests.c
+ * @brief Full program integration tests for StarForth
+ *
+ * This file contains integration tests that verify complete Forth programs
+ * as regression tests. It includes test suites for complete programs,
+ * data structures, and algorithms implementations.
+ */
+
+#include "test_common.h"
+#include "test_runner.h"
+
+/* Integration test suites - complete Forth programs */
+static WordTestSuite integration_suites[] = {
+    {
+        "COMPLETE_PROGRAMS", {
+            {
+                "prime_check",
+                ": PRIME? ( n -- flag ) "
+                "  DUP 2 < IF DROP 0 EXIT THEN "
+                "  DUP 2 = IF DROP -1 EXIT THEN "
+                "  DUP 2 MOD 0= IF DROP 0 EXIT THEN "
+                "  DUP 3 DO "
+                "    DUP I MOD 0= IF DROP 0 EXIT THEN "
+                "  2 +LOOP "
+                "  DROP -1 "
+                "; "
+                "17 PRIME? . CR",
+                "Prime number checker",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "array_sum",
+                ": ARRAY 5 CELLS ALLOT ; "
+                "ARRAY NUMS "
+                ": STORE-NUMS "
+                "  10 NUMS 0 CELLS + ! "
+                "  20 NUMS 1 CELLS + ! "
+                "  30 NUMS 2 CELLS + ! "
+                "  40 NUMS 3 CELLS + ! "
+                "  50 NUMS 4 CELLS + ! "
+                "; "
+                ": SUM-NUMS "
+                "  0 5 0 DO "
+                "    NUMS I CELLS + @ + "
+                "  LOOP "
+                "; "
+                "STORE-NUMS SUM-NUMS . CR",
+                "Array sum program",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "fizzbuzz_mini",
+                ": FIZZ? 3 MOD 0= ; "
+                ": BUZZ? 5 MOD 0= ; "
+                ": FIZZBUZZ "
+                "  DUP FIZZ? OVER BUZZ? AND IF DROP .\" FizzBuzz \" EXIT THEN "
+                "  DUP FIZZ? IF DROP .\" Fizz \" EXIT THEN "
+                "  DUP BUZZ? IF DROP .\" Buzz \" EXIT THEN "
+                "  . "
+                "; "
+                "15 FIZZBUZZ CR",
+                "FizzBuzz for 15",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "calculator",
+                ": + DEPTH 2 < IF .\" Stack underflow\" CR EXIT THEN + ; "
+                ": CALC "
+                "  5 3 + "
+                "  2 * "
+                "  4 - "
+                "  . CR "
+                "; "
+                "CALC",
+                "Simple calculator",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        4, {0}
+    },
+    {
+        "DATA_STRUCTURES", {
+            {
+                "linked_list",
+                "VARIABLE HEAD "
+                "0 HEAD ! "
+                ": NODE ( value -- addr ) "
+                "  HERE "
+                "  , " /* value */
+                "  HEAD @ , " /* next pointer */
+                "  DUP HEAD ! "
+                "; "
+                ": PRINT-LIST ( -- ) "
+                "  HEAD @ "
+                "  BEGIN DUP WHILE "
+                "    DUP @ . "
+                "    CELL+ @ "
+                "  REPEAT DROP CR "
+                "; "
+                "10 NODE DROP "
+                "20 NODE DROP "
+                "30 NODE DROP "
+                "PRINT-LIST",
+                "Simple linked list",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "stack_min_max",
+                ": INIT-MINMAX "
+                "  2147483647 VARIABLE MIN " /* Max int */
+                "  -2147483648 VARIABLE MAX " /* Min int */
+                "; "
+                ": UPDATE-MINMAX ( n -- ) "
+                "  DUP MIN @ < IF DUP MIN ! ELSE DROP THEN "
+                "  DUP MAX @ > IF DUP MAX ! ELSE DROP THEN "
+                "; "
+                "INIT-MINMAX "
+                "42 UPDATE-MINMAX "
+                "17 UPDATE-MINMAX "
+                "99 UPDATE-MINMAX "
+                "MIN @ . MAX @ . CR",
+                "Min/Max tracker",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "ALGORITHMS", {
+            {
+                "bubble_sort_concept",
+                ": SWAP-IF-NEEDED ( addr1 addr2 -- ) "
+                "  OVER @ OVER @ > IF "
+                "    OVER @ OVER @ "
+                "    ROT ! SWAP ! "
+                "  ELSE 2DROP THEN "
+                "; "
+                "VARIABLE A "
+                "VARIABLE B "
+                "5 A ! 3 B ! "
+                "A B SWAP-IF-NEEDED "
+                "A @ . B @ . CR",
+                "Swap if needed (sort helper)",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {
+                "gcd",
+                ": GCD ( a b -- gcd ) "
+                "  BEGIN DUP WHILE "
+                "    TUCK MOD "
+                "  REPEAT DROP "
+                "; "
+                "48 18 GCD . CR",
+                "Greatest Common Divisor",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+};
+
+/**
+ * @brief Executes all integration test suites for StarForth
+ *
+ * @param vm Pointer to the Forth virtual machine instance
+ *
+ * This function runs through all defined integration test suites, including:
+ * - Complete Programs suite (prime checker, array operations, etc)
+ * - Data Structures suite (linked list, min/max tracker)
+ * - Algorithms suite (sorting, GCD)
+ */
+void run_integration_tests(VM *vm) {
+    if (!vm) return;
+
+    log_message(LOG_INFO, "==============================================");
+    log_message(LOG_INFO, "   StarForth Integration Test Suite");
+    log_message(LOG_INFO, "   Complete Forth Programs");
+    log_message(LOG_INFO, "==============================================\n");
+
+    for (size_t i = 0; i < sizeof(integration_suites) / sizeof(WordTestSuite); i++) {
+        run_test_suite(vm, &integration_suites[i]);
+    }
+
+    log_message(LOG_INFO, "\n==============================================");
+    log_message(LOG_INFO, "   Integration Tests Complete");
+    log_message(LOG_INFO, "==============================================\n");
+}
@@ -0,0 +1,285 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/** 
+ * @brief Test suites for I/O words (Module 9)
+ * @details Contains comprehensive test cases for all I/O related FORTH words
+ *          including output formatting, character I/O, and base conversion operations
+ */
+static WordTestSuite io_word_suites[] = {
+    {
+        ".", {
+            {"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, {0}
+    },
+
+    {
+        "CR", {
+            {"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, {0}
+    },
+
+    {
+        "SPACE", {
+            {"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, {0}
+    },
+
+    {
+        "SPACES", {
+            {"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, {0}
+    },
+
+    {
+        "EMIT", {
+            {"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, {0}
+    },
+
+    {
+        "KEY", {
+            {"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, {0}
+    },
+
+    {
+        "?KEY", {
+            {"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, {0}
+    },
+
+    {
+        "TYPE", {
+            {
+                "basic_string", "HERE S\" Hello\" DUP >R HERE SWAP CMOVE HERE R> TYPE CR", "Should print: Hello",
+                TEST_NORMAL, 0, 1, {0}
+            },
+            {"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, {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, {0}
+    },
+
+    {
+        "COUNT", {
+            {
+                "basic", "HERE S\" Test\" DROP C@ HERE 1+ SWAP 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}},
+            {"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, {0}
+    },
+
+    {
+        "EXPECT", {
+            {"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, {0}
+    },
+
+    {
+        "SPAN", {
+            {"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, {0}
+    },
+
+    {
+        "WORD", {
+            /* Basic functionality */
+            {"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, {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, {0}},
+
+            /* Word length tests */
+            {"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, {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, {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, {0}},
+
+            /* Consecutive delimiters */
+            {"multi_delim", "BL WORD DROP BL WORD DROP", "Should handle multiple parses", TEST_NORMAL, 0, 1, {0}},
+
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        17, {0}
+    },
+
+    /* Base conversion and formatting tests */
+    {
+        "BASE_OUTPUT", {
+            {"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, {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, {0}
+    },
+
+    /* Output formatting combinations */
+    {
+        "FORMAT_COMBO", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all I/O words test suites
+ * @param vm Pointer to the FORTH virtual machine instance
+ * @details Runs through all defined test suites for I/O words, logging results_run_01_2025_12_08
+ *          and providing a summary of the test execution
+ */
+void run_io_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running I/O Words Tests (Module 9)...");
+
+    for (int i = 0; io_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &io_word_suites[i]);
+    }
+
+    print_module_summary("I/O Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,274 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+/**
+ * @file mama_forth_words_test.c
+ * @brief Test module for Mama FORTH vocabulary (M7.1 Capsule System)
+ *
+ * Tests for the MAMA vocabulary words. These words are kernel-only
+ * (__STARKERNEL__), so in hosted builds all tests are marked as
+ * not implemented and will be skipped.
+ *
+ * In kernel builds, these tests validate:
+ *   - Capsule directory enumeration
+ *   - Descriptor field access
+ *   - VM birth protocol
+ *   - Experiment execution
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/*
+ * Mama FORTH words (CAPSULE-COUNT etc.) are kernel runtime objects, not
+ * FORTH dictionary words.  They do not live in the StarForth dictionary,
+ * so there is nothing to test via vm_interpret.  Mark all tests skipped.
+ */
+#define MAMA_IMPLEMENTED 0
+
+/* Mama FORTH Words Test Suites */
+static WordTestSuite mama_word_suites[] = {
+    {
+        "CAPSULE-COUNT",
+        {
+            {
+                "basic",
+                "CAPSULE-COUNT . CR",
+                "Should print number of capsules",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "non_negative",
+                "CAPSULE-COUNT 0 >= . CR",
+                "Should be >= 0",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "CAPSULE@",
+        {
+            {
+                "first_capsule",
+                "0 CAPSULE@ . CR",
+                "Should return first descriptor address",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "out_of_bounds",
+                "9999 CAPSULE@ . CR",
+                "Should return 0 for invalid index",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "empty_stack",
+                "CAPSULE@",
+                "Should cause stack underflow",
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "CAPSULE-FLAGS@",
+        {
+            {
+                "basic",
+                "0 CAPSULE@ CAPSULE-FLAGS@ . CR",
+                "Should return flags from descriptor",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "null_desc",
+                "0 CAPSULE-FLAGS@ . CR",
+                "Should handle null descriptor",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "empty_stack",
+                "CAPSULE-FLAGS@",
+                "Should cause stack underflow",
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "CAPSULE-LEN@",
+        {
+            {
+                "basic",
+                "0 CAPSULE@ CAPSULE-LEN@ . CR",
+                "Should return payload length",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "empty_stack",
+                "CAPSULE-LEN@",
+                "Should cause stack underflow",
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "CAPSULE-HASH@",
+        {
+            {
+                "basic",
+                "0 CAPSULE@ CAPSULE-HASH@ . CR",
+                "Should return content hash",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "empty_stack",
+                "CAPSULE-HASH@",
+                "Should cause stack underflow",
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "MAMA-VM-ID",
+        {
+            {
+                "always_zero",
+                "MAMA-VM-ID . CR",
+                "Should always print 0",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "equals_zero",
+                "MAMA-VM-ID 0 = . CR",
+                "Should equal 0",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "VM-COUNT",
+        {
+            {
+                "at_least_one",
+                "VM-COUNT . CR",
+                "Should be at least 1 (Mama)",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "positive",
+                "VM-COUNT 0 > . CR",
+                "Should be positive",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "CAPSULE-BIRTH",
+        {
+            {
+                "invalid_id",
+                "9999999 CAPSULE-BIRTH . CR",
+                "Should return -1 for invalid capsule ID",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {
+                "empty_stack",
+                "CAPSULE-BIRTH",
+                "Should cause stack underflow",
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "CAPSULE-RUN",
+        {
+            {
+                "empty_stack",
+                "CAPSULE-RUN",
+                "Should cause stack underflow",
+                TEST_ERROR_CASE, 1, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+
+    {
+        "CAPSULE-TEST",
+        {
+            {
+                "basic",
+                "CAPSULE-TEST",
+                "Should print diagnostic message",
+                TEST_NORMAL, 0, MAMA_IMPLEMENTED, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}  /* End marker */
+};
+
+/**
+ * @brief Executes all Mama FORTH vocabulary test suites
+ *
+ * In hosted builds, all tests will be skipped since MAMA_IMPLEMENTED=0.
+ * In kernel builds, tests will execute against the capsule system.
+ *
+ * @param vm Pointer to the Forth virtual machine instance
+ */
+void run_mama_forth_words_tests(VM *vm)
+{
+    log_message(LOG_INFO, "Running Mama FORTH Words Tests (Capsule System M7.1)...");
+
+#ifndef __STARKERNEL__
+    log_message(LOG_INFO, "  (Hosted build - Mama words not available, tests will be skipped)");
+#endif
+
+    for (int i = 0; mama_word_suites[i].word_name != NULL; i++) {
+        run_test_suite(vm, &mama_word_suites[i]);
+    }
+
+    print_module_summary("Mama FORTH Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,240 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Memory Words Test Suites - Module 3 */
+static WordTestSuite memory_word_suites[] = {
+    {
+        "!", {
+            {"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, {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, {0}
+    },
+
+    {
+        "C!", {
+            {"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, {0}
+    },
+
+    {
+        "C@", {
+            {"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, {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, {0}
+    },
+
+    {
+        "C,", {
+            {"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, {0}
+    },
+
+    {
+        "2,", {
+            {
+                "roundtrip", "12345 67890 2, HERE 16 - 2@ . . CR", "Should print: 67890 12345",
+                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, {0}
+            },
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "HERE", {
+            {"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, {0}
+    },
+
+    {
+        "ALLOT", {
+            {"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, {0}
+    },
+
+    {
+        "PAD", {
+            {"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, {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, {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, {0}
+    },
+
+    {
+        "2!", {
+            {"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, {0}
+    },
+
+    {
+        "FILL", {
+            {"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, {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, {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, {0}
+    },
+
+    {
+        "ERASE", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes the test suite for memory manipulation words
+ * @details Runs through a series of test cases for Forth memory operations including
+ *          store, fetch, allot, and other memory-related words
+ *
+ * @param vm Pointer to the Forth virtual machine instance
+ */
+void run_memory_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Memory Words Tests (Module 3)...");
+
+    WordContract mod = {CONTRACT_PHYSICS_TRANSPARENT, 0};
+    for (int i = 0; memory_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite_m(vm, &memory_word_suites[i], mod);
+    }
+
+    print_module_summary("Memory Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,162 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/**
+ * @brief Module 7 test-suite table for mixed-arithmetic FORTH-79 words.
+ *
+ * Covers the five combined multiply-divide words: @c *-/ , @c *-/MOD ,
+ * @c M+ , @c M* , and @c M/MOD . Each suite exercises normal cases,
+ * edge cases (overflow, large products), and error cases (division by
+ * zero, stack underflow). The table is terminated with a NULL sentinel.
+ */
+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, {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, {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, {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, {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, {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, {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, {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, {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, {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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Module 7 entry point — run all mixed-arithmetic word POST tests.
+ *
+ * Iterates @c mixed_arithmetic_word_suites and delegates each to
+ * @c run_test_suite(). Covers five word families:
+ *
+ *  - @c *-/     ( n1 n2 n3 -- n4 ) — scale: n1*n2/n3 in 64-bit intermediate
+ *  - @c *-/MOD  ( n1 n2 n3 -- rem quot ) — scale with remainder
+ *  - @c M+     ( d n -- d' ) — add single to double
+ *  - @c M*     ( n1 n2 -- d ) — signed multiply to double
+ *  - @c M/MOD  ( d n -- rem quot ) — double divided by single
+ *
+ * @param vm  VM instance; must be initialised with the standard vocabulary.
+ */
+void run_mixed_arithmetic_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Mixed Arithmetic Words Tests (Module 7)...");
+
+    for (int i = 0; mixed_arithmetic_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &mixed_arithmetic_word_suites[i]);
+    }
+
+    print_module_summary("Mixed Arithmetic Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,127 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ */
+
+/*
+ * physics_freeze_words_test.c — POST tests for the proof-covered subset of
+ * physics_freeze_words.c (Module 27)
+ *
+ * physics_freeze_words.c registers 9 words; proof/COVERAGE.md and
+ * proof/StarForth_Physics_Freeze_Words.thy give real (non-"True"-placeholder)
+ * lemmas for exactly 6 of them: FREEZE-WORD, UNFREEZE-WORD, FROZEN?, HEAT!,
+ * HEAT@, DECAY-RATE@. FREEZE-CRITICAL, SHOW-HEAT, and ALL-HEATS carry only
+ * trivial "not_modelled"/pass-through True lemmas, so they are intentionally
+ * left uncovered here (matches the 6/9 figure in COVERAGE.md). No test file
+ * for this module existed before.
+ *
+ * Each test case defines a scratch dictionary word (`:` ... `;`) and takes
+ * its name via S" — every word here operates on ( caddr u ), the standard
+ * counted-string-less pair the rest of the FORTH interpreter uses. Using
+ * `run_test_suite` (no WordContract) rather than `run_test_suite_m`, matching
+ * defining_words_tests.c's precedent: these test cases define dictionary
+ * words, and check_physics_transparent's own contract explicitly documents
+ * that its re-run mechanism does not snapshot/restore dictionary state.
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Physics Freeze Words Test Suites - Module 27 */
+static WordTestSuite physics_freeze_word_suites[] = {
+    {
+        "FREEZE-WORD", {
+            {"basic",
+             ": __freeze_test_word__ ; S\" __freeze_test_word__\" FREEZE-WORD S\" __freeze_test_word__\" FROZEN? . CR",
+             "Should print: -1 (word is now frozen)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "UNFREEZE-WORD", {
+            {"basic",
+             ": __unfreeze_test_word__ ; S\" __unfreeze_test_word__\" FREEZE-WORD S\" __unfreeze_test_word__\" UNFREEZE-WORD S\" __unfreeze_test_word__\" FROZEN? . CR",
+             "Should print: 0 (freeze cleared)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "FROZEN?", {
+            {"not_frozen",
+             ": __frozen_test_word__ ; S\" __frozen_test_word__\" FROZEN? . CR",
+             "Should print: 0 (freshly defined word is not frozen)", TEST_NORMAL, 0, 1, {0}},
+            {"not_found",
+             "S\" __nonexistent_freeze_xyz__\" FROZEN? . CR",
+             "Should print: 0 (not-found treated as not frozen)", TEST_EDGE_CASE, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "HEAT!", {
+            {"basic",
+             ": __heat_store_test_word__ ; 999 S\" __heat_store_test_word__\" HEAT! S\" __heat_store_test_word__\" HEAT@ . CR",
+             "Should print: 999", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "HEAT@", {
+            {"of_fresh_word",
+             ": __heat_fetch_test_word__ ; S\" __heat_fetch_test_word__\" HEAT@ . CR",
+             "Should print: 0 (freshly defined word has zero heat)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "DECAY-RATE@", {
+            {"basic", "DECAY-RATE@ . CR",
+             "Should print the compile-time DECAY_RATE_PER_US_Q16 constant (no error)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes the proof-covered subset of physics-freeze word test suites
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Covers the 6 words proof/StarForth_Physics_Freeze_Words.thy gives
+ *          real lemmas for: FREEZE-WORD, UNFREEZE-WORD, FROZEN?, HEAT!,
+ *          HEAT@, DECAY-RATE@. Does not cover FREEZE-CRITICAL, SHOW-HEAT, or
+ *          ALL-HEATS — those carry only trivial/not-modelled lemmas in the
+ *          same theory file.
+ */
+void run_physics_freeze_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Physics Freeze Words Tests (Module 27)...");
+
+    for (int i = 0; physics_freeze_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &physics_freeze_word_suites[i]);
+    }
+
+    print_module_summary("Physics Freeze Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,230 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ */
+
+/*
+ * q48_words_test.c — POST tests for Q48.16 fixed-point words (Module 25)
+ *
+ * Proof-covered per proof/COVERAGE.md (StarForth_Q48_Words.thy, 17/23) but
+ * had no interpreter-level POST coverage at all before this file — no test
+ * file for q48_words.c existed. Values are built with Q.FROM-INT/Q.1/Q.0
+ * and read back with Q.TO-INT so results print as plain readable integers;
+ * pass/fail itself is judged only by vm->error (matching every other
+ * WordTestSuite-based module), so exact printed values are for a human
+ * reading the log, not machine-verified — same convention arithmetic_words_
+ * test.c already uses for its own "Should print: N" fields.
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* Q48.16 Words Test Suites - Module 25 */
+static WordTestSuite q48_word_suites[] = {
+    {
+        "Q.+", {
+            {"basic", "1 Q.FROM-INT 2 Q.FROM-INT Q.+ Q.TO-INT . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.-", {
+            {"basic", "5 Q.FROM-INT 2 Q.FROM-INT Q.- Q.TO-INT . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.*", {
+            {"basic", "3 Q.FROM-INT 4 Q.FROM-INT Q.* Q.TO-INT . CR", "Should print: 12", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q./", {
+            {"basic",    "10 Q.FROM-INT 2 Q.FROM-INT Q./ Q.TO-INT . CR", "Should print: 5", TEST_NORMAL, 0, 1, {0}},
+            {"by_zero",  "5 Q.FROM-INT 0 Q.FROM-INT Q./ Q.TO-INT . CR",  "Should print: 0 (division by zero yields q=0)", TEST_EDGE_CASE, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "Q.ABS", {
+            {"basic", "3 Q.FROM-INT Q.NEG Q.ABS Q.TO-INT . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.NEG", {
+            {"basic", "5 Q.FROM-INT Q.NEG Q.TO-INT . CR", "Should print: -5", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.LOG", {
+            {"of_one", "Q.1 Q.LOG Q.TO-INT . CR", "Should print: 0 (ln 1.0 = 0)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.EXP", {
+            {"of_zero", "Q.0 Q.EXP Q.TO-INT . CR", "Should print: 1 (e^0 = 1)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.SQRT", {
+            {"of_four", "4 Q.FROM-INT Q.SQRT Q.TO-INT . CR", "Should print: 2", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.SIN", {
+            {"of_zero", "Q.0 Q.SIN Q.TO-INT . CR", "Should print: 0 (sin 0 = 0)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.COS", {
+            {"of_zero", "Q.0 Q.COS Q.TO-INT . CR", "Should print: 1 (cos 0 = 1)", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.FROM-INT", {
+            {"round_trip", "7 Q.FROM-INT Q.TO-INT . CR", "Should print: 7", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.TO-INT", {
+            {"of_one", "Q.1 Q.TO-INT . CR", "Should print: 1", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.1", {
+            {"raw_value", "Q.1 . CR", "Should print: 65536", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.0", {
+            {"raw_value", "Q.0 . CR", "Should print: 0", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.SCALE", {
+            {"raw_value", "Q.SCALE . CR", "Should print: 65536", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.=", {
+            {"equal",     "Q.1 Q.1 Q.= . CR", "Should print: -1 (true)",  TEST_NORMAL, 0, 1, {0}},
+            {"not_equal", "Q.1 Q.0 Q.= . CR", "Should print: 0 (false)",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "Q.<", {
+            {"true",  "Q.0 Q.1 Q.< . CR", "Should print: -1 (true)",  TEST_NORMAL, 0, 1, {0}},
+            {"false", "Q.1 Q.0 Q.< . CR", "Should print: 0 (false)",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "Q.>", {
+            {"true",  "Q.1 Q.0 Q.> . CR", "Should print: -1 (true)",  TEST_NORMAL, 0, 1, {0}},
+            {"false", "Q.0 Q.1 Q.> . CR", "Should print: 0 (false)",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "Q.0=", {
+            {"true",  "Q.0 Q.0= . CR", "Should print: -1 (true)",  TEST_NORMAL, 0, 1, {0}},
+            {"false", "Q.1 Q.0= . CR", "Should print: 0 (false)",  TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        2, {0}
+    },
+    {
+        "Q.MAX", {
+            {"basic", "3 Q.FROM-INT 7 Q.FROM-INT Q.MAX Q.TO-INT . CR", "Should print: 7", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.MIN", {
+            {"basic", "3 Q.FROM-INT 7 Q.FROM-INT Q.MIN Q.TO-INT . CR", "Should print: 3", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {
+        "Q.PRINT", {
+            {"of_one", "Q.1 Q.PRINT CR", "Should print: 1.00000", TEST_NORMAL, 0, 1, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        1, {0}
+    },
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all Q48.16 fixed-point word test suites
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Covers all 23 words registered by register_q48_words()
+ *          (q48_words.c): arithmetic (+, -, *, /), sign (ABS, NEG),
+ *          transcendental approximations (LOG, EXP, SQRT, SIN, COS),
+ *          conversions (FROM-INT, TO-INT), constants (1, 0, SCALE),
+ *          comparisons (=, <, >, 0=, MAX, MIN), and PRINT.
+ */
+void run_q48_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Q48.16 Words Tests (Module 25)...");
+
+    WordContract mod = {CONTRACT_PHYSICS_TRANSPARENT, 0};
+    for (int i = 0; q48_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite_m(vm, &q48_word_suites[i], mod);
+    }
+
+    print_module_summary("Q48.16 Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,104 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/** 
+ * @brief Test suites for return stack manipulation words
+ * @details Contains test cases for >R (push to return stack), 
+ *          R> (pop from return stack), and R@ (copy top of return stack)
+ */
+static WordTestSuite return_stack_word_suites[] = {
+    {
+        ">R", {
+            {"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, {0}
+    },
+
+    {
+        "R>", {
+            {"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, {0}
+    },
+
+    {
+        "R@", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all test suites for return stack manipulation words
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Runs through all defined test cases for >R, R>, and R@ words
+ *          and reports results_run_01_2025_12_08 through the logging system
+ */
+void run_return_stack_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Return Stack Words Tests (Module 2)...");
+
+    WordContract mod = {CONTRACT_PHYSICS_TRANSPARENT, 0};
+    for (int i = 0; return_stack_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite_m(vm, &return_stack_word_suites[i], mod);
+    }
+
+    print_module_summary("Return Stack Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,215 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+/**
+ * @file stack_words_test.c
+ * @brief Test module for Forth stack manipulation words
+ * @details Contains test suites for basic stack operations including
+ *          DUP, DROP, SWAP, OVER, ROT, DEPTH, PICK, and ROLL
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/** 
+ * @brief Test suites for stack manipulation words
+ * @details Contains comprehensive test cases for all standard stack operations,
+ *          including normal cases, edge cases, and error conditions
+ */
+static WordTestSuite stack_word_suites[] = {
+    {
+        "DUP", {
+            {"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, {0}
+    },
+
+    {
+        "DROP", {
+            /* Basic functionality */
+            {"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, {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, {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, {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, {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, {0}},
+
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        15, {0}
+    },
+
+    {
+        "SWAP", {
+            {"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, {0}
+    },
+
+    {
+        "OVER", {
+            {"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, {0}
+    },
+
+    {
+        "ROT", {
+            {"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, {0}
+    },
+
+    {
+        "DEPTH", {
+            {"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, {0}
+    },
+
+    {
+        "PICK", {
+            {"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, {0}
+    },
+
+    {
+        "ROLL", {
+            {"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, {0}
+    },
+
+    {
+        "?DUP", {
+            {"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, {0}
+    },
+
+    {
+        "-ROT", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all test suites for stack manipulation words
+ * @param vm Pointer to the Forth virtual machine instance
+ * @details Runs through all defined test cases for stack manipulation words
+ *          and reports results_run_01_2025_12_08 through the logging system
+ */
+void run_stack_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running Stack Words Tests (Module 1: Foundation)...");
+
+    WordContract mod = {CONTRACT_PHYSICS_TRANSPARENT, 0};
+    for (int i = 0; stack_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite_m(vm, &stack_word_suites[i], mod);
+    }
+
+    print_module_summary("Stack Words", 0, 0, 0, 0); /* Will be calculated by test_suite */
+}
@@ -0,0 +1,222 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/**
+ * @brief Test suites for StarForth-specific words
+ *
+ * Contains test cases for the following StarForth implementation words:
+ * - ENTROPY@: Fetch word execution count
+ * - ENTROPY!: Store word execution count
+ * - WORD-ENTROPY: Get execution count for a word by name
+ * - RESET-ENTROPY: Reset all word execution counts
+ * - TOP-WORDS: Display most frequently executed words
+ * - (-: Comment to end of line
+ * - INIT: System initialization
+ */
+static WordTestSuite starforth_word_suites[] = {
+    {
+        "ENTROPY@", {
+            /* 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, {0}
+            },
+            {
+                "zero_initial", ": NEWWORD ; ' NEWWORD ENTROPY@ . CR",
+                "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, {0}
+            },
+
+            /* Error cases */
+            {"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, {0}}
+        },
+        5, {0}
+    },
+
+    {
+        "ENTROPY!", {
+            /* 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, {0}
+            },
+            {
+                "overwrite",
+                ": ENTOV ; 10 ' ENTOV ENTROPY! 20 ' ENTOV ENTROPY! ' ENTOV ENTROPY@ . CR",
+                "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, {0}
+            },
+
+            /* Error cases */
+            {"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, {0}}
+        },
+        6, {0}
+    },
+
+    {
+        "WORD-ENTROPY", {
+            /* 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, {0}
+            },
+            {
+                "after_execution", ": WDENT 1 2 + DROP ; WDENT WDENT WORD-ENTROPY",
+                "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, {0}
+            },
+
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "RESET-ENTROPY", {
+            /* Basic functionality */
+            {
+                "reset_defined", ": RESETTEST 1 DROP ; RESETTEST RESETTEST RESETTEST RESET-ENTROPY",
+                "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, {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, {0}
+            },
+
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        3, {0}
+    },
+
+    {
+        "TOP-WORDS", {
+            /* 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, {0}
+            },
+            {"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, {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, {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, {0}}
+        },
+        8, {0}
+    },
+
+    {
+        "(-", {
+            /* Basic functionality */
+            {"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, {0}},
+
+            /* Multiple comments */
+            {"multiple", "1 (- first\n2 (- second\n+ . CR", "Should handle multiple comments", TEST_NORMAL, 0, 1, {0}},
+
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        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}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all StarForth words test suites
+ * @param vm Pointer to the FORTH virtual machine instance
+ *
+ * Runs through all test cases for StarForth-specific implementation words,
+ * including entropy tracking, comments, and initialization.
+ */
+void run_starforth_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running StarForth Words Tests (Module 17: StarForth Extensions)...");
+
+    for (int i = 0; starforth_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &starforth_word_suites[i]);
+    }
+
+    print_module_summary("StarForth Words", 0, 0, 0, 0);
+}
@@ -0,0 +1,219 @@
+/*
+  StarForth — Steady-State Virtual Machine Runtime
+
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+      https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ StarForth — Steady-State Virtual Machine Runtime
+  Copyright (c) 2023–2025 Robert A. James
+  All rights reserved.
+
+  This file is part of the StarForth project.
+
+  Licensed under the StarForth License, Version 1.0 (the "License");
+  you may not use this file except in compliance with the License.
+
+  You may obtain a copy of the License at:
+       https://github.com/star.4th@proton.me/StarForth/LICENSE.txt
+
+  This software is provided "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  express or implied, including but not limited to the warranties of
+  merchantability, fitness for a particular purpose, and noninfringement.
+
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+ */
+
+#include "../include/test_runner.h"
+#include "../include/test_common.h"
+
+/* String Words Test Suites - Module 11 */
+static WordTestSuite string_word_suites[] = {
+    {
+        "COUNT", {
+            {"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, {0}
+    },
+
+    {
+        "-TRAILING", {
+            {"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, {0}
+    },
+
+    {
+        "CMOVE", {
+            {"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, {0}
+    },
+
+    {
+        "CMOVE>", {
+            {"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, {0}
+    },
+
+    {
+        "COMPARE", {
+            {"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, {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, {0}
+    },
+
+    {
+        "SEARCH", {
+            {"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, {0}
+            },
+            {
+                "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, {0}},
+            {NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}
+        },
+        4, {0}
+    },
+
+    {
+        "SCAN", {
+            {"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, {0}
+    },
+
+    {
+        "SKIP", {
+            {"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, {0}
+    },
+
+    {
+        "BLANK", {
+            {"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, {0}}
+        },
+        2, {0}
+    },
+
+    {
+        "S\"", {
+            {"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, {0}
+    },
+
+    {
+        "BL", {
+            {"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, {0}
+    },
+
+    {
+        "SOURCE", {
+            {"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, {0}
+    },
+
+    {
+        ">IN", {
+            {"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, {0}
+    },
+
+    /* End marker */
+    {NULL, {{NULL, NULL, NULL, TEST_NORMAL, 0, 0, {0}}}, 0, {0}}
+};
+
+/**
+ * @brief Executes all string manipulation word tests
+ *
+ * @details Runs test suites for FORTH string operations including COUNT, -TRAILING,
+ * CMOVE, CMOVE>, COMPARE, SEARCH, SCAN, SKIP, and BLANK
+ *
+ * @param vm Pointer to the Forth virtual machine instance
+ */
+void run_string_words_tests(VM *vm) {
+    log_message(LOG_INFO, "Running String Words Tests (Module 11)...");
+
+    for (int i = 0; string_word_suites[i].word_name != NULL; i++) {
+        log_message(LOG_TEST, "▶ Testing module: %s", __FILE__);
+        run_test_suite(vm, &string_word_suites[i]);
+    }
+
+    print_module_summary("String Words", 0, 0, 0, 0);
+}
--- a/Show More
+++ b/Show More