#!/usr/bin/env python3 """Verify the public release, and ship with the package. Needs Python 3.9 or later and nothing else - no third-party packages. Invoke it with whichever launcher your system has: `py`, `python3` or `python`. Most checks here are ones a third party can run on the published files. Checks 1 and 2 are not: they need the evaluation pool, the frozen manifest and the id-to-name mapping, none of which is distributed, and they report SKIPPED without them. Hashes are computed with the semantics the harness used - sha256 over the UTF-8 encoding of the string, no normalisation - so a mismatch is a real finding rather than an encoding artefact. Checks: 1 authority file hashes to the source_sha256 the frozen manifest recorded 2 every published prompt is byte-identical to the evaluated prompt 3 both published hashes recompute from the published prompt for every row, under each arm's rendering rule (local template for base/tuned; system+user for frontier) 4 each item maps to exactly three result rows: one base, one tuned, one frontier 5 the public rows reproduce every published table: 2/184, 170/184, 179/184, the base-vs-tuned contingency table and the tuned-vs-frontier paired table 6 substituting into the published template reproduces prompt_sha256 for every local-arm row 7 every SHA-256 quoted in the card is one the release stands behind 8 every checksum-manifest entry recomputes from the shipped files 9 the three v1.1 row files carry the row count, the arm ids and the per-arm row counts the card publishes 10 every published headline count falls out of the rows under the pre-registered scoring rule: a pass is verdict_headline true AND truncated false 11 every published per-arm truncation count falls out of the rows 12 the arms of a row file cover one and the same item set, once each 13 corpus_row_hashes.json carries 219,867 row hashes and agrees with its own count D diagnostic: do the sealed spec_sha256 / prompt_sha256 reproduce from the prompt? Checks 9 to 13 need nothing but the published files. They run on the holdout rows even though the holdout prompts are private: the arithmetic of an attested result is still arithmetic, and it is the only thing about the holdouts a reader can check. Checks 1 and 2 need the evaluation pool, the frozen manifest and the id-to-name mapping. None of those is distributed, so for a public reader they report SKIPPED and the run continues. Checks 3 through 8 need nothing but the published files. Check 6 is not redundant with check 3. Check 3 renders the prompt with this file's own format_local_prompt; check 6 renders it the way a reader does, by substituting into the template published in serving_template.json. They agree only if the published template is correct - and it once was not. Exit 0 all checks pass, 2 a check failed, 3 an input was missing or unreadable. Usage: python3 verify_public_release.py --public . With the undistributed inputs to hand, checks 1 and 2 also run: python3 verify_public_release.py --public --private \ --authority --manifest """ from __future__ import annotations import argparse import hashlib import json import re import sys from collections import defaultdict from pathlib import Path MANIFEST_NAME = "SHA256SUMS.txt" SYSTEM_PROMPT = ( "You are an expert MQL5 programmer. Write the complete MQL5 " "Expert Advisor code that implements the given specification exactly." ) EXPECTED = {"n": 184, "base": 2, "tuned": 170, "a": 1, "b": 1, "c": 169, "d": 13} # The frontier arm and its pairing against the tuned arm, added 2026-09-02. EXPECTED_FRONTIER = {"n": 184, "frontier": 179, "both_pass": 168, "tuned_only": 2, "frontier_only": 11, "both_fail": 3} CORPUS_NAME = "corpus_row_hashes.json" EXPECTED_CORPUS_ROWS = 219867 # Every count the card publishes for the v1.1 row files, keyed by file and arm. # `passes` is the headline figure under the pre-registered rule below; it is NOT a # count of rows whose verdict_headline is true. On the 220k arm of the non-EA holdout # the two differ by one - a row compiled despite being truncated - and that single # item is why the rule is stated here rather than assumed. EXPECTED_ROW_FILES = { "holdout_ea300_results.jsonl": { "rows": 1200, "items": 300, "item_key": "item_sha256", "arms": { "base": {"rows": 300, "passes": 1, "truncated": 3}, "tuned83k": {"rows": 300, "passes": 281, "truncated": 0}, "tuned220k": {"rows": 300, "passes": 282, "truncated": 0}, "frontier": {"rows": 300, "passes": 286, "truncated": 4}, }, }, "holdout_nonea200_results.jsonl": { "rows": 800, "items": 200, "item_key": "item_sha256", "arms": { "base": {"rows": 200, "passes": 56, "truncated": 14}, "tuned83k": {"rows": 200, "passes": 135, "truncated": 13}, "tuned220k": {"rows": 200, "passes": 168, "truncated": 12}, "tuned220k_q8_replay": {"rows": 200, "passes": 169, "truncated": 11}, }, }, "bridge_q8_184_results.jsonl": { "rows": 552, "items": 184, "item_key": "item_id", "arms": { "base": {"rows": 184, "passes": 2, "truncated": 2}, "tuned83k": {"rows": 184, "passes": 175, "truncated": 0}, "tuned220k": {"rows": 184, "passes": 169, "truncated": 0}, }, }, } def scored_pass(row: dict) -> bool: """The pre-registered scoring rule, and the whole of it: a generation cut off at the token ceiling counts as a fail even if what it produced happened to compile.""" return row.get("verdict_headline") is True and row.get("truncated") is not True def format_api_prompt(system: str, spec: str) -> str: """Canonical rendering of the frontier arm's system+user pair. The vendor API takes the two as separate fields; the frontier rows' prompt_sha256 hashes this single-string rendering of them.""" return f"{system}\n\n{spec}" def sha256_text(text: str) -> str: """Byte-for-byte the harness's hash rule: sha256 over the UTF-8 encoding.""" return hashlib.sha256(text.encode("utf-8")).hexdigest() def sha256_file(path: Path) -> str: h = hashlib.sha256() with path.open("rb") as fh: for chunk in iter(lambda: fh.read(1 << 20), b""): h.update(chunk) return h.hexdigest() def read_jsonl(path: Path): with path.open("r", encoding="utf-8") as fh: for lineno, line in enumerate(fh, 1): line = line.strip() if not line: continue try: yield json.loads(line) except json.JSONDecodeError as exc: raise SystemExit(f"{path}:{lineno}: {exc}") def format_local_prompt(spec: str) -> str: """The serving template, rendered exactly as the harness rendered it.""" return ( f"<|system|>{SYSTEM_PROMPT}<|end|>\n" f"<|user|>{spec}<|end|>\n" f"<|assistant|>" ) def main(argv: list[str]) -> int: ap = argparse.ArgumentParser(description=__doc__) # Only --public is required. The authority pool, the frozen manifest and the id-to-name # mapping are not distributed, so a public reader has none of them; requiring any of # them made the script exit before check 3 and the release was not runnable by anyone # outside. Checks 3, 4 and 5 need nothing but the published files, and they are the # checks that matter to a reader: the hashes recompute, the pairing is one-to-one, and # the headline falls out of the rows. ap.add_argument("--public", type=Path, required=True) ap.add_argument("--private", type=Path, help="holds item_id_mapping.jsonl; not distributed, so check 2 skips") ap.add_argument("--authority", type=Path, help="the evaluation pool; not distributed, so check 1 skips") ap.add_argument("--manifest", type=Path, help="the frozen manifest; not distributed, so check 1 skips") ap.add_argument("--sealed-rows", type=Path, help="the sealed base-arm results file (not distributed), " "for the reproduction diagnostic") args = ap.parse_args(argv) failures: list[str] = [] notes: list[str] = [] # ---- check 1 ----------------------------------------------------------------- # Runs only when the pool and the frozen manifest are both to hand. Neither ships, so # for a public reader this reports SKIPPED and the run continues. have_authority = args.authority is not None and args.authority.is_file() have_manifest = args.manifest is not None and args.manifest.is_file() authority: dict[str, str] = {} if have_authority and have_manifest: manifest = json.loads(args.manifest.read_text(encoding="utf-8")) actual = sha256_file(args.authority) if actual == manifest["source_sha256"]: print(f" [1] authority sha256 matches the frozen manifest {actual[:16]}...") else: failures.append( f"[1] authority sha256 {actual} != manifest source_sha256 " f"{manifest['source_sha256']}" ) # The authority is the only source of prompt text. Published prompts are checked # against it rather than the other way round. for rec in read_jsonl(args.authority): name = rec.get("ea_name") if name is not None: authority[name] = rec["prompt"] else: print(" [1] SKIPPED - needs the evaluation pool and the frozen manifest, " "neither of which is distributed") # Checks 3-8 verify the PUBLIC release, so they read the public prompts file # unconditionally. An earlier version fell back between the two, which meant a # present --private copy silently substituted for the release copy and the # verifier could pass a public file that no longer matched its results. public_prompts = args.public / "prompts.jsonl" if not public_prompts.is_file(): print(f"MISSING: prompts.jsonl in {args.public}") return 3 published = list(read_jsonl(public_prompts)) # ---- check 2 ----------------------------------------------------------------- # Needs the id-to-name mapping, which is not distributed. A public reader gets a # clear SKIPPED rather than a crash; internally the mapping is present and it runs. id_to_name: dict[str, str] = {} mapping_path = args.private / "item_id_mapping.jsonl" if args.private else None if mapping_path is not None and mapping_path.is_file(): id_to_name = {r["item_id"]: r["ea_name"] for r in read_jsonl(mapping_path)} if not id_to_name or not authority: print(" [2] SKIPPED - needs the evaluation pool and the id-to-name mapping, " "neither of which is distributed") else: mismatched = [ r["item_id"] for r in published if authority.get(id_to_name.get(r["item_id"], "")) != r["prompt"] ] if mismatched: failures.append( f"[2] {len(mismatched)} published prompt(s) differ from the evaluated " f"prompt" ) else: print(f" [2] all {len(published)} published prompts are byte-identical to " f"the evaluated prompt") # ---- check 3 ----------------------------------------------------------------- # The check any reader can run with nothing but the published files. public_hash = {r["item_id"]: sha256_text(r["prompt"]) for r in published} results_path = args.public / "per_item_results.jsonl" if not results_path.is_file(): # The docstring's exit-3 contract for missing inputs, honoured here too — # without this a missing results file was an uncaught traceback. print(f"MISSING: per_item_results.jsonl in {args.public}") return 3 rows = list(read_jsonl(results_path)) prompt_by_id = {p["item_id"]: p["prompt"] for p in published} # The published prompt_sha256 per item for the LOCAL arms, for check 6 to compare a # reader-built template render to. Frontier rows hash a different rendering (the # API's system+user pair) and are checked under that rule in check 3. by_id_hash = {r["item_id"]: r.get("prompt_sha256") for r in rows if r.get("arm") != "frontier"} hash_bad = [ r["item_id"] for r in rows if public_hash.get(r["item_id"]) != r.get("prompt_sha256_public") ] tmpl_bad_rows = [] for r in rows: if r["item_id"] not in prompt_by_id: continue prompt = prompt_by_id[r["item_id"]] want = (format_api_prompt(SYSTEM_PROMPT, prompt) if r.get("arm") == "frontier" else format_local_prompt(prompt)) if sha256_text(want) != r.get("prompt_sha256"): tmpl_bad_rows.append(r["item_id"]) if hash_bad: failures.append(f"[3] prompt_sha256_public does not recompute for " f"{len(set(hash_bad))} item(s)") elif tmpl_bad_rows: failures.append(f"[3] prompt_sha256 does not recompute from the published " f"serving template for {len(set(tmpl_bad_rows))} item(s)") else: print(f" [3] both published hashes recompute from the published prompt for all " f"{len(public_hash)} items ({len(rows)} rows)") # ---- check 4 ----------------------------------------------------------------- by_item: dict[str, list[dict]] = defaultdict(list) for r in rows: by_item[r["item_id"]].append(r) bad = { i: sorted(x["arm"] for x in v) for i, v in by_item.items() if sorted(x["arm"] for x in v) != ["base", "frontier", "tuned"] } if bad: failures.append(f"[4] {len(bad)} item(s) do not map to exactly one base, one " f"tuned and one frontier row: {list(bad.items())[:3]}") else: print(f" [4] all {len(by_item)} items map to exactly one base, one tuned and " f"one frontier row") # ---- check 5 ----------------------------------------------------------------- # The headline is a claim about verdict_headline, so it is measured on that field. # The two verdict fields can and do diverge - warnings fail strict but not headline, # and some frontier rows show exactly that - so the divergence is counted and printed # below rather than assumed away, and the tables are measured on verdict_headline # only. An earlier version read verdict_strict and got away with it only while the # two happened to agree. disagree = [ i for i, v in by_item.items() if any(x["verdict_headline"] != x["verdict_strict"] for x in v) ] if disagree: notes.append(f"[5] NOTE: verdict_headline and verdict_strict disagree on " f"{len(disagree)} item-arm row(s); the headline below is measured on " f"verdict_headline") else: notes.append(f"[5] verdict_headline and verdict_strict agree on all " f"{len(rows)} rows") a = b = c = d = 0 fp = f_both_pass = f_tuned_only = f_frontier_only = f_both_fail = 0 for v in by_item.values(): base = next(x for x in v if x["arm"] == "base")["verdict_headline"] tuned = next(x for x in v if x["arm"] == "tuned")["verdict_headline"] frontier = next(x for x in v if x["arm"] == "frontier")["verdict_headline"] if base and tuned: a += 1 elif base and not tuned: b += 1 elif tuned: c += 1 else: d += 1 if frontier: fp += 1 if tuned and frontier: f_both_pass += 1 elif tuned: f_tuned_only += 1 elif frontier: f_frontier_only += 1 else: f_both_fail += 1 got = {"n": len(by_item), "base": a + b, "tuned": a + c, "a": a, "b": b, "c": c, "d": d} got_frontier = {"n": len(by_item), "frontier": fp, "both_pass": f_both_pass, "tuned_only": f_tuned_only, "frontier_only": f_frontier_only, "both_fail": f_both_fail} if got == EXPECTED and got_frontier == EXPECTED_FRONTIER: print(f" [5] headline reproduces from the public rows: base {got['base']}/" f"{got['n']}, tuned {got['tuned']}/{got['n']}, frontier " f"{fp}/{got['n']}, a={a} b={b} c={c} d={d}; tuned-vs-frontier " f"{f_both_pass}/{f_tuned_only}/{f_frontier_only}/{f_both_fail}") else: failures.append(f"[5] headline does not reproduce. expected {EXPECTED} + " f"{EXPECTED_FRONTIER}, got {got} + {got_frontier}") # ---- check 6 ----------------------------------------------------------------- # The reader's path, and the reason this check exists. Checks 3 renders the prompt # with format_local_prompt, a function compiled into this script. A reader has no such # function: they parse serving_template.json, substitute the two placeholders, and # hash. Those are different routes to the same string only if the published template # is right. It once was not - the template field held the two-character sequence # backslash-n where a newline belonged, so every reader-side hash disagreed while # check 3 passed. A check that shares the harness's own definition cannot see that. template_path = args.public / "serving_template.json" if not template_path.is_file(): failures.append("[6] serving_template.json is missing from the public release") else: tmpl = json.loads(template_path.read_text(encoding="utf-8")) sys_prompt = tmpl["system_prompt"] if sha256_text(sys_prompt) != tmpl["system_prompt_sha256"]: failures.append("[6] the published system prompt does not match its own " "published hash") rendered_bad = [ r["item_id"] for r in published if sha256_text( tmpl["template"].replace("{system_prompt}", sys_prompt) .replace("{prompt}", r["prompt"]) ) != by_id_hash.get(r["item_id"]) ] if rendered_bad: failures.append( f"[6] substituting into the published template does not reproduce " f"prompt_sha256 for {len(set(rendered_bad))} item(s). A reader following " f"serving_template.json cannot reproduce our hashes." ) else: print(f" [6] substituting into the published template reproduces " f"prompt_sha256 for all {len(published)} items") # ---- check 7 ----------------------------------------------------------------- # Every 64-hex string in README.md must be a hash the release actually stands behind. # The card quotes file hashes in prose and in a table, and those are hand-carried from # the metadata when the card is written - so they go stale the moment any file is # regenerated. That happened: the card published a serving_template.json hash from an # earlier build while the manifest, the metadata and the projection report all agreed # on a different one. Nothing caught it, because nothing was comparing the two. readme = args.public / "README.md" manifest_file = args.public / MANIFEST_NAME if readme.is_file() and manifest_file.is_file(): known: set[str] = set() for line in manifest_file.read_text(encoding="utf-8").splitlines(): digest = line.split(" ")[0].strip() if len(digest) == 64: known.add(digest) # Hashes the release legitimately quotes that are not file hashes: model weights, # the corpus, the adapter, the evaluation pool, the normaliser source. Those live # in publication_metadata.json, so that file is the second authority. # serving_template.json is a third authority: it carries the system-prompt hash # and the worked example, which are legitimately quoted in the card and appear in # neither the manifest nor the metadata. authorities = "".join( (args.public / n).read_text(encoding="utf-8") for n in ("publication_metadata.json", "serving_template.json", "PROJECTION_REPORT.json") if (args.public / n).is_file() ) stale = sorted({ h for h in re.findall(r"\b[0-9a-f]{64}\b", readme.read_text(encoding="utf-8")) if h not in known and h not in authorities }) if stale: failures.append( f"[7] README.md quotes {len(stale)} sha256 value(s) that appear in none " f"of {MANIFEST_NAME}, publication_metadata.json, serving_template.json " f"or PROJECTION_REPORT.json, so the card disagrees with the release: " f"{stale[:3]}" ) else: print(" [7] every sha256 quoted in the card is one the release stands behind") else: # A copy missing the card or the manifest must not verify. Without this branch # the check was silently skipped and a damaged copy printed ALL CHECKS PASSED. absent = [n for n, f in (("README.md", readme), (MANIFEST_NAME, manifest_file)) if not f.is_file()] failures.append(f"[7] cannot run: missing {', '.join(absent)}") # ---- check 8 ----------------------------------------------------------------- # Recompute the manifest. Check 7 reads SHA256SUMS.txt to learn which hashes the # release stands behind, but never hashes a file - so a modified LICENSE or # CITATION.cff passed the verifier untouched while the card said the verifier checks # the release package. Third parties do not all have sha256sum, and telling them to # run a tool this script could run itself is not verification. if manifest_file.is_file(): listed: dict[str, str] = {} for line in manifest_file.read_text(encoding="utf-8").splitlines(): if not line.strip(): continue digest, _, name = line.partition(" ") if len(digest.strip()) == 64 and name.strip(): listed[name.strip()] = digest.strip() bad, missing = [], [] for name, want in sorted(listed.items()): f = args.public / name if not f.is_file(): missing.append(name) elif sha256_file(f) != want: bad.append(name) present = {p.name for p in args.public.iterdir() if p.is_file()} unlisted = sorted(present - set(listed) - {MANIFEST_NAME}) if bad or missing: failures.append( f"[8] manifest reconciliation FAILED: {len(bad)} file(s) do not match " f"their recorded hash {bad[:3]}, {len(missing)} listed file(s) absent " f"{missing[:3]}" ) elif unlisted: failures.append( f"[8] {len(unlisted)} file(s) in the release are not listed in " f"{MANIFEST_NAME}: {unlisted[:5]}" ) else: print(f" [8] all {len(listed)} manifest entries recompute, and the only " f"unlisted file is {MANIFEST_NAME}, which cannot list itself") else: # Same rule as check 7: a copy with no manifest is unverifiable, not verified. failures.append(f"[8] cannot run: {MANIFEST_NAME} is missing") # ---- checks 9-12 ------------------------------------------------------------- # The v1.1 row files. These ship, so a missing one is a failure and never a skip: # the card's headline tables are computed from them and a reader who cannot find # them cannot check a single holdout number. loaded: dict[str, list[dict]] = {} for fname in EXPECTED_ROW_FILES: path = args.public / fname if path.is_file(): loaded[fname] = list(read_jsonl(path)) else: failures.append(f"[9] {fname} is missing from the public release") shape_bad, pass_bad, trunc_bad, pair_bad = [], [], [], [] for fname, want in EXPECTED_ROW_FILES.items(): rows = loaded.get(fname) if rows is None: continue key = want["item_key"] by_arm: dict[str, list[dict]] = defaultdict(list) for r in rows: by_arm[r.get("arm")].append(r) if len(rows) != want["rows"]: shape_bad.append(f"{fname}: {len(rows)} rows, expected {want['rows']}") if sorted(by_arm) != sorted(want["arms"]): shape_bad.append(f"{fname}: arm ids {sorted(by_arm)}, expected " f"{sorted(want['arms'])}") for arm, cell in want["arms"].items(): got_rows = by_arm.get(arm, []) if len(got_rows) != cell["rows"]: shape_bad.append(f"{fname}/{arm}: {len(got_rows)} rows, expected " f"{cell['rows']}") continue got_pass = sum(1 for r in got_rows if scored_pass(r)) if got_pass != cell["passes"]: pass_bad.append(f"{fname}/{arm}: {got_pass}/{len(got_rows)} passes, " f"expected {cell['passes']}") got_trunc = sum(1 for r in got_rows if r.get("truncated") is True) if got_trunc != cell["truncated"]: trunc_bad.append(f"{fname}/{arm}: {got_trunc} truncated, expected " f"{cell['truncated']}") # One item set, once per arm. A duplicate key inside an arm and a key present # in one arm but not another are different faults, so both are named. reference = None for arm in sorted(want["arms"]): keys = [r.get(key) for r in by_arm.get(arm, [])] unique = set(keys) if len(unique) != len(keys): pair_bad.append(f"{fname}/{arm}: {len(keys) - len(unique)} duplicate " f"{key} value(s)") if len(unique) != want["items"]: pair_bad.append(f"{fname}/{arm}: {len(unique)} distinct {key}, " f"expected {want['items']}") if reference is None: reference = unique elif unique != reference: pair_bad.append(f"{fname}/{arm}: its {key} set differs from the first " f"arm's by {len(unique ^ reference)} value(s)") for tag, label, problems in ( (9, "row counts and arm ids", shape_bad), (10, "headline counts under the pre-registered scoring rule", pass_bad), (11, "per-arm truncation counts", trunc_bad), (12, "item pairing across arms", pair_bad)): if problems: failures.append(f"[{tag}] {label} do not reproduce: {problems[:3]}") elif loaded: print(f" [{tag}] {label} reproduce for all {len(loaded)} v1.1 row files") # ---- check 13 ---------------------------------------------------------------- corpus_path = args.public / CORPUS_NAME if not corpus_path.is_file(): failures.append(f"[13] {CORPUS_NAME} is missing from the public release") else: corpus = json.loads(corpus_path.read_text(encoding="utf-8")) entries = corpus.get("row_content_hashes", []) declared = corpus.get("counts", {}).get("final") malformed = sum(1 for e in entries if not re.fullmatch(r"[0-9a-f]{64}", str(e.get("sha256", "")))) if len(entries) != EXPECTED_CORPUS_ROWS: failures.append(f"[13] {CORPUS_NAME} carries {len(entries)} row hashes, " f"expected {EXPECTED_CORPUS_ROWS}") elif declared != EXPECTED_CORPUS_ROWS: failures.append(f"[13] {CORPUS_NAME} declares counts.final {declared}, " f"expected {EXPECTED_CORPUS_ROWS}") elif malformed: failures.append(f"[13] {CORPUS_NAME}: {malformed} entr(ies) do not carry a " f"64-hex sha256") else: print(f" [13] {CORPUS_NAME} carries {len(entries)} row hashes and agrees " f"with its own counts.final") # ---- diagnostic -------------------------------------------------------------- if args.sealed_rows and args.sealed_rows.is_file(): sealed = {r["ea_name"]: r for r in read_jsonl(args.sealed_rows)} spec_ok = spec_bad = tmpl_ok = tmpl_bad = 0 example = None for r in published: s = sealed.get(id_to_name.get(r["item_id"], "")) if not s: continue if sha256_text(r["prompt"]) == s.get("spec_sha256"): spec_ok += 1 else: spec_bad += 1 if example is None: # Published rows carry item_id only; the name comes from the # private mapping already resolved above. example = (r["item_id"], id_to_name.get(r["item_id"], "?"), sha256_text(r["prompt"]), s.get("spec_sha256")) if sha256_text(format_local_prompt(r["prompt"])) == s.get("prompt_sha256"): tmpl_ok += 1 else: tmpl_bad += 1 notes.append( f"[D] sealed spec_sha256 reproduces for {spec_ok}/{spec_ok + spec_bad} items; " f"sealed prompt_sha256 reproduces under the local serving template for " f"{tmpl_ok}/{tmpl_ok + tmpl_bad}" ) if example: notes.append(f"[D] first divergence: {example[0]} ({example[1]})\n" f" sha256(published prompt) = {example[2]}\n" f" sealed spec_sha256 = {example[3]}") # A known-answer check on the hashing itself, so a zero above cannot be blamed # on this script's encoding. want = "820208ddccc935fe44222db63416e192f605183e1b77c8e833de0d8aa94c6377" got_sp = sha256_text(SYSTEM_PROMPT) notes.append(f"[D] instrument check: sha256(SYSTEM_PROMPT) " f"{'MATCHES' if got_sp == want else 'DIFFERS FROM'} the sealed " f"system_prompt_sha256") if got_sp != want: failures.append("[D] this script's hashing does not reproduce a known answer; " "every hash result above is untrustworthy") for n in notes: print(n) if failures: print("\n=== FAILED ===") for f in failures: print(f" {f}") return 2 print("\n=== ALL CHECKS PASSED ===") return 0 if __name__ == "__main__": sys.exit(main(sys.argv[1:]))