#188: the Jacquard selector's 64 cards, L7 permanently on, L2 a real gate

Captain Bob, 2026-11-12: "Wire L2, keep L7 on". The table held the 128 cards of the 7-bit L1-L7 space; nothing read L7, and the rolling window recorded whatever the card said, so the 128 were 32 behaviours. - compudynamics.c: cd_tuning_word() sizes the table to 64 (L1-L6). - ssm_jacquard.c: card_bits() makes a card's 7-bit mask, L7 set, where a card is read, seeded and started (C4: 17 -> card 8); ssm_l8_force_config() still takes the 7-bit index, its L7 bit implied. - physics_execution_hooks.c, kernel vm_core.c: the rolling window records only while L2 is on (or before there is a config). - ssm_jacquard.h says what is wired, bit by bit (it said L7 was); v3/CLAUDE.md and the L8 reference corrected in place; FABRIC-3 XLVIII.21. Tests first, seen to fail against HEAD (logs/20261112-210510/kernel-tests): test_ssm_jacquard 4 of 7, test_physics_l2 1 of 4; all pass now. v4 reads no rolling window: acceptance is unchanged; the protocol runs next. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
2026-11-12 21:05:24 +00:00
parent 7e0728e46b
commit c76a742f2b
15 changed files with 233 additions and 19 deletions
@@ -785,8 +785,13 @@ void execute_colon_word(VM* vm)
            uint32_t word_id = w->word_id;
            if (word_id < DICTIONARY_SIZE)
            {
-                /* L8 FINAL INTEGRATION: Loop #2 always-on - Rolling Window of Truth */
-                rolling_window_record_execution(&vm->rolling_window, word_id);
+                /* Loop #2: Rolling Window of Truth -- L8's live toggle (#188: it was always on,
+                 * so the selector's L2 bit did nothing). No config yet: recorded. */
+                {
+                    const ssm_config_t *ssm_cfg = (const ssm_config_t*)vm->ssm_config;
+                    if (!ssm_cfg || ssm_cfg->L2_rolling_window)
+                        rolling_window_record_execution(&vm->rolling_window, word_id);
+                }

 /* L8 FINAL INTEGRATION: Loop always-on */                /* Loop #4: Pipelining Transition Metrics - WIRED & UTILIZED */
                if (prev_word && prev_word->transition_metrics && ENABLE_PIPELINING)
@@ -19,7 +19,9 @@ CC     ?= cc
 CFLAGS := -std=c99 -Wall -Wextra -Werror -O2 -g -I$(HERE) -I$(ROOT)/kernel/include \
          -I$(ROOT)/kernel/include/starkernel -I$(ROOT)/v3/include

-TESTS := test_gpt test_usb_config test_sk_v4_stop test_sk_v4_slots test_sk_v4_mint test_sk_v4_identity test_heartbeat_export
+TESTS := test_gpt test_usb_config test_sk_v4_stop test_sk_v4_slots test_sk_v4_mint test_sk_v4_identity test_heartbeat_export test_ssm_jacquard test_physics_l2
+SRC_test_physics_l2 := $(ROOT)/v3/src/physics_execution_hooks.c
+SRC_test_ssm_jacquard := $(ROOT)/v3/src/ssm_jacquard.c $(ROOT)/v3/src/compudynamics.c
 SRC_test_heartbeat_export := $(ROOT)/v3/src/heartbeat_export.c
 SRC_test_sk_v4_identity := $(ROOT)/kernel/src/v4/sk_v4_identity.c $(ROOT)/kernel/src/v4/sk_v4_slots.c $(ROOT)/kernel/src/gpt.c
 EXTRA_test_sk_v4_identity := -D__STARKERNEL__ -I$(ROOT)/v4/include -DSTICK_GROW_MIN_BYTES=8000000000ULL -DSTICK_ARTEMIS_CAP_GIB=256ULL
@@ -0,0 +1,80 @@
+/* SPDX-License-Identifier: LicenseRef-Starship-1.0
+ * Copyright (c) 2023-2026 Robert A. James
+ */
+/* test_physics_l2.c -- v3/src/physics_execution_hooks.c on the host (#188): the rolling window
+ * records a word's execution only while the live config's L2 (rolling window) is on -- L8's toggle,
+ * as L4 is -- and, with no config yet, records it. It recorded whatever the card said (Captain Bob,
+ * 2026-11-12: "Wire L2, keep L7 on").
+ *
+ * What the hook calls outside itself is defined here: the rolling window's recorder counts.
+ */
+#include "harness.h"
+#include "vm.h"
+#include "physics_execution_hooks.h"
+#include "physics_metadata.h"
+#include "platform_time.h"
+#include "profiler.h"
+#include "rolling_window_of_truth.h"
+#include "ssm_jacquard.h"
+#include <stdlib.h>
+#include <string.h>
+
+static unsigned recorded;
+int rolling_window_record_execution(RollingWindowOfTruth *window, uint32_t word_id)
+{
+    (void)window; (void)word_id; recorded++; return 0;
+}
+void physics_metadata_apply_linear_decay(DictEntry *entry, uint64_t elapsed_ticks, VM *vm)
+{
+    (void)entry; (void)elapsed_ticks; (void)vm;
+}
+void physics_metadata_touch(DictEntry *entry, cell_t execution_heat, uint64_t now_ns)
+{
+    (void)entry; (void)execution_heat; (void)now_ns;
+}
+void profiler_word_exit(const DictEntry *entry) { (void)entry; }
+void sf_mutex_lock(sf_mutex_t *mutex) { (void)mutex; }
+void sf_mutex_unlock(sf_mutex_t *mutex) { (void)mutex; }
+void vm_heartbeat_run_cycle(VM *vm) { (void)vm; }
+
+static sf_time_ns_t clock_ns(void) { return 1000u; }
+static sf_time_backend_t backend;
+const sf_time_backend_t *sf_time_backend = &backend;
+
+static unsigned run(VM *vm, DictEntry *w)   /* one execution of w: how many times was it recorded */
+{
+    recorded = 0;
+    physics_pre_execute(vm, w, NULL);
+    return recorded;
+}
+
+int main(void)
+{
+    VM *vm = calloc(1, sizeof *vm);
+    DictEntry w;
+    ssm_config_t cfg;
+    unsigned n;
+
+    backend.get_monotonic_ns = clock_ns;
+    CHECK(vm != 0, "a VM");
+    if (!vm) return DONE();
+    memset(&w, 0, sizeof w);
+    w.word_id = 7;
+    memset(&cfg, 0, sizeof cfg);
+
+    vm->ssm_config = NULL;
+    n = run(vm, &w);
+    CHECK(n == 1u, "no config yet: the execution is recorded (%u)", n);
+
+    vm->ssm_config = &cfg;
+    cfg.L2_rolling_window = 1;
+    n = run(vm, &w);
+    CHECK(n == 1u, "L2 on: the execution is recorded (%u)", n);
+
+    cfg.L2_rolling_window = 0;
+    n = run(vm, &w);
+    CHECK(n == 0u, "#188: L2 off: the execution is not recorded (%u times)", n);
+
+    free(vm);
+    return DONE();
+}
@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: LicenseRef-Starship-1.0
+ * Copyright (c) 2023-2026 Robert A. James
+ */
+/* test_ssm_jacquard.c -- v3/src/ssm_jacquard.c and compudynamics.c on the host (#188): the L8
+ * selector's cards are 64, every one different, L7 (adaptive heartrate) on in all of them -- it is
+ * permanently on (docs/reference/L8_ADAPTIVE_CONFIG_TABLE.md; Captain Bob, 2026-11-12: "Wire L2,
+ * keep L7 on") -- instead of 128 cards of which those differing only in L7 (or L2) acted alike.
+ */
+#include "harness.h"
+#include "ssm_jacquard.h"
+#include "compudynamics.h"
+#include <string.h>
+
+static unsigned tuple(const ssm_config_t *c)       /* L1..L6 as six bits */
+{
+    return (unsigned)(c->L1_heat_tracking << 5 | c->L2_rolling_window << 4 | c->L3_linear_decay << 3 |
+                      c->L4_pipelining << 2 | c->L5_window_inference << 1 | c->L6_decay_inference);
+}
+
+int main(void)
+{
+    ssm_l8_state_t st;
+    ssm_config_t cfg;
+    unsigned seen[64], c, n, distinct = 0, all_l7 = 1;
+
+    memset(&st, 0, sizeof st);
+    ssm_l8_init(&st, SSM_MODE_C4);
+    ssm_l8_init_table(&st);
+    CHECK(st.table != 0, "the adaptive table is allocated");
+    if (!st.table) return DONE();
+    n = st.table->num_configs;
+    CHECK(n == 64u, "#188: 64 cards -- L7 is not the selector's to choose (%u)", n);
+
+    memset(&cfg, 0, sizeof cfg);
+    ssm_apply_mode_from_table(&st, &cfg);
+    CHECK(cfg.L3_linear_decay == 1 && cfg.L7_adaptive_heartrate == 1 && tuple(&cfg) == 0x08u,
+          "the starting card is still C4: L3 and L7 only (L1-L6 bits %#x, L7 %d)", tuple(&cfg), cfg.L7_adaptive_heartrate);
+
+    memset(seen, 0, sizeof seen);
+    for (c = 0; c < n && c < 128u; c++) {
+        st.table->current_config = c;
+        memset(&cfg, 0, sizeof cfg);
+        ssm_apply_mode_from_table(&st, &cfg);
+        if (!cfg.L7_adaptive_heartrate) all_l7 = 0;
+        if (tuple(&cfg) < 64u && !seen[tuple(&cfg)]++) distinct++;
+    }
+    CHECK(all_l7, "#188: L7 on in every card");
+    CHECK(distinct == 64u && distinct == n, "#188: every card a different L1-L6 setting, all 64 of them (%u distinct of %u)", distinct, n);
+
+    /* forcing a card by its 7-bit index (inference_words.c): the L7 bit is implied on */
+    memset(&cfg, 0, sizeof cfg);
+    ssm_l8_force_config(&st, &cfg, 0x31u);                  /* 49: L2+L3+L7 -- C12 */
+    CHECK(tuple(&cfg) == 0x18u && cfg.L7_adaptive_heartrate == 1, "forced 0x31: L2, L3 and L7 (L1-L6 %#x)", tuple(&cfg));
+    memset(&cfg, 0, sizeof cfg);
+    ssm_l8_force_config(&st, &cfg, 0x30u);                  /* the same without its L7 bit */
+    CHECK(tuple(&cfg) == 0x18u && cfg.L7_adaptive_heartrate == 1, "forced 0x30: the same card, L7 still on (L1-L6 %#x, L7 %d)",
+          tuple(&cfg), cfg.L7_adaptive_heartrate);
+
+    ssm_l8_free_table(&st);
+    return DONE();
+}