From 7639fc949ef4fbcdef77fe7f40f35fd6c961120f Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 12:20:02 -0600 Subject: [PATCH 1/3] Reject non-oracle freshness mutation failures --- .github/workflows/current-site.yml | 18 +- .../node-status-freshness/run_mutations.py | 154 ++++++++++- docs/site/node-status.json | 9 +- records/node_status/eng.hard-gate.json | 9 +- tests/test_node_status_mutation_grader.py | 244 ++++++++++++++++++ 5 files changed, 414 insertions(+), 20 deletions(-) create mode 100644 tests/test_node_status_mutation_grader.py diff --git a/.github/workflows/current-site.yml b/.github/workflows/current-site.yml index 5c2e6e3fd..68db2b41d 100644 --- a/.github/workflows/current-site.yml +++ b/.github/workflows/current-site.yml @@ -15,6 +15,7 @@ name: Current research site - 'tools/node_status_refresh.py' - 'tests/test_node_status_refresh.py' - 'tests/test_node_status_freshness.py' + - 'tests/test_node_status_mutation_grader.py' - 'cbz/evidence/node-status-freshness/run_mutations.py' # inputs of the freshness suite and its mutation runner - 'tools/validate_node_status.py' @@ -49,6 +50,22 @@ jobs: python3 -B -S -m unittest discover -s tests -p 'test_current_site*.py' -v python3 -B -O -S -m unittest discover -s tests -p 'test_current_site*.py' -v node --test tests/test_current_site.mjs + - name: Verify freshness mutation provenance + run: | + set -euo pipefail + mkdir -p "$RUNNER_TEMP/node-status-grader-evidence" + python3 -B -S -m unittest tests.test_node_status_mutation_grader -v > "$RUNNER_TEMP/node-status-grader-evidence/controls-normal.stdout" 2> "$RUNNER_TEMP/node-status-grader-evidence/controls-normal.stderr" + python3 -B -O -S -m unittest tests.test_node_status_mutation_grader -v > "$RUNNER_TEMP/node-status-grader-evidence/controls-optimized.stdout" 2> "$RUNNER_TEMP/node-status-grader-evidence/controls-optimized.stderr" + python3 -B -S cbz/evidence/node-status-freshness/run_mutations.py > "$RUNNER_TEMP/node-status-grader-evidence/mutations-normal.json" 2> "$RUNNER_TEMP/node-status-grader-evidence/mutations-normal.stderr" + python3 -B -O -S cbz/evidence/node-status-freshness/run_mutations.py > "$RUNNER_TEMP/node-status-grader-evidence/mutations-optimized.json" 2> "$RUNNER_TEMP/node-status-grader-evidence/mutations-optimized.stderr" + - name: Preserve freshness mutation evidence + if: always() + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 + with: + name: node-status-grader-${{ github.run_id }}-${{ github.run_attempt }} + path: ${{ runner.temp }}/node-status-grader-evidence/ + if-no-files-found: error + retention-days: 90 node-status-refresh: # LANES-20261022 Lane 3: report-only freshness of records/node_status. @@ -66,7 +83,6 @@ jobs: run: | python3 -B -S -m unittest tests.test_node_status_freshness tests.test_node_status_refresh -v python3 -B -O -S -m unittest tests.test_node_status_freshness tests.test_node_status_refresh -v - python3 -B -S cbz/evidence/node-status-freshness/run_mutations.py > "$RUNNER_TEMP/node-status-mutations.json" # Pull requests run only the offline steps above. The live refresh reads the GitHub API, # so it runs on main pushes, schedules and manual dispatch, never on a pull request. - name: Report-only freshness refresh (read-only GitHub API) diff --git a/cbz/evidence/node-status-freshness/run_mutations.py b/cbz/evidence/node-status-freshness/run_mutations.py index 880093773..282cdbae9 100644 --- a/cbz/evidence/node-status-freshness/run_mutations.py +++ b/cbz/evidence/node-status-freshness/run_mutations.py @@ -1,6 +1,7 @@ #!/usr/bin/env python3 """Bounded, non-destructive assertion-only mutation experiment; no math certification.""" import json +import os from pathlib import Path import shutil import subprocess @@ -22,9 +23,140 @@ ('directory-drift', 'before == after', 'True', 'test_directory_changed_even_unchanged_child'), ] -def execute(root, method, optimized): - cmd=[sys.executable,'-B','-S']+(['-O'] if optimized else [])+['-m','unittest','-v','tests.test_node_status_freshness.ContentTests.'+method] - return subprocess.run(cmd,cwd=root,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True,timeout=30) +# The child records code-object identities while unittest still holds the +# original traceback. Only the selected body and explicitly captured standard +# unittest assertion machinery may appear after the selected frame. +ORIGIN_RUNNER = r''' +import contextlib +import io +import json +import sys +import unittest +import unittest.case + +def code_of(value): + return getattr(getattr(value, "__func__", value), "__code__", None) + +oracle = set() +for name in dir(unittest.TestCase): + if name.startswith("assert") or name in ("fail", "_baseAssertEqual", "_formatMessage"): + code = code_of(getattr(unittest.TestCase, name, None)) + if code is not None: + oracle.add(code) +for cls, names in ((unittest.case._AssertRaisesContext, ("__exit__",)), + (unittest.case._AssertRaisesBaseContext, ("_raiseFailure",))): + for name in names: + code = code_of(getattr(cls, name, None)) + if code is not None: + oracle.add(code) + +test_id = sys.argv[1] +captured = io.StringIO() +with contextlib.redirect_stdout(captured): + suite = unittest.defaultTestLoader.loadTestsFromName(test_id) + def leaves(node): + if isinstance(node, unittest.TestSuite): + for child in node: + yield from leaves(child) + else: + yield node + cases = list(leaves(suite)) + selected = cases[0] if len(cases) == 1 else None + selected_name = getattr(selected, "_testMethodName", "") + selected_code = code_of(getattr(selected, selected_name, None)) + selected_id = selected.id() if selected is not None else None + + class Result(unittest.TextTestResult): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.events = [] + + def record(self, test, err, kind): + case = getattr(test, "test_case", test) + frames = [] + tb = err[2] + while tb is not None: + code = tb.tb_frame.f_code + frames.append((code, tb.tb_lineno)) + tb = tb.tb_next + indexes = [i for i, (code, _) in enumerate(frames) if code is selected_code] + tail = frames[indexes[-1] + 1:] if indexes else frames + authorized = (kind == "failure" and case is selected and selected_id == test_id + and selected_code is not None and bool(indexes) + and all(code in oracle for code, _ in tail)) + self.events.append({"test_id": case.id(), "kind": kind, "authorized": authorized, + "exception": err[0].__name__, + "frames": [{"name": code.co_name, + "filename": code.co_filename, + "line": line, + "selected": code is selected_code, + "oracle": code in oracle} + for code, line in frames]}) + + def addFailure(self, test, err): + self.record(test, err, "failure") + super().addFailure(test, err) + + def addError(self, test, err): + self.record(test, err, "error") + super().addError(test, err) + + def addSubTest(self, test, subtest, err): + if err is not None: + kind = "failure" if issubclass(err[0], test.failureException) else "error" + self.record(subtest, err, kind) + super().addSubTest(test, subtest, err) + + result = unittest.TextTestRunner(stream=sys.stderr, verbosity=2, resultclass=Result).run(suite) + report = {"schema": "node-freshness-origin-v1", "test_id": test_id, + "selected_id": selected_id, "tests_run": result.testsRun, + "failure_count": len(result.failures), "error_count": len(result.errors), + "skip_count": len(result.skipped), "expected_failure_count": len(result.expectedFailures), + "unexpected_success_count": len(result.unexpectedSuccesses), "events": result.events, + "captured_stdout": captured.getvalue()} +print(json.dumps(report, sort_keys=True)) +sys.exit(0 if result.wasSuccessful() and not result.skipped and not result.expectedFailures else 1) +''' + + +def run_selected(root, test_id, optimized): + cmd = [sys.executable, '-B', '-S'] + (['-O'] if optimized else []) + ['-c', ORIGIN_RUNNER, test_id] + env = {key: value for key, value in os.environ.items() if not key.startswith('PYTHON')} + child = subprocess.run(cmd, cwd=root, env=env, stdin=subprocess.DEVNULL, + stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=30) + try: + report = json.loads(child.stdout) + if not isinstance(report, dict) or report.get('schema') != 'node-freshness-origin-v1': + raise ValueError('unexpected provenance schema') + except (ValueError, TypeError): + return {'protocol_error': True, 'child_exit': child.returncode, + 'stdout': child.stdout, 'output': child.stderr} + report.update(protocol_error=False, child_exit=child.returncode, output=child.stderr) + return report + + +def _common(result, test_id): + count_keys = ('tests_run', 'failure_count', 'error_count', 'skip_count', + 'expected_failure_count', 'unexpected_success_count', 'child_exit') + return (isinstance(result, dict) and all(type(result.get(key)) is int for key in count_keys) + and result.get('protocol_error') is False and result.get('test_id') == test_id + and result.get('selected_id') == test_id and result.get('tests_run') == 1 + and result.get('error_count') == 0 and result.get('skip_count') == 0 + and result.get('expected_failure_count') == 0 + and result.get('unexpected_success_count') == 0 and isinstance(result.get('events'), list)) + + +def qualified_kill(result, test_id): + return (_common(result, test_id) and result.get('child_exit') == 1 + and result['failure_count'] > 0 + and len(result['events']) == result['failure_count'] + and all(isinstance(event, dict) and event.get('kind') == 'failure' and event.get('test_id') == test_id + and event.get('authorized') is True for event in result['events'])) + + +def baseline_ok(result, test_id): + return (_common(result, test_id) and result.get('child_exit') == 0 + and result.get('failure_count') == 0 and not result['events']) def main(): rows=[] @@ -43,15 +175,15 @@ def main(): for name,old,new,method in CASES: if original.count(old)!=1: raise RuntimeError('nonunique mutation: '+name) module.write_text(original) - baseline=execute(dest,method,optimized) - if baseline.returncode != 0 or 'Ran 1 test' not in baseline.stdout or 'skipped' in baseline.stdout: raise RuntimeError('baseline failed or vacuous: '+baseline.stdout) + test_id='tests.test_node_status_freshness.ContentTests.'+method + baseline=run_selected(dest,test_id,optimized) + if not baseline_ok(baseline,test_id): raise RuntimeError('baseline failed or vacuous: '+json.dumps(baseline)) module.write_text(original.replace(old,new)) - result=execute(dest,method,optimized) - killed=(result.returncode==1 and 'AssertionError' in result.stdout - and 'FAILED (failures=' in result.stdout and 'errors=' not in result.stdout - and method in result.stdout) - rows.append(dict(name=name,optimized=optimized,killed=killed,output=result.stdout)) - if not killed: raise RuntimeError('not an intended assertion kill: '+result.stdout) + result=run_selected(dest,test_id,optimized) + killed=qualified_kill(result,test_id) + rows.append(dict(name=name,optimized=optimized,killed=killed, + output=result.get('output',''),provenance=result)) + if not killed: raise RuntimeError('not an authorized assertion kill: '+json.dumps(result)) module.write_text(original) print(json.dumps({'cases':len(rows),'results':rows},indent=2)) return 0 diff --git a/docs/site/node-status.json b/docs/site/node-status.json index 627d9c0ae..e1d0469af 100644 --- a/docs/site/node-status.json +++ b/docs/site/node-status.json @@ -27,9 +27,10 @@ "schema_version": 0, "node_id": "eng.hard-gate", "owner": null, - "next_action": "Use the pinned downstream-gate package as the recorded engineering control. This view sets no mathematical status.", + "next_action": "Use the pinned downstream-gate package as the recorded engineering control. This view sets no mathematical status. Before treating this view as current, compare the cited directory with the observed Math- default.", "missing_input": [ - "The graph source is the directory frontiers/downstream_gate_20260925/, so this view does not pin one document byte as the control text." + "The graph source is the directory frontiers/downstream_gate_20260925/, so this view does not pin one document byte as the control text.", + "At Math- f532c3e2d91a0c7679a37c733741660917a9b21b the cited directory tree differs from the pinned dbe6c0a1b1a22c7404b0fd173ee0043b98a08cde tree; the historical source pin is retained." ], "stops": [], "sources": [ @@ -43,8 +44,8 @@ } ], "source_rev": "dbe6c0a1b1a22c7404b0fd173ee0043b98a08cde", - "observed_at": "2026-10-22T17:00:35Z", - "status": "fresh", + "observed_at": "2026-11-09T18:03:21Z", + "status": "stale", "scientific_effect": "NONE" }, "math.lifetime-remainder": { diff --git a/records/node_status/eng.hard-gate.json b/records/node_status/eng.hard-gate.json index 6a502b1d8..b28f43394 100644 --- a/records/node_status/eng.hard-gate.json +++ b/records/node_status/eng.hard-gate.json @@ -2,9 +2,10 @@ "schema_version": 0, "node_id": "eng.hard-gate", "owner": null, - "next_action": "Use the pinned downstream-gate package as the recorded engineering control. This view sets no mathematical status.", + "next_action": "Use the pinned downstream-gate package as the recorded engineering control. This view sets no mathematical status. Before treating this view as current, compare the cited directory with the observed Math- default.", "missing_input": [ - "The graph source is the directory frontiers/downstream_gate_20260925/, so this view does not pin one document byte as the control text." + "The graph source is the directory frontiers/downstream_gate_20260925/, so this view does not pin one document byte as the control text.", + "At Math- f532c3e2d91a0c7679a37c733741660917a9b21b the cited directory tree differs from the pinned dbe6c0a1b1a22c7404b0fd173ee0043b98a08cde tree; the historical source pin is retained." ], "stops": [], "sources": [ @@ -18,7 +19,7 @@ } ], "source_rev": "dbe6c0a1b1a22c7404b0fd173ee0043b98a08cde", - "observed_at": "2026-10-22T17:00:35Z", - "status": "fresh", + "observed_at": "2026-11-09T18:03:21Z", + "status": "stale", "scientific_effect": "NONE" } diff --git a/tests/test_node_status_mutation_grader.py b/tests/test_node_status_mutation_grader.py new file mode 100644 index 000000000..2c98e0ac8 --- /dev/null +++ b/tests/test_node_status_mutation_grader.py @@ -0,0 +1,244 @@ +"""Adverse execution controls for the node-status mutation grader.""" +import importlib.util +import json +from pathlib import Path +import shutil +import tempfile +import textwrap +import unittest + + +ROOT = Path(__file__).resolve().parents[1] +GRADER = ROOT / "cbz/evidence/node-status-freshness/run_mutations.py" +TEST_ID = "tests.fixture.Fixture.test_selected" + + +def load_grader(): + spec = importlib.util.spec_from_file_location("node_freshness_grader_under_test", GRADER) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +class MutationOriginTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.grader = load_grader() + + def check_case(self, method, *, setup="pass", teardown="pass"): + self.assertTrue(hasattr(self.grader, "run_selected"), "missing provenance-aware runner") + self.assertTrue(hasattr(self.grader, "qualified_kill"), "missing provenance-aware classifier") + source = """\ +import unittest + +def subject(): + raise AssertionError('subject assertion') + +class Fixture(unittest.TestCase): + def setUp(self): + {setup} + + def tearDown(self): + {teardown} + + def helper(self): + self.fail('helper assertion') + + def test_selected(self): +{method} +""".format(setup=setup, teardown=teardown, + method=textwrap.indent(textwrap.dedent(method).strip(), " ")) + with tempfile.TemporaryDirectory(prefix="freshness-origin-fixture-") as tmp: + root = Path(tmp) + (root / "tests").mkdir() + (root / "tests/__init__.py").write_text("", encoding="utf-8") + (root / "tests/fixture.py").write_text(source, encoding="utf-8") + return [self.grader.qualified_kill(self.grader.run_selected(root, TEST_ID, optimized), TEST_ID) + for optimized in (False, True)] + + def test_selected_body_assertion_is_a_kill(self): + self.assertEqual(self.check_case("raise AssertionError('selected body')"), [True, True]) + + def test_selected_unittest_oracle_is_a_kill(self): + self.assertEqual(self.check_case("self.assertEqual(1, 2)"), [True, True]) + + def test_selected_assert_raises_oracle_is_a_kill(self): + self.assertEqual(self.check_case("with self.assertRaises(ValueError):\n pass"), [True, True]) + + def test_selected_subtest_oracle_is_a_kill(self): + self.assertEqual(self.check_case("with self.subTest(number=1):\n self.assertEqual(1, 2)"), [True, True]) + + def test_subject_assertion_is_not_a_kill(self): + self.assertEqual(self.check_case("self.assertEqual(subject(), 1)"), [False, False]) + + def test_real_subject_assertion_is_not_a_kill(self): + test_id = ("tests.test_node_status_freshness.ContentTests." + "test_strict_invalid_records_never_repaired_to_green") + target_path = "tools/node_status_refresh.py" + old = "if problems:" + adverse = "if (_ for _ in ()).throw(AssertionError('subject-origin probe')):" + paths = [target_path, "tools/validate_node_status.py", + "tests/test_node_status_freshness.py", "architecture/node-status.schema.json", + "docs/site/current.json"] + paths += [str(p.relative_to(ROOT)) for p in (ROOT / "records/node_status").glob("*.json")] + with tempfile.TemporaryDirectory(prefix="freshness-real-origin-") as tmp: + root = Path(tmp) + for path in paths: + (root / path).parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT / path, root / path) + for package in ("tools", "tests"): + (root / package / "__init__.py").write_text("", encoding="utf-8") + target = root / target_path + original = target.read_text(encoding="utf-8") + self.assertEqual(original.count(old), 1) + for optimized in (False, True): + target.write_text(original, encoding="utf-8") + baseline = self.grader.run_selected(root, test_id, optimized) + self.assertTrue(self.grader.baseline_ok(baseline, test_id), baseline) + target.write_text(original.replace(old, adverse, 1), encoding="utf-8") + result = self.grader.run_selected(root, test_id, optimized) + self.assertFalse(self.grader.qualified_kill(result, test_id), result) + self.assertEqual(result["failure_count"], 1) + self.assertEqual(result["error_count"], 0) + self.assertFalse(result["events"][0]["authorized"]) + self.assertTrue(any(frame["filename"].endswith(target_path) + for frame in result["events"][0]["frames"])) + print("FRESHNESS_REAL_SUBJECT " + json.dumps({ + "optimized": optimized, "test_id": test_id, + "baseline": baseline, "adverse": result, + }, sort_keys=True), flush=True) + + def test_helper_assertion_is_not_a_kill(self): + self.assertEqual(self.check_case("self.helper()"), [False, False]) + + def test_nested_callback_assertion_is_not_a_kill(self): + self.assertEqual(self.check_case("def callback():\n self.fail('nested assertion')\ncallback()"), [False, False]) + + def test_spoofed_unittest_filename_is_not_a_kill(self): + self.assertEqual(self.check_case("exec(compile(\"raise AssertionError('spoof')\", unittest.case.__file__, 'exec'))"), [False, False]) + + def test_setup_assertion_is_not_a_kill(self): + self.assertEqual(self.check_case("pass", setup="raise AssertionError('setup assertion')"), [False, False]) + + def test_teardown_assertion_is_not_a_kill(self): + self.assertEqual(self.check_case("pass", teardown="raise AssertionError('teardown assertion')"), [False, False]) + + def test_selected_failure_with_teardown_failure_is_not_a_kill(self): + self.assertEqual(self.check_case("self.assertEqual(1, 2)", teardown="raise AssertionError('teardown assertion')"), [False, False]) + + def test_ordinary_error_is_not_a_kill(self): + self.assertEqual(self.check_case("raise ValueError('runtime error')"), [False, False]) + + def test_skipped_test_is_not_a_kill(self): + self.assertEqual(self.check_case("self.skipTest('not executed')"), [False, False]) + + def test_failure_with_later_skip_is_not_a_kill(self): + self.assertEqual(self.check_case("with self.subTest(number=1):\n self.fail('body failure')\nself.skipTest('later skip')"), [False, False]) + + def test_corrupt_provenance_counts_are_refused(self): + self.assertTrue(hasattr(self.grader, "qualified_kill"), "missing provenance-aware classifier") + valid = {"protocol_error": False, "test_id": TEST_ID, "selected_id": TEST_ID, + "tests_run": 1, "failure_count": 1, "error_count": 0, "skip_count": 0, + "expected_failure_count": 0, "unexpected_success_count": 0, "child_exit": 1, + "events": [{"test_id": TEST_ID, "kind": "failure", "authorized": True}]} + self.assertTrue(self.grader.qualified_kill(valid, TEST_ID)) + for key, value in (("tests_run", True), ("failure_count", True), + ("error_count", False), ("child_exit", True)): + with self.subTest(key=key): + corrupted = dict(valid, **{key: value}) + self.assertFalse(self.grader.qualified_kill(corrupted, TEST_ID)) + + def test_non_object_provenance_is_refused(self): + for malformed in (None, [], "not a report", 1): + with self.subTest(malformed=malformed): + self.assertFalse(self.grader.qualified_kill(malformed, TEST_ID)) + self.assertFalse(self.grader.baseline_ok(malformed, TEST_ID)) + + +class MutationGuardSelfTests(unittest.TestCase): + def test_origin_and_classifier_mutants_fail_for_the_designated_oracle(self): + grader = load_grader() + original = GRADER.read_text(encoding="utf-8") + mutations = ( + ("ignore non-oracle frames", "and all(code in oracle for code, _ in tail))", "and True)", + "test_subject_assertion_is_not_a_kill"), + ("ignore authorization", "and event.get('authorized') is True", "and True", + "test_subject_assertion_is_not_a_kill"), + ("accept boolean counters", "all(type(result.get(key)) is int for key in count_keys)", "True", + "test_corrupt_provenance_counts_are_refused"), + ("ignore skips", "and result.get('skip_count') == 0", "and True", + "test_failure_with_later_skip_is_not_a_kill"), + ) + with tempfile.TemporaryDirectory(prefix="freshness-grader-mutants-") as tmp: + root = Path(tmp) + (root / "tests").mkdir() + (root / "tests/__init__.py").write_text("", encoding="utf-8") + shutil.copyfile(Path(__file__), root / "tests/test_node_status_mutation_grader.py") + target = root / "cbz/evidence/node-status-freshness/run_mutations.py" + target.parent.mkdir(parents=True) + for name, old, new, method in mutations: + with self.subTest(mutation=name): + self.assertEqual(original.count(old), 1, name) + test_id = "tests.test_node_status_mutation_grader.MutationOriginTests." + method + for optimized in (False, True): + target.write_text(original, encoding="utf-8") + baseline = grader.run_selected(root, test_id, optimized) + self.assertTrue(grader.baseline_ok(baseline, test_id), (name, optimized, baseline)) + target.write_text(original.replace(old, new, 1), encoding="utf-8") + mutated = grader.run_selected(root, test_id, optimized) + self.assertTrue(grader.qualified_kill(mutated, test_id), (name, optimized, mutated)) + print("FRESHNESS_GRADER_MUTATION " + json.dumps({ + "name": name, "optimized": optimized, "test_id": test_id, + "old": old, "new": new, "baseline": baseline, "mutated": mutated, + }, sort_keys=True), flush=True) + + +class WorkflowWiringTests(unittest.TestCase): + @staticmethod + def accepts(workflow): + try: + controls = workflow.split(" controls:\n", 1)[1].split("\n node-status-refresh:", 1)[0] + step = controls.split(" - name: Verify freshness mutation provenance\n", 1)[1] + step = step.split("\n - name:", 1)[0] + except IndexError: + return False + required_step = """\ + run: | + set -euo pipefail + mkdir -p "$RUNNER_TEMP/node-status-grader-evidence" + python3 -B -S -m unittest tests.test_node_status_mutation_grader -v > "$RUNNER_TEMP/node-status-grader-evidence/controls-normal.stdout" 2> "$RUNNER_TEMP/node-status-grader-evidence/controls-normal.stderr" + python3 -B -O -S -m unittest tests.test_node_status_mutation_grader -v > "$RUNNER_TEMP/node-status-grader-evidence/controls-optimized.stdout" 2> "$RUNNER_TEMP/node-status-grader-evidence/controls-optimized.stderr" + python3 -B -S cbz/evidence/node-status-freshness/run_mutations.py > "$RUNNER_TEMP/node-status-grader-evidence/mutations-normal.json" 2> "$RUNNER_TEMP/node-status-grader-evidence/mutations-normal.stderr" + python3 -B -O -S cbz/evidence/node-status-freshness/run_mutations.py > "$RUNNER_TEMP/node-status-grader-evidence/mutations-optimized.json" 2> "$RUNNER_TEMP/node-status-grader-evidence/mutations-optimized.stderr" +""" + return (" - 'tests/test_node_status_mutation_grader.py'\n" in workflow + and "continue-on-error:" not in controls + and step + "\n" == required_step + and "- name: Preserve freshness mutation evidence\n if: always()" in controls + and "if-no-files-found: error" in controls) + + def test_freshness_grader_checks_are_required_and_preserve_results(self): + workflow = (ROOT / ".github/workflows/current-site.yml").read_text(encoding="utf-8") + self.assertTrue(self.accepts(workflow)) + + def test_workflow_contract_refuses_bypasses(self): + workflow = (ROOT / ".github/workflows/current-site.yml").read_text(encoding="utf-8") + mutations = ( + ("missing trigger", " - 'tests/test_node_status_mutation_grader.py'\n", ""), + ("ignored failure", "mutations-normal.stderr\"\n", "mutations-normal.stderr\" || true\n"), + ("disabled step", " - name: Verify freshness mutation provenance\n", + " - name: Verify freshness mutation provenance\n if: false\n"), + ("missing errexit", " set -euo pipefail\n", ""), + ("allowed job failure", " controls:\n", " controls:\n continue-on-error: true\n"), + ("missing failure artifact", + "- name: Preserve freshness mutation evidence\n if: always()", + "- name: Preserve freshness mutation evidence\n if: success()"), + ) + for name, old, new in mutations: + with self.subTest(mutation=name): + self.assertEqual(workflow.count(old), 1) + self.assertFalse(self.accepts(workflow.replace(old, new, 1))) + + +if __name__ == "__main__": + unittest.main() From c65dc2d3ee52038a0804f6c7455ff8b5844d17ab Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 12:20:13 -0600 Subject: [PATCH 2/3] Record freshness provenance and current boundaries --- BASELINE.md | 14 ++++++++++ DECISIONS.md | 1 + GOVERNANCE.md | 13 ++++++++++ PROOF_INDEX.md | 10 ++++++++ STATUS.md | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++ TOOLING.md | 34 +++++++++++++++++++++++++ 6 files changed, 141 insertions(+) diff --git a/BASELINE.md b/BASELINE.md index 82d6b2cc6..10391669e 100644 --- a/BASELINE.md +++ b/BASELINE.md @@ -6,6 +6,20 @@ This ledger binds the currently observed repository snapshot to the twelve owner criteria and final gate matrix. It records evidence and gaps; it is not a completion certificate. +## Freshness provenance candidate — 9 November 2026 + +The sequential observed boundary is Main signed merge +`6ab126beda65e19865b8468b52f8757ac2324e1f`, Math- +`f532c3e2d91a0c7679a37c733741660917a9b21b`, and Workspace default +`a3e6552104d89917105a668a296121680a7f03bc`, which still pins the earlier +Main. Workspace #53 proposes the updated pin, but four hosted runs failed +before jobs and no current-tip integration is inferred. The isolated Main +freshness-grader repair and the precisely stale engineering record are +described in [STATUS.md](STATUS.md#freshness-provenance-repair-candidate--9-november-2026). +The old false mutation kill remains historical and cannot receive new +provenance credit. All twelve final criteria and a single current G0–G11 +pass remain unawarded; neither CBZ-0 nor terminal Partial is established. + ## Navigation history candidate — 9 November 2026 The sequential base is Main `5ebe5771d44160f56d4f2fd1e11726858d17dc90`, diff --git a/DECISIONS.md b/DECISIONS.md index ce26b2bdb..819083bf8 100644 --- a/DECISIONS.md +++ b/DECISIONS.md @@ -110,3 +110,4 @@ Append-only. Historical source outcomes remain in their original records. | 2026-11-09 07:24 | 2 | B/tooling | Recoverably retired the final thirteen documented historical research/browser drivers that the current G11 graph did not execute. Exact native blobs remain recoverable; every plan, report, preserved failure, authorship record and product source remains unchanged. Fresh pre-change normal and optimized censuses were byte-identical and failed only on those thirteen tools. Exact deletion-tree censuses are byte-identical and pass with 69 tools, zero unresolved tools and zero production findings. The auditor passes 263/263 controls and kills 328/328 designated mutants per mode. Complete discovery passes 2,459 tests in each mode with 25 explicit skips; this does not award full-regression 100%. The G11 component is closed only for this exact candidate tree; final federation G11 and CBZ-0 remain unawarded pending current integration, pins, other gates, cold start and one-pass G0--G11. No theorem, proof, bound, axiom, kernel outcome, historical failure, authorship or scientific status changed. | Yes | Base signed Main `848cd66bbf4a73e77a6f3e1fff64ce4796150f6d`, tree `2f48833cbd051545be1a7d383137c99e5fa57a12`; deletion commit `26bd26594c6bf7d1678ae0ea40483b61e07fac61`, tree `473cd9a018993327536c6510ac78122eb830020f`; baseline/deletion census SHA-256 `5ce8979ff1b0ba1a5c77aaefcf276d135f4cc3d4314a4a00d9756cd3d2260342` / `793a7f09cdafb40b22283d284722a495628c22b707631ae0e887b10fb123adc6`; mutation receipt SHA-256 `e73ecb9f1a31208d4a92dfc5359e11ea8c6de833ab0df1495cc3c5675f05b97e`; full log SHA-256 `1cf4c2d78b85a7317e8e60e15a6fc382cc538950c6dc9ad65b57859c8a27a411` / `0d0122b4080e969d1d0795dde8a912d95c6aa2c52f3726999bb66fe261fee6d3`; durable v138 status/evidence SHA-256 `1f61a595a7bbbc0e4a3c661c3f860e0355c3fbe7db8c9d810ca42e25cff6f059` / `3af309a2ca2f951e5cca74f5647776822bb0de7459b0575ea0e9b486faae169c`. | | 2026-11-09 08:24 | 2 | B/status | Bound all five canonical reading surfaces to the signed Main #777 / Workspace #51 serial integration boundary and independently read-back durable v139. The current Workspace gitlink exactly matches Main; the organization-visible open-PR search returned zero. Author-observed G11 component execution passes with 69 tools, zero unresolved or production findings, 263/263 controls and 328/328 designated mutant kills per mode. Complete discovery passes 2,459 tests per mode with 25 skips, so full-regression 100% remains false. Preserved the landed HTTP-504 failure on attempt 1 and successful targeted retry on the identical signed commit. No theorem, proof, quarantine, bound, axiom, authorship, failure, kernel outcome or scientific status changed; no independent review is invented and no CBZ criterion is awarded. A later Main merge requires another guarded Workspace pin refresh. | Yes | Main `ed5d83b7eff354cd7025117f4d2371422acd816b`, tree `87fdabafadfdb1ee2b766222b6d0c313de8d9a89`; Workspace `7019083126d3e9fb732447dee5c2895d8c5b7475`, tree `5d591958e516a582367deb4433cbedf300207d7d`; Math- `f532c3e2d91a0c7679a37c733741660917a9b21b`; durable v139 status/evidence SHA-256 `68c00bab7590630ddaae8f67e0d9e1dc081d5168bc65809b18cce5cf0518affc` / `02e6efe1360f2e2b93ea9c64687db14b6b610961ca93434d1527665461c0fbb0`; landed workflow `42581324023` attempts 1 and 2. | | 2026-11-09 17:33 | 2 | B/regression | Require full Main history and a separate no-skip execution of the two historical reader-source classes in the navigation workflow. The previously landed 2,459-test log records 37 skips, including twelve missing-history events; it remains preserved. The candidate shell block passed 20/20 on an actual full clone and rejected an actual depth-one clone with twelve skips. Focused controls passed 25/25 per mode. Nine designated workflow mutations per mode produced intended selected-body failures, with explicit helper/nested/subject-origin refusal controls. Earlier summary-spoofing false acceptances and the initial non-discriminating probe attempt remain recorded; no future hosted outcome is inferred. The existing full discovery and historical test contract remain. No theorem, proof, bound, axiom, authorship, historical failure or scientific status changed; all final criteria remain unawarded. Reversible in native Git; any later Main merge requires a guarded Workspace pin refresh. | Yes | Main base `5ebe5771d44160f56d4f2fd1e11726858d17dc90`; Workspace `a3e6552104d89917105a668a296121680a7f03bc`; workflow SHA-256 `fde0aab9cd82c5709f7970da2d5935a7cbeea2f1559725b4639fd5ad23a6c641`; landed artifact `13660495414`, SHA-256 `b2b93e4a1792fef2c994559baee9852927ed26f3a00484cd301eee99de0e6f5a`; qualification archive SHA-256 `6fa1b43e564baa27270e311f44b56cd2e580b2564c8253805789ab17f4c39fcf`. | +| 2026-11-09 18:16 | 2 | B/tooling, conflict | Preserve the real subject-origin false kill in the older node-status freshness mutation grader and require actual pre-cleanup selected-body/assertion provenance for future kills. Add adverse and workflow controls, retain all eleven original mutations, and keep the strict stale outcome visible. Correct the `eng.hard-gate` status and published projection after the read-only directory observation while preserving its original source pin. Local tests and exact limits are in STATUS and TOOLING; hosted integration remains unobserved. This changes no mathematical or scientific disposition. | Yes | Native source `9486c850d0c22fd1438e18fb392dbe02d7bd214f`, tree `d9a794488b34168cad49580a40460b44a5b33dfd`; local qualification archive SHA-256 `9e980d03e16d94716d62df10c00a39c88f0c0717b9de414d60a13ebc5b3d7411`; [A8 finding](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6747450269); [source observation](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6747623136); [Workspace checks](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6747829645). | diff --git a/GOVERNANCE.md b/GOVERNANCE.md index b16b6ffe6..d4db73414 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md @@ -18,6 +18,19 @@ Its team-model sections 1.5, 7.4 and 8 supersede older exclusive-owner and monitor-specific integration restrictions. Historical decisions retain their original timestamps and outcomes; the latest directive controls future action. +## Freshness mutation provenance candidate — 9 November 2026 + +An assertion is an admissible kill for the node-status freshness mutation +experiment only when the selected synchronous unittest case actually ran and +the pre-cleanup traceback identifies the selected body or explicitly captured +standard assertion code as the failure origin. Subject, helper, callback, +lifecycle, runtime, skip, malformed or incomplete outcomes do not qualify. +The prior grader's real subject-origin false kill remains recorded and its +historical results are not rebound. The new bounded control's purpose, +commands, verification and limits are registered in [TOOLING.md](TOOLING.md) +and its current observation in [STATUS.md](STATUS.md). These controls are not +an adversarial process sandbox or mathematical/scientific review. + ## Navigation history guard candidate — 9 November 2026 For history-backed reader checks, the navigation workflow must obtain the diff --git a/PROOF_INDEX.md b/PROOF_INDEX.md index e8d0a6664..d5f6409cd 100644 --- a/PROOF_INDEX.md +++ b/PROOF_INDEX.md @@ -8,6 +8,16 @@ into a kernel proof. A theorem is CLOSED only for the literal statement and allowed-axiom boundary actually checked. Anything else must remain OPEN or be placed in a complete dormant quarantine. +## Freshness repair proof boundary — 9 November 2026 + +The candidate described in +[STATUS.md](STATUS.md#freshness-provenance-repair-candidate--9-november-2026) +changes an engineering mutation grader and a stale engineering record. It does +not change, close, refute or rebind any theorem, hypothesis, axiom, bound, +quarantine, kernel result, historical mathematical statement or scientific +disposition. The retained original false kill concerns mutation evidence, +not the mathematical statements. + ## Navigation history candidate boundary — 9 November 2026 The candidate based on Main `5ebe5771d44160f56d4f2fd1e11726858d17dc90` diff --git a/STATUS.md b/STATUS.md index 86de9d886..a2e6a42c9 100644 --- a/STATUS.md +++ b/STATUS.md @@ -8,6 +8,75 @@ The inherited scientific material below is explicitly the 29 September snapshot, not a fresh CLOSED decision or an empirical-validation receipt. Its mathematical statements, source cuts and review limits are preserved. +## Freshness provenance repair candidate — 9 November 2026 + +Main #779 merged as signed `6ab126beda65e19865b8468b52f8757ac2324e1f`, +tree `df5509f1f25dc406bad95ab4b88c288300901a98`. This isolated repair +began from its tree-equivalent hosted parent `2d4403838f6d697e671834f12a9a87b379a93ad6`; +native source commit `9486c850d0c22fd1438e18fb392dbe02d7bd214f` has tree +`d9a794488b34168cad49580a40460b44a5b33dfd`. It is not yet an integrated +or hosted-qualified result. Workspace #53 is +open at `bd617949f349805b87f51ede2b793553f30c542f`, based on +`a3e6552104d89917105a668a296121680a7f03bc`, to pin Main `6ab126be…`. +Its local 187-test suites passed in both modes. Four hosted Workspace runs +`42671456239`, `42671456244`, `42672115232`, and `42672114965` +stopped before any job with GitHub internal-server annotations; targeted +retries of the first two were refused with HTTP 403. Those failures remain +evidence; they are not passing checks. Sequential tips are not atomic. + +The old node-status freshness mutation grader accepted a real subject-origin +`AssertionError` as a kill in both child modes. Its historical mutation +results are not retroactively provenance-qualified. The candidate captures +the actual traceback and code identities before unittest cleanup, accepts +only the selected test body or explicitly captured standard assertion code, +and rejects subject, helper, nested callback and lifecycle origins. The real +adverse subject replacement was refused in both modes while its baseline +passed. A malformed non-object report also exposed a classifier exception; +the candidate now refuses it. Local CPython 3.12.14 runs passed 20/20 focused +controls in each parent mode, including designated grader-guard mutations. +The extracted workflow block exited zero and observed 22/22 authorized kills +in each parent mode: eleven unchanged subject mutations in both child modes. +Each parent run also observed eight authorized detections of four grader-guard +mutations across both child modes. Separate existing subject/refresh/projection +controls passed 72/72 per mode. These are local, bounded observations, not +hosted checks or full regression. The source bundle, raw logs, original +failures and provenance are independently read back from +`libfile_fde3_f-0332e0543bcc819194e66f37fbd29b81_59a0f9f234e48191bc19fddcc0f80648`, +SHA-256 `9e980d03e16d94716d62df10c00a39c88f0c0717b9de414d60a13ebc5b3d7411`. +Hosted checks and integration must be inspected at the actual candidate head. + +The read-only command `python3 -B -S tools/node_status_refresh.py +records/node_status --check` observed Math- default +`f532c3e2d91a0c7679a37c733741660917a9b21b` on 9 November and exited 1: +the cited directory of `eng.hard-gate` changed from tree `715449bb…` +to `13272515…`. The other three records were fresh under the cited-content +contract. This candidate marks only that record and its published projection +stale while retaining the historical source pin. The strict freshness check +remains nonzero until the stale condition is resolved; it is not a proof or +scientific-status decision. The actual observation is retained in +`libfile_fde3_f-ca14368b86b88191ae1d95fae1baeeba_59a0f9f234e48191bc19fddcc0f80648`; +the original false-kill evidence is retained in +`libfile_fde3_f-606b8b159414819198b7a213ca93d32c_59a0f9f234e48191bc19fddcc0f80648`. +The site atlas tests passed 10/10 and both asset-release commands produced +digest `efff4cc5ef57e4ece003e919c7e9449cae97b7e539ffb515f819de4a2621ed3e`. + +For this bounded component run: + +```sh +python3 -B -S -m unittest tests.test_node_status_mutation_grader -v +python3 -B -O -S -m unittest tests.test_node_status_mutation_grader -v +python3 -B -S cbz/evidence/node-status-freshness/run_mutations.py +python3 -B -O -S cbz/evidence/node-status-freshness/run_mutations.py +python3 -B -S tools/node_status_refresh.py records/node_status --check +python3 -B tools/site_asset_release.py --check +``` + +The grader covers selected synchronous unittest cases and these explicit +mutation/oracle patterns; it is not a sandbox against a malicious child +process. It does not establish a full Layer A audit, complete regression, +Lean/kernel pass, final G7/G11, STATUS-only cold start, same-pass G0–G11, +scientific acceptance or CBZ-0. No terminal Partial is declared. + ## Navigation history candidate — 9 November 2026 The candidate starts from signed Main diff --git a/TOOLING.md b/TOOLING.md index 90eb8681b..c3a67f19a 100644 --- a/TOOLING.md +++ b/TOOLING.md @@ -9,6 +9,40 @@ preserved in their dated sections as history. Each entry states purpose, command, verification and scope. A component passing in isolation does not complete a CBZ gate or the final G0–G11 matrix. +## Node-status freshness origin guard candidate — 9 November 2026 + +**Purpose:** reject false mutation kills caused by failures in the subject, +helpers, nested callbacks or test lifecycle. The original eleven designated +mutations remain; the runner captures pre-cleanup unittest traceback code +identity, test identity, outcome and counts for each actual child execution. + +**Commands:** from this Main candidate checkout: + +```sh +python3 -B -S -m unittest tests.test_node_status_mutation_grader -v +python3 -B -O -S -m unittest tests.test_node_status_mutation_grader -v +python3 -B -S cbz/evidence/node-status-freshness/run_mutations.py +python3 -B -O -S cbz/evidence/node-status-freshness/run_mutations.py +``` + +**Verification:** the local CPython 3.12.14 focused suites passed 20/20 in +each parent mode. They exercise both child modes, a real subject-origin +adverse replacement, malformed counts and reports, failure/skip combinations, +workflow bypass attempts, and four designated grader-guard mutations. The +extracted workflow block exited zero: 22/22 authorized original-mutation +kills and eight authorized grader-guard detections were recorded per parent +mode, each covering both child modes. Hosted execution must be read at the +actual candidate head. The previous false-kill and strict freshness +observation are retained separately as identified in +[STATUS.md](STATUS.md#freshness-provenance-repair-candidate--9-november-2026). + +**Scope:** selected synchronous unittest cases and the named mutation and +oracle patterns. It is not a general mutation framework, a hostile-process +sandbox, a mathematical verifier or the final federation G0–G11 pass. The +workflow attempts to retain produced stdout, stderr and JSON on failure. The strictly +read-only freshness command is `python3 -B -S tools/node_status_refresh.py +records/node_status --check`; an observed stale record makes it exit nonzero. + ## Navigation history guard candidate — 9 November 2026 Purpose: ensure the existing history-backed reader-source checks actually run From 9bf048e9aeee3b846da92fba6e4d0708dee310e7 Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Mon, 9 Nov 2026 12:31:16 -0600 Subject: [PATCH 3/3] Record Workspace integration and hosted freshness evidence --- BASELINE.md | 13 +++++++++---- DECISIONS.md | 2 ++ GOVERNANCE.md | 4 ++++ PROOF_INDEX.md | 4 ++++ STATUS.md | 47 ++++++++++++++++++++++++++++++++++++++++------- TOOLING.md | 13 ++++++++----- 6 files changed, 67 insertions(+), 16 deletions(-) diff --git a/BASELINE.md b/BASELINE.md index 10391669e..81c3862b9 100644 --- a/BASELINE.md +++ b/BASELINE.md @@ -10,15 +10,20 @@ completion certificate. The sequential observed boundary is Main signed merge `6ab126beda65e19865b8468b52f8757ac2324e1f`, Math- -`f532c3e2d91a0c7679a37c733741660917a9b21b`, and Workspace default -`a3e6552104d89917105a668a296121680a7f03bc`, which still pins the earlier -Main. Workspace #53 proposes the updated pin, but four hosted runs failed -before jobs and no current-tip integration is inferred. The isolated Main +`f532c3e2d91a0c7679a37c733741660917a9b21b`, and signed Workspace merge +`2441baf051312878ca28e462d455cfbcd8e91b20`, pinning that Main. Workspace +#53 passed its exact-head jobs and merged normally; four prior hosted runs +failed before jobs and are preserved. The post-merge pins job passed, while +the post-merge federation run failed before jobs with a GitHub internal +server error and its failed-job retry was refused with HTTP 403. +These sequential observations are not final G7; a later Main merge will again +require a guarded Workspace pin update. The isolated Main freshness-grader repair and the precisely stale engineering record are described in [STATUS.md](STATUS.md#freshness-provenance-repair-candidate--9-november-2026). The old false mutation kill remains historical and cannot receive new provenance credit. All twelve final criteria and a single current G0–G11 pass remain unawarded; neither CBZ-0 nor terminal Partial is established. +This section supersedes older dated descriptions of current tips below. ## Navigation history candidate — 9 November 2026 diff --git a/DECISIONS.md b/DECISIONS.md index 819083bf8..909ff6434 100644 --- a/DECISIONS.md +++ b/DECISIONS.md @@ -111,3 +111,5 @@ Append-only. Historical source outcomes remain in their original records. | 2026-11-09 08:24 | 2 | B/status | Bound all five canonical reading surfaces to the signed Main #777 / Workspace #51 serial integration boundary and independently read-back durable v139. The current Workspace gitlink exactly matches Main; the organization-visible open-PR search returned zero. Author-observed G11 component execution passes with 69 tools, zero unresolved or production findings, 263/263 controls and 328/328 designated mutant kills per mode. Complete discovery passes 2,459 tests per mode with 25 skips, so full-regression 100% remains false. Preserved the landed HTTP-504 failure on attempt 1 and successful targeted retry on the identical signed commit. No theorem, proof, quarantine, bound, axiom, authorship, failure, kernel outcome or scientific status changed; no independent review is invented and no CBZ criterion is awarded. A later Main merge requires another guarded Workspace pin refresh. | Yes | Main `ed5d83b7eff354cd7025117f4d2371422acd816b`, tree `87fdabafadfdb1ee2b766222b6d0c313de8d9a89`; Workspace `7019083126d3e9fb732447dee5c2895d8c5b7475`, tree `5d591958e516a582367deb4433cbedf300207d7d`; Math- `f532c3e2d91a0c7679a37c733741660917a9b21b`; durable v139 status/evidence SHA-256 `68c00bab7590630ddaae8f67e0d9e1dc081d5168bc65809b18cce5cf0518affc` / `02e6efe1360f2e2b93ea9c64687db14b6b610961ca93434d1527665461c0fbb0`; landed workflow `42581324023` attempts 1 and 2. | | 2026-11-09 17:33 | 2 | B/regression | Require full Main history and a separate no-skip execution of the two historical reader-source classes in the navigation workflow. The previously landed 2,459-test log records 37 skips, including twelve missing-history events; it remains preserved. The candidate shell block passed 20/20 on an actual full clone and rejected an actual depth-one clone with twelve skips. Focused controls passed 25/25 per mode. Nine designated workflow mutations per mode produced intended selected-body failures, with explicit helper/nested/subject-origin refusal controls. Earlier summary-spoofing false acceptances and the initial non-discriminating probe attempt remain recorded; no future hosted outcome is inferred. The existing full discovery and historical test contract remain. No theorem, proof, bound, axiom, authorship, historical failure or scientific status changed; all final criteria remain unawarded. Reversible in native Git; any later Main merge requires a guarded Workspace pin refresh. | Yes | Main base `5ebe5771d44160f56d4f2fd1e11726858d17dc90`; Workspace `a3e6552104d89917105a668a296121680a7f03bc`; workflow SHA-256 `fde0aab9cd82c5709f7970da2d5935a7cbeea2f1559725b4639fd5ad23a6c641`; landed artifact `13660495414`, SHA-256 `b2b93e4a1792fef2c994559baee9852927ed26f3a00484cd301eee99de0e6f5a`; qualification archive SHA-256 `6fa1b43e564baa27270e311f44b56cd2e580b2564c8253805789ab17f4c39fcf`. | | 2026-11-09 18:16 | 2 | B/tooling, conflict | Preserve the real subject-origin false kill in the older node-status freshness mutation grader and require actual pre-cleanup selected-body/assertion provenance for future kills. Add adverse and workflow controls, retain all eleven original mutations, and keep the strict stale outcome visible. Correct the `eng.hard-gate` status and published projection after the read-only directory observation while preserving its original source pin. Local tests and exact limits are in STATUS and TOOLING; hosted integration remains unobserved. This changes no mathematical or scientific disposition. | Yes | Native source `9486c850d0c22fd1438e18fb392dbe02d7bd214f`, tree `d9a794488b34168cad49580a40460b44a5b33dfd`; local qualification archive SHA-256 `9e980d03e16d94716d62df10c00a39c88f0c0717b9de414d60a13ebc5b3d7411`; [A8 finding](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6747450269); [source observation](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6747623136); [Workspace checks](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6747829645). | +| 2026-11-09 18:28 | 2 | B/integration, conflict | Integrated Workspace #53 through fresh exact-head checks and normal expected-head merge. The tested tree became signed Workspace `2441baf051312878ca28e462d455cfbcd8e91b20`, pinning then-current Main `6ab126be…`. Preserve the four earlier zero-job internal-server failures and refused retries. Main #782's actual provenance artifact qualifies the bounded hosted component, while navigation failed before jobs and two other workflow runs reported internal errors despite successful individual jobs. Preserve each outcome and require fresh current-head checks; no bypass or final-gate claim. | Yes | Workspace tested tree `13dd6b73201627177c568cb4233a33fb60acbbab`; hosted artifact SHA-256 `478e130f46398aa00756f4b78692a8a34e6897eda4d2ceb63bba43b74e71c303`; read-back supplement SHA-256 `528f5686c2ef37c214142d5d2ab00a2a4b8a5642aae320a5304002abbde464ce`; [board result](https://github.com/d6g8k5htny-coder/main/issues/738#issuecomment-6748069485). | +| 2026-11-09 18:30 | 2 | B/CI | The post-merge Workspace pins job passed eight network and strict-current pins, four canonical inputs and 187 tests. The post-merge federation workflow failed before any job with GitHub internal-server correlation `63dc5ffa-474e-4405-925b-574e391c43c6`; GitHub refused its failed-job retry with HTTP 403. Preserve both outcomes, do not infer a passing post-merge federation run, and continue other authorized checks. | Yes | Workspace pins run `42674111147`, job `129351557433`; federation run `42674110867`. | diff --git a/GOVERNANCE.md b/GOVERNANCE.md index d4db73414..0393c631d 100644 --- a/GOVERNANCE.md +++ b/GOVERNANCE.md @@ -30,6 +30,10 @@ historical results are not rebound. The new bounded control's purpose, commands, verification and limits are registered in [TOOLING.md](TOOLING.md) and its current observation in [STATUS.md](STATUS.md). These controls are not an adversarial process sandbox or mathematical/scientific review. +Workspace #53's guarded merge pins the then-current Main `6ab126be…`; +the newer Main freshness repair remains a draft. Later integration must use +fresh heads and normal required checks, preserving the recorded platform +failures. Older dated descriptions of current tips below are historical. ## Navigation history guard candidate — 9 November 2026 diff --git a/PROOF_INDEX.md b/PROOF_INDEX.md index d5f6409cd..8c5538918 100644 --- a/PROOF_INDEX.md +++ b/PROOF_INDEX.md @@ -18,6 +18,10 @@ quarantine, kernel result, historical mathematical statement or scientific disposition. The retained original false kill concerns mutation evidence, not the mathematical statements. +The current sequential Workspace merge `2441baf0…` pins Main `6ab126be…`; +the freshness repair remains a separate Main draft. This observation +supersedes older dated descriptions of current tips below. + ## Navigation history candidate boundary — 9 November 2026 The candidate based on Main `5ebe5771d44160f56d4f2fd1e11726858d17dc90` diff --git a/STATUS.md b/STATUS.md index a2e6a42c9..b218341e4 100644 --- a/STATUS.md +++ b/STATUS.md @@ -14,15 +14,25 @@ Main #779 merged as signed `6ab126beda65e19865b8468b52f8757ac2324e1f`, tree `df5509f1f25dc406bad95ab4b88c288300901a98`. This isolated repair began from its tree-equivalent hosted parent `2d4403838f6d697e671834f12a9a87b379a93ad6`; native source commit `9486c850d0c22fd1438e18fb392dbe02d7bd214f` has tree -`d9a794488b34168cad49580a40460b44a5b33dfd`. It is not yet an integrated -or hosted-qualified result. Workspace #53 is -open at `bd617949f349805b87f51ede2b793553f30c542f`, based on -`a3e6552104d89917105a668a296121680a7f03bc`, to pin Main `6ab126be…`. -Its local 187-test suites passed in both modes. Four hosted Workspace runs +`d9a794488b34168cad49580a40460b44a5b33dfd`. Draft Main #782 hosted head +`c65dc2d3ee52038a0804f6c7455ff8b5844d17ab` tested synthetic merge +`0f76c40fac38af52aed6b32693bb3e1c6ea902d3`, tree +`cfc7bca8d65eec3592e22be0530ddbdcc406f134`; it is not yet integrated. + +Workspace #53 merged as signed `2441baf051312878ca28e462d455cfbcd8e91b20`, +tree `13dd6b73201627177c568cb4233a33fb60acbbab`, pinning Main `6ab126be…`. +Its exact-head federation job ran 187 tests per mode; its pins job ran 187 +tests, eight network and strict-current pin checks, and four canonical-input +checks. Post-merge pins job `129351557433` passed eight network and +strict-current pins, four canonical inputs and 187 tests. Post-merge +federation run `42674110867` failed before jobs with GitHub internal-server +correlation `63dc5ffa-474e-4405-925b-574e391c43c6`; its failed-job retry +was refused with HTTP 403. Four earlier hosted Workspace runs `42671456239`, `42671456244`, `42672115232`, and `42672114965` stopped before any job with GitHub internal-server annotations; targeted retries of the first two were refused with HTTP 403. Those failures remain evidence; they are not passing checks. Sequential tips are not atomic. +This section supersedes older dated descriptions of current tips below. The old node-status freshness mutation grader accepted a real subject-origin `AssertionError` as a kill in both child modes. Its historical mutation @@ -39,11 +49,30 @@ in each parent mode: eleven unchanged subject mutations in both child modes. Each parent run also observed eight authorized detections of four grader-guard mutations across both child modes. Separate existing subject/refresh/projection controls passed 72/72 per mode. These are local, bounded observations, not -hosted checks or full regression. The source bundle, raw logs, original +full regression. The source bundle, raw logs, original failures and provenance are independently read back from `libfile_fde3_f-0332e0543bcc819194e66f37fbd29b81_59a0f9f234e48191bc19fddcc0f80648`, SHA-256 `9e980d03e16d94716d62df10c00a39c88f0c0717b9de414d60a13ebc5b3d7411`. -Hosted checks and integration must be inspected at the actual candidate head. +The hosted current-site controls job `129350315907` also passed on the tested +merge. Its downloaded artifact `13700485135`, SHA-256 +`478e130f46398aa00756f4b78692a8a34e6897eda4d2ceb63bba43b74e71c303`, +contains the eight expected files: 20 controls, eight guard detections and +22/22 original-mutation kills in each parent mode, with real subject-origin +refusals in both child modes. This observed component is not final G0 or G6. +The exact native composed-tree G11 censuses passed in both modes with 69 tools, +zero failing tools and zero skips; that is not the final federation G11 gate. +The full local regressions were still running. Inspect all checks at any later +candidate head. + +The hosted navigation workflow `42673203393` failed before jobs with a +GitHub internal-server annotation; its failed-job retry was refused with +HTTP 403. Public-shop `42673202992` and federation-drift `42673203388` +also reported workflow failure with internal-server annotations even though +their individual jobs succeeded. Do not erase or turn these failures into +passing workflow checks. The hosted artifact, full job logs, actual strict +refresh, Workspace merge and failed-run records were independently read back +from `libfile_fde3_f-e95f98760b048191833a8514e364aab2_59a0f9f234e48191bc19fddcc0f80648`, +SHA-256 `528f5686c2ef37c214142d5d2ab00a2a4b8a5642aae320a5304002abbde464ce`. The read-only command `python3 -B -S tools/node_status_refresh.py records/node_status --check` observed Math- default @@ -59,6 +88,10 @@ the original false-kill evidence is retained in `libfile_fde3_f-606b8b159414819198b7a213ca93d32c_59a0f9f234e48191bc19fddcc0f80648`. The site atlas tests passed 10/10 and both asset-release commands produced digest `efff4cc5ef57e4ece003e919c7e9449cae97b7e539ffb515f819de4a2621ed3e`. +After the record correction, a second actual strict observation ran +18:25:16–18:26:26 UTC with no input drift and again exited 1: the corrected +record remained stale, and the other three records remained fresh under the +cited-content contract. The report is in the hosted evidence supplement. For this bounded component run: diff --git a/TOOLING.md b/TOOLING.md index c3a67f19a..129b05a85 100644 --- a/TOOLING.md +++ b/TOOLING.md @@ -4,7 +4,7 @@ This file lists runnable mission-relevant tools present in Main. The current documentation candidate is based on signed Main -`ed5d83b7eff354cd7025117f4d2371422acd816b`; older source-parent bindings are +`6ab126beda65e19865b8468b52f8757ac2324e1f`; older source-parent bindings are preserved in their dated sections as history. Each entry states purpose, command, verification and scope. A component passing in isolation does not complete a CBZ gate or the final G0–G11 matrix. @@ -31,16 +31,19 @@ adverse replacement, malformed counts and reports, failure/skip combinations, workflow bypass attempts, and four designated grader-guard mutations. The extracted workflow block exited zero: 22/22 authorized original-mutation kills and eight authorized grader-guard detections were recorded per parent -mode, each covering both child modes. Hosted execution must be read at the -actual candidate head. The previous false-kill and strict freshness +mode, each covering both child modes. Hosted current-site job `129350315907` +also passed, and artifact `13700485135` independently exposed the same +20-control, eight-guard and 22-kill counts per parent mode with both real +subject-origin refusals. These apply to tested merge `0f76c40f…` only; +later candidate heads require fresh checks. The previous false-kill and strict freshness observation are retained separately as identified in [STATUS.md](STATUS.md#freshness-provenance-repair-candidate--9-november-2026). **Scope:** selected synchronous unittest cases and the named mutation and oracle patterns. It is not a general mutation framework, a hostile-process sandbox, a mathematical verifier or the final federation G0–G11 pass. The -workflow attempts to retain produced stdout, stderr and JSON on failure. The strictly -read-only freshness command is `python3 -B -S tools/node_status_refresh.py +workflow attempts to retain produced stdout, stderr and JSON on failure. +The strictly read-only freshness command is `python3 -B -S tools/node_status_refresh.py records/node_status --check`; an observed stale record makes it exit nonzero. ## Navigation history guard candidate — 9 November 2026