fix(v4.0.0): POST leaves nothing, as v3 really does; and what the review of step 6b found

Captain Bob was told that v3 leaves the words POST's cases define in the
dictionary, and ruled that v4 should.  That was false: v3's run_test_suite
puts the dictionary back after each word's cases (test_common.c:333,
:365).  Shown that, he ruled that POST leaves nothing.  The boot now
seals the system, runs POST, and has the node do COLD, whose printing is
not shown; PARITY:V4_SYSTEM is the system as sealed.

A case the node does not come back from ends POST there, named, with how
many were not run: it would have stalled the boot for hours, where the
capsule had ended it.  The runner's test of it now uses a word that
really never ends.

hosted-check also requires that RS1 and T{ are unknown after boot, and
boots a program whose POST has failing cases (tests/post_cases_fail.c):
PARITY:FAIL, POST: FAILED, no prompt, none of a case's printing shown.

Comments and documents that still named the POST capsule or its two
hooks are brought up to date; NUCLEUS.md 6.3 says what v3 does, with the
lines, and how the wrong ruling came about.

make -C v4 test, sanitize and hosted-check pass; amd64, aarch64 and
riscv64 boot, POST 538 of 538, word_count=314, dict_hash
0x220ab283a504a3b3 on all six: logs/20261007-112638, -112901, -113220.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

v4/tests/test_host_unit.c

@@ -344,7 +344,7 @@ int main(void)
     printf("v4 unit tests: V4_CELL_BITS=%d, V4_NODE_WORDS=%u\n", V4_CELL_BITS, (unsigned)V4_NODE_WORDS);
     if (V4_CELL_BITS != 64) {
         /* The capsules the unit is built from are the 64-bit products': the
-         * expected results in post79.4th are v3's, on 64-bit cells, and the
+         * expected results in POST's table are v3's, on 64-bit cells, and the
          * nucleus capsule is nucleus-64.  POST has never been run on 32-bit
          * cells (docs/v4.0.0/MESH.md, step 5). */
         printf("  not run at this width: the capsules are the 64-bit products'\n");
@@ -400,16 +400,30 @@ int main(void)
     }
     CHECK(strcmp(tell(10, "NODE-ME ."), "0 ") == 0 && refused == 0, "it asks where it is, and is answered");
     CHECK(load(10, "forth79.4th") == 0, "it takes in FORTH-79");
+    CHECK(told(10, "(SEAL)"), "the nucleus and FORTH-79 are the system POST is run on");
     {
+        static v4_cell before[V4_NODE_WORDS];
         v4_post_host host;
         v4_post_tally tally;
-        host.self = 0; host.n = node_numbered(10); host.line = post_line; host.say = post_say;
+        v4_node *hera = node_numbered(10);
+        v4_cell here = hera->mem[DP] / 4, k, changed = 0, first = -1;
+        uint64_t hash = v4_image_dict_hash(hera, &im);
+        memcpy(before, hera->mem, sizeof before);
+        host.self = 0; host.n = hera; host.line = post_line; host.say = post_say;
         CHECK(v4_post_run(&host, v4_post_cases, v4_post_case_count, &tally) && tally.tests == 538 && tally.pass == 538 && tally.fail == 0
               && strstr(post_said, "PARITY:V4_POST tests=538 pass=538 fail=0\n") != NULL && strstr(post_said, "POST FAIL") == NULL,
               "and passes POST, which the kernel runs on her: %u of %u, %u failed; \"%s\"", tally.pass, tally.tests, tally.fail, post_said);
+        CHECK(strcmp(tell(10, "RS1"), "42 42 \n") == 0, "while POST runs, what its cases define is on her: \"%s\"", printed);
+        CHECK(strstr(tell(10, "COLD"), "Cold Start") != NULL, "the kernel puts her back to the system as it was sealed");
+        CHECK(hera->mem[DP] == before[DP] && hera->mem[LATEST] == before[LATEST], "HERE and LATEST are where they were before POST");
+        for (k = 0; k < here; k++) if (hera->mem[k] != before[k]) { if (first < 0) first = k; changed++; }
+        /* What differs is the TTL in the entry of each word POST had interpreted: a count of uses left before
+         * the word's access is checked again, which every use counts down (compile.v4, (ACL?)), as in v3. */
+        printf("  after POST and COLD: %ld of the %ld cells below HERE differ from before POST (the first at %ld); dict_hash %s\n",
+               (long)changed, (long)here, (long)first, v4_image_dict_hash(hera, &im) == hash ? "the same" : "differs");
     }
     CHECK(strstr(tell(10, "T{"), "UNKNOWN WORD") != NULL, "nothing of POST's harness is on her: \"%s\"", printed);
-    CHECK(strcmp(tell(10, "RS1"), "42 42 \n") == 0, "what POST's cases defined is: \"%s\"", printed);
+    CHECK(strstr(tell(10, "RS1"), "UNKNOWN WORD") != NULL && strstr(tell(10, "ZERO"), "UNKNOWN WORD") != NULL, "nor anything POST's cases defined: POST leaves nothing, as in v3: \"%s\"", printed);
     CHECK(load(10, "hera.4th") == 0, "and its own capsule, which makes it Hera");
     CHECK(told(10, "(SEAL)"), "that is the system it comes back to");
 
@@ -423,7 +437,6 @@ int main(void)
     CHECK(post_passed[10] == 0 && post_passed[11] == 0 && post_passed[12] == 0 && post_passed[13] == 0 && post_passed[14] == 0 && post_other == 0,
           "a node she births is not POSTed, and no node prints a POST tally: POST is the kernel's, once, on Hera: %u %u %u %u %u, %u failed",
           post_passed[10], post_passed[11], post_passed[12], post_passed[13], post_passed[14], post_other);
-    CHECK(strstr(tell(10, "COLD"), "Cold Start") != NULL && strcmp(tell(10, "RS1"), "42 42 \n") == 0, "COLD on Hera comes back to a system that has what POST's cases defined: \"%s\"", printed);
     CHECK(parity_count == 4 && parity_number[0] == 11 && parity_number[1] == 12 && parity_number[2] == 13 && parity_number[3] == 14, "the parity of each was recorded: %u", parity_count);
     CHECK(parity_hash[0] == parity_hash[1] && parity_hash[1] == parity_hash[2] && parity_hash[2] == parity_hash[3],
           "and their dictionary hashes are the same: %016llx %016llx %016llx %016llx",