szl-drift 0.1.0__tar.gz

szl_drift-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

szl_drift-0.1.0/NOTICE

@@ -0,0 +1,17 @@
+SZL Holdings
+Copyright 2026 SZL Holdings
+
+This product includes software developed at SZL Holdings
+(https://github.com/szl-holdings).
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

szl_drift-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: szl-drift
+Version: 0.1.0
+Summary: Origin-drift receipts: compare a-11-oy.com, a11oy.net, and a Ring 1 preview. Λ = Conjecture 1. Apache-2.0.
+Author-email: Stephen Lutar <stephen@szlholdings.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://a-11-oy.com
+Project-URL: Repository, https://github.com/szl-holdings/szl-drift
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# szl-drift
+
+Origin-drift receipts. **Not a second flagship.**
+
+<!-- szl:header v1 -->
+<!-- Native identity: szl-brand@4309f6fce89179331b0b3ed8c99494e76c5be256; Orbit v2 icon. -->
+<p>
+  <a href="https://github.com/szl-holdings">
+    <img src="https://raw.githubusercontent.com/szl-holdings/szl-brand/4309f6fce89179331b0b3ed8c99494e76c5be256/kit/logos/orbit-v2/suite/szl-icon-32.svg" alt="SZL Holdings — Orbit v2" width="32" height="32" />
+  </a>
+</p>
+
+**Control before action. Evidence after.**
+
+[Product](https://a-11-oy.com) · [Proof](https://a11oy.net) · [GitHub organization](https://github.com/szl-holdings)
+<!-- /szl:header -->
+
+Compares:
+
+| Origin | Probe | Meaning |
+|---|---|---|
+| Product | `https://a-11-oy.com/api/a11oy/v1/honest` + `/readyz` | Runtime doctrine + readiness |
+| Proof | `https://a11oy.net/health.json` | Static GitHub Pages document. Not DSSE-LIVE. |
+| Preview | Ring 1 kernel catalog | This surface is not the product origin |
+
+A `200` from product `/readyz` is **not** a production certificate. Factory bind `AO-2026-08-29-001` still holds that certificate **CLOSED**.
+
+## Run
+
+```bash
+python3 probe.py
+```
+
+Exit `0` always prints JSON. Missing, malformed, or non-object origin responses populate `errors`;
+a known HTTP status is retained. No upstream response can set `certified_production_ready` to true.
+
+The scheduled `verdict.py drift-report.json` check fails when an origin did not
+answer HTTP 200 or its response was rejected by the probe. A 200 response with
+malformed JSON, a non-object body, or an oversized body remains an alert. A
+passing verdict does not evaluate doctrine values or certify production readiness.
+
+## Honesty
+
+- Doctrine v11 LOCKED
+- Λ = Conjecture 1
+- locked-8 paints only when live `locked_formula_count === 8`
+- Warhacker v1.0.0 is archived
+- Apache-2.0
+
+Interactive verify stays on [a-11-oy.com/verify](https://a-11-oy.com/verify).
+
+Estate on Hugging Face: models, datasets and Spaces are published under the [SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS) org.
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE).

szl_drift-0.1.0/README.md

@@ -0,0 +1,56 @@
+# szl-drift
+
+Origin-drift receipts. **Not a second flagship.**
+
+<!-- szl:header v1 -->
+<!-- Native identity: szl-brand@4309f6fce89179331b0b3ed8c99494e76c5be256; Orbit v2 icon. -->
+<p>
+  <a href="https://github.com/szl-holdings">
+    <img src="https://raw.githubusercontent.com/szl-holdings/szl-brand/4309f6fce89179331b0b3ed8c99494e76c5be256/kit/logos/orbit-v2/suite/szl-icon-32.svg" alt="SZL Holdings — Orbit v2" width="32" height="32" />
+  </a>
+</p>
+
+**Control before action. Evidence after.**
+
+[Product](https://a-11-oy.com) · [Proof](https://a11oy.net) · [GitHub organization](https://github.com/szl-holdings)
+<!-- /szl:header -->
+
+Compares:
+
+| Origin | Probe | Meaning |
+|---|---|---|
+| Product | `https://a-11-oy.com/api/a11oy/v1/honest` + `/readyz` | Runtime doctrine + readiness |
+| Proof | `https://a11oy.net/health.json` | Static GitHub Pages document. Not DSSE-LIVE. |
+| Preview | Ring 1 kernel catalog | This surface is not the product origin |
+
+A `200` from product `/readyz` is **not** a production certificate. Factory bind `AO-2026-08-29-001` still holds that certificate **CLOSED**.
+
+## Run
+
+```bash
+python3 probe.py
+```
+
+Exit `0` always prints JSON. Missing, malformed, or non-object origin responses populate `errors`;
+a known HTTP status is retained. No upstream response can set `certified_production_ready` to true.
+
+The scheduled `verdict.py drift-report.json` check fails when an origin did not
+answer HTTP 200 or its response was rejected by the probe. A 200 response with
+malformed JSON, a non-object body, or an oversized body remains an alert. A
+passing verdict does not evaluate doctrine values or certify production readiness.
+
+## Honesty
+
+- Doctrine v11 LOCKED
+- Λ = Conjecture 1
+- locked-8 paints only when live `locked_formula_count === 8`
+- Warhacker v1.0.0 is archived
+- Apache-2.0
+
+Interactive verify stays on [a-11-oy.com/verify](https://a-11-oy.com/verify).
+
+Estate on Hugging Face: models, datasets and Spaces are published under the [SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS) org.
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE).

szl_drift-0.1.0/probe.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Origin drift probe. Fail closed. Never fabricates a certificate."""
+
+from __future__ import annotations
+
+import json
+import math
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+PRODUCT = "https://a-11-oy.com"
+PROOF = "https://a11oy.net"
+TIMEOUT = 8
+# Observed origin bodies are under 2 KB; anything past 1 MiB is not a probe response.
+MAX_BODY_BYTES = 1024 * 1024
+_DEFAULT_PORTS = {"http": 80, "https": 443}
+
+
+def _origin(url: str) -> tuple[str, str, int | None]:
+    """Return (scheme, host, port) with the default port filled in. Raises ValueError on a bad port."""
+    parts = urllib.parse.urlsplit(url)
+    scheme = parts.scheme.lower()
+    port = parts.port if parts.port is not None else _DEFAULT_PORTS.get(scheme)
+    return scheme, (parts.hostname or "").lower(), port
+
+
+def _origin_label(url: str) -> str:
+    try:
+        scheme, host, port = _origin(url)
+    except ValueError:
+        return "an unparseable origin"
+    return f"{scheme}://{host}" if port == _DEFAULT_PORTS.get(scheme) else f"{scheme}://{host}:{port}"
+
+
+class SameOriginRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """Follow a redirect only when it stays on the origin that was requested."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        try:
+            same_origin = _origin(newurl) == _origin(req.full_url)
+        except ValueError:
+            same_origin = False
+        # Close the 3xx response first: urllib otherwise drains its body with an
+        # unbounded read() before following the redirect.
+        fp.close()
+        if not same_origin:
+            reason = (
+                f"cross-origin redirect refused: {_origin_label(req.full_url)} -> {_origin_label(newurl)}"
+            )
+            raise urllib.error.HTTPError(req.full_url, code, reason, headers, None)
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+_OPENER = urllib.request.build_opener(SameOriginRedirectHandler)
+
+
+def _read_capped(res: Any, cap: int) -> bytes:
+    """Read at most cap + 1 bytes, so an oversized body is detectable without buffering it."""
+    chunks: list[bytes] = []
+    total = 0
+    while total <= cap:
+        chunk = res.read(cap + 1 - total)
+        if not chunk:
+            break
+        chunks.append(chunk)
+        total += len(chunk)
+    return b"".join(chunks)
+
+
+def _reject_duplicate_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    value: dict[str, Any] = {}
+    for key, item in pairs:
+        if key in value:
+            raise ValueError("duplicate JSON object key")
+        value[key] = item
+    return value
+
+
+def _reject_nonfinite_constant(_value: str) -> Any:
+    raise ValueError("non-finite JSON number")
+
+
+def _parse_finite_float(value: str) -> float:
+    number = float(value)
+    if not math.isfinite(number):
+        raise ValueError("non-finite JSON number")
+    return number
+
+
+def _strict_json(raw: str) -> Any:
+    return json.loads(
+        raw,
+        object_pairs_hook=_reject_duplicate_keys,
+        parse_constant=_reject_nonfinite_constant,
+        parse_float=_parse_finite_float,
+    )
+
+
+def get(url: str) -> dict[str, Any]:
+    req = urllib.request.Request(url, headers={"User-Agent": "szl-drift/1", "Accept": "application/json"})
+    try:
+        with _OPENER.open(req, timeout=TIMEOUT) as res:
+            cap = MAX_BODY_BYTES
+            data = _read_capped(res, cap)
+            if len(data) > cap:
+                return {
+                    "ok": False,
+                    "status": res.status,
+                    "body": None,
+                    "error": f"response body exceeds {cap} bytes",
+                }
+            try:
+                raw = data.decode("utf-8")
+                body: Any = _strict_json(raw)
+            except (UnicodeDecodeError, ValueError) as exc:
+                message = exc.msg if isinstance(exc, json.JSONDecodeError) else str(exc)
+                return {
+                    "ok": False,
+                    "status": res.status,
+                    "body": None,
+                    "error": f"invalid JSON response: {message}",
+                }
+            if not isinstance(body, dict):
+                return {
+                    "ok": False,
+                    "status": res.status,
+                    "body": None,
+                    "error": f"invalid JSON object: got {type(body).__name__}",
+                }
+            return {"ok": True, "status": res.status, "body": body, "error": None}
+    except urllib.error.HTTPError as exc:
+        return {"ok": False, "status": exc.code, "body": None, "error": str(exc)}
+    except Exception as exc:
+        return {"ok": False, "status": None, "body": None, "error": str(exc)}
+
+
+def main() -> int:
+    honest = get(f"{PRODUCT}/api/a11oy/v1/honest")
+    readyz = get(f"{PRODUCT}/readyz")
+    health = get(f"{PROOF}/health.json")
+    # Keep the defensive shape guard even though get() rejects non-object JSON:
+    # tests and future callers can replace get(), and main must still degrade
+    # rather than crash on a malformed result.
+    raw_body = honest.get("body")
+    body = raw_body if isinstance(raw_body, dict) else {}
+    raw_doctrine = body.get("doctrine_lock")
+    doctrine = raw_doctrine if isinstance(raw_doctrine, dict) else {}
+    # Presence, not truthiness, selects the authoritative top-level observation.
+    # An explicit 0/null must not be replaced by a nested fallback and thereby
+    # hide drift in the source response.
+    locked_formula_count = (
+        body["locked_formula_count"]
+        if "locked_formula_count" in body
+        else doctrine.get("locked_formula_count")
+    )
+    report = {
+        "schema": "szl.origin-drift/v1",
+        "certified_production_ready": False,
+        "product_honest": {
+            "status": honest["status"],
+            "locked_formula_count": locked_formula_count,
+            "lambda": doctrine.get("lambda"),
+            "kernel": doctrine.get("commit"),
+            "git_sha": body.get("git_sha"),
+        },
+        "product_readyz": {
+            "status": readyz["status"],
+            "body": readyz.get("body"),
+            "note": "200 ready is not a production certificate.",
+        },
+        "proof_health": {
+            "status": health["status"],
+            "sha": (health.get("body") or {}).get("sha") if isinstance(health.get("body"), dict) else None,
+            "signer": (health.get("body") or {}).get("signer")
+            if isinstance(health.get("body"), dict)
+            else None,
+            "note": "Static document. Not DSSE-LIVE.",
+        },
+        "errors": {
+            "honest": honest["error"],
+            "readyz": readyz["error"],
+            "health": health["error"],
+        },
+    }
+    print(json.dumps(report, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

szl_drift-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "szl-drift"
+version = "0.1.0"
+description = "Origin-drift receipts: compare a-11-oy.com, a11oy.net, and a Ring 1 preview. Λ = Conjecture 1. Apache-2.0."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [{ name = "Stephen Lutar", email = "stephen@szlholdings.com" }]
+dependencies = []
+
+[project.urls]
+Homepage = "https://a-11-oy.com"
+Repository = "https://github.com/szl-holdings/szl-drift"
+
+[tool.setuptools]
+py-modules = ["probe", "verdict"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"

szl_drift-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

szl_drift-0.1.0/szl_drift.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: szl-drift
+Version: 0.1.0
+Summary: Origin-drift receipts: compare a-11-oy.com, a11oy.net, and a Ring 1 preview. Λ = Conjecture 1. Apache-2.0.
+Author-email: Stephen Lutar <stephen@szlholdings.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://a-11-oy.com
+Project-URL: Repository, https://github.com/szl-holdings/szl-drift
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: license-file
+
+# szl-drift
+
+Origin-drift receipts. **Not a second flagship.**
+
+<!-- szl:header v1 -->
+<!-- Native identity: szl-brand@4309f6fce89179331b0b3ed8c99494e76c5be256; Orbit v2 icon. -->
+<p>
+  <a href="https://github.com/szl-holdings">
+    <img src="https://raw.githubusercontent.com/szl-holdings/szl-brand/4309f6fce89179331b0b3ed8c99494e76c5be256/kit/logos/orbit-v2/suite/szl-icon-32.svg" alt="SZL Holdings — Orbit v2" width="32" height="32" />
+  </a>
+</p>
+
+**Control before action. Evidence after.**
+
+[Product](https://a-11-oy.com) · [Proof](https://a11oy.net) · [GitHub organization](https://github.com/szl-holdings)
+<!-- /szl:header -->
+
+Compares:
+
+| Origin | Probe | Meaning |
+|---|---|---|
+| Product | `https://a-11-oy.com/api/a11oy/v1/honest` + `/readyz` | Runtime doctrine + readiness |
+| Proof | `https://a11oy.net/health.json` | Static GitHub Pages document. Not DSSE-LIVE. |
+| Preview | Ring 1 kernel catalog | This surface is not the product origin |
+
+A `200` from product `/readyz` is **not** a production certificate. Factory bind `AO-2026-08-29-001` still holds that certificate **CLOSED**.
+
+## Run
+
+```bash
+python3 probe.py
+```
+
+Exit `0` always prints JSON. Missing, malformed, or non-object origin responses populate `errors`;
+a known HTTP status is retained. No upstream response can set `certified_production_ready` to true.
+
+The scheduled `verdict.py drift-report.json` check fails when an origin did not
+answer HTTP 200 or its response was rejected by the probe. A 200 response with
+malformed JSON, a non-object body, or an oversized body remains an alert. A
+passing verdict does not evaluate doctrine values or certify production readiness.
+
+## Honesty
+
+- Doctrine v11 LOCKED
+- Λ = Conjecture 1
+- locked-8 paints only when live `locked_formula_count === 8`
+- Warhacker v1.0.0 is archived
+- Apache-2.0
+
+Interactive verify stays on [a-11-oy.com/verify](https://a-11-oy.com/verify).
+
+Estate on Hugging Face: models, datasets and Spaces are published under the [SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS) org.
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE).

szl_drift-0.1.0/szl_drift.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+NOTICE
+README.md
+probe.py
+pyproject.toml
+verdict.py
+szl_drift.egg-info/PKG-INFO
+szl_drift.egg-info/SOURCES.txt
+szl_drift.egg-info/dependency_links.txt
+szl_drift.egg-info/top_level.txt
+tests/test_probe.py
+tests/test_verdict.py

szl_drift-0.1.0/szl_drift.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

szl_drift-0.1.0/szl_drift.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+probe
+verdict

szl_drift-0.1.0/tests/test_probe.py

@@ -0,0 +1,496 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""Offline tests for the origin drift probe.
+
+These tests never touch the public network. `probe.get` is exercised against a
+stubbed `probe._OPENER.open` and against a throwaway HTTP server bound to
+127.0.0.1, and `probe.main` is exercised with `probe.get` itself replaced, so
+the suite is deterministic and safe to run in CI on a fork.
+
+The properties under test are the two the probe exists to guarantee:
+
+1. **Fail closed.** Every failure path returns a well-formed dict with
+   ``ok=False`` rather than raising, so a dead or malformed endpoint degrades
+   the report instead of crashing the run or being recorded as healthy.
+2. **Never fabricates a certificate.** ``certified_production_ready`` is
+   ``False`` in the report unconditionally — including when every upstream
+   endpoint returns a healthy 200.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+import threading
+import urllib.error
+import urllib.request
+from collections.abc import Iterator
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import probe
+
+
+class _FakeResponse:
+    def __init__(self, payload: bytes, status: int = 200) -> None:
+        self._buf = io.BytesIO(payload)
+        self.status = status
+
+    def read(self, amt: int | None = None) -> bytes:
+        return self._buf.read(amt)
+
+    def __enter__(self) -> _FakeResponse:
+        return self
+
+    def __exit__(self, *_exc: object) -> bool:
+        return False
+
+
+def test_get_parses_json_body(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        probe._OPENER,
+        "open",
+        lambda *_a, **_k: _FakeResponse(b'{"doctrine_lock": {"lambda": 14}}'),
+    )
+    result = probe.get("https://example.test/x")
+    assert result["ok"] is True
+    assert result["status"] == 200
+    assert result["body"] == {"doctrine_lock": {"lambda": 14}}
+    assert result["error"] is None
+
+
+@pytest.mark.parametrize(
+    ("payload", "expected"),
+    [(b'{"value":1.5}', 1.5), (b'{"value":1e2}', 100.0)],
+)
+def test_get_accepts_finite_json_numbers(
+    monkeypatch: pytest.MonkeyPatch, payload: bytes, expected: float
+) -> None:
+    monkeypatch.setattr(
+        probe._OPENER,
+        "open",
+        lambda *_a, **_k: _FakeResponse(payload),
+    )
+    result = probe.get("https://example.test/x")
+    assert result == {
+        "ok": True,
+        "status": 200,
+        "body": {"value": expected},
+        "error": None,
+    }
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        b'{"locked_formula_count":0,"locked_formula_count":749}',
+        b'{"doctrine_lock":{"lambda":0,"lambda":14}}',
+        b'{"value":NaN}',
+        b'{"value":Infinity}',
+        b'{"value":-Infinity}',
+        b'{"value":1e999}',
+        b'{"value":"\xff"}',
+    ],
+)
+def test_get_fails_closed_on_ambiguous_nonfinite_or_undecodable_json(
+    monkeypatch: pytest.MonkeyPatch, payload: bytes
+) -> None:
+    monkeypatch.setattr(
+        probe._OPENER,
+        "open",
+        lambda *_a, **_k: _FakeResponse(payload),
+    )
+    result = probe.get("https://example.test/x")
+    assert result["ok"] is False
+    assert result["status"] == 200
+    assert result["body"] is None
+    assert result["error"].startswith("invalid JSON response:")
+
+
+def test_get_fails_closed_on_invalid_json(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        probe._OPENER,
+        "open",
+        lambda *_a, **_k: _FakeResponse(b"<!doctype html><title>nope</title>"),
+    )
+    result = probe.get("https://example.test/x")
+    assert result["ok"] is False
+    assert result["status"] == 200
+    assert result["body"] is None
+    assert result["error"].startswith("invalid JSON response:")
+
+
+@pytest.mark.parametrize(
+    ("payload", "kind"),
+    [
+        (b'["not", "an", "object"]', "list"),
+        (b'"a string"', "str"),
+        (b"42", "int"),
+        (b"true", "bool"),
+        (b"null", "NoneType"),
+    ],
+)
+def test_get_fails_closed_on_json_that_is_not_an_object(
+    monkeypatch: pytest.MonkeyPatch, payload: bytes, kind: str
+) -> None:
+    monkeypatch.setattr(
+        probe._OPENER,
+        "open",
+        lambda *_a, **_k: _FakeResponse(payload),
+    )
+    result = probe.get("https://example.test/x")
+    assert result["ok"] is False
+    assert result["status"] == 200
+    assert result["body"] is None
+    assert result["error"] == f"invalid JSON object: got {kind}"
+
+
+def test_get_fails_closed_on_http_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _raise(*_a: object, **_k: object) -> None:
+        raise urllib.error.HTTPError(  # type: ignore[arg-type]
+            "https://example.test/x", 503, "boom", {}, None
+        )
+
+    monkeypatch.setattr(probe._OPENER, "open", _raise)
+    result = probe.get("https://example.test/x")
+    assert result["ok"] is False
+    assert result["status"] == 503
+    assert result["body"] is None
+    assert result["error"]
+
+
+def test_get_fails_closed_on_transport_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    def _raise(*_a: object, **_k: object) -> None:
+        raise OSError("name or service not known")
+
+    monkeypatch.setattr(probe._OPENER, "open", _raise)
+    result = probe.get("https://example.test/x")
+    assert result["ok"] is False
+    assert result["status"] is None
+    assert result["error"]
+
+
+class _EndlessResponse:
+    """A body that never ends: an unbounded read() would never return."""
+
+    status = 200
+
+    def __init__(self) -> None:
+        self.requested = 0
+
+    def read(self, amt: int | None = None) -> bytes:
+        assert amt is not None, "get() must never issue an unbounded read"
+        self.requested += amt
+        return b" " * amt
+
+    def __enter__(self) -> _EndlessResponse:
+        return self
+
+    def __exit__(self, *_exc: object) -> bool:
+        return False
+
+
+def test_get_reads_at_most_cap_plus_one_bytes(monkeypatch: pytest.MonkeyPatch) -> None:
+    endless = _EndlessResponse()
+    monkeypatch.setattr(probe, "MAX_BODY_BYTES", 1024)
+    monkeypatch.setattr(probe._OPENER, "open", lambda *_a, **_k: endless)
+    result = probe.get("https://example.test/x")
+    assert result == {
+        "ok": False,
+        "status": 200,
+        "body": None,
+        "error": "response body exceeds 1024 bytes",
+    }
+    assert endless.requested == 1025
+
+
+@pytest.fixture
+def origin() -> Iterator[SimpleNamespace]:
+    """A throwaway HTTP origin on 127.0.0.1 with scripted routes and a hit log."""
+    routes: dict[str, tuple[int, dict[str, str], bytes]] = {}
+    hits: list[str] = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *_args: object) -> None:
+            pass
+
+        def do_GET(self) -> None:
+            hits.append(self.path)
+            status, headers, body = routes.get(self.path, (404, {}, b""))
+            self.send_response(status)
+            for name, value in headers.items():
+                self.send_header(name, value)
+            self.end_headers()
+            self.wfile.write(body)
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield SimpleNamespace(
+            base=f"http://127.0.0.1:{server.server_port}",
+            port=server.server_port,
+            routes=routes,
+            hits=hits,
+        )
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join()
+
+
+def _json_route(body: bytes) -> tuple[int, dict[str, str], bytes]:
+    return 200, {"Content-Type": "application/json", "Content-Length": str(len(body))}, body
+
+
+def test_get_accepts_a_valid_body_exactly_at_the_cap(
+    monkeypatch: pytest.MonkeyPatch, origin: SimpleNamespace
+) -> None:
+    body = b'{"pad": "' + b"x" * 53 + b'"}'
+    assert len(body) == 64
+    monkeypatch.setattr(probe, "MAX_BODY_BYTES", 64)
+    origin.routes["/ok"] = _json_route(body)
+    result = probe.get(origin.base + "/ok")
+    assert result == {"ok": True, "status": 200, "body": {"pad": "x" * 53}, "error": None}
+
+
+@pytest.mark.parametrize("declared_length", [True, False], ids=["content-length", "close-delimited"])
+def test_get_refuses_an_oversized_body(
+    monkeypatch: pytest.MonkeyPatch, origin: SimpleNamespace, declared_length: bool
+) -> None:
+    body = b'{"pad": "' + b"x" * 4096 + b'"}'
+    headers = {"Content-Type": "application/json"}
+    if declared_length:
+        headers["Content-Length"] = str(len(body))
+    monkeypatch.setattr(probe, "MAX_BODY_BYTES", 64)
+    origin.routes["/big"] = (200, headers, body)
+    result = probe.get(origin.base + "/big")
+    assert result == {
+        "ok": False,
+        "status": 200,
+        "body": None,
+        "error": "response body exceeds 64 bytes",
+    }
+
+
+def test_get_fails_closed_on_malformed_json_from_a_live_socket(origin: SimpleNamespace) -> None:
+    origin.routes["/bad"] = _json_route(b'{"truncated": ')
+    result = probe.get(origin.base + "/bad")
+    assert result["ok"] is False
+    assert result["status"] == 200
+    assert result["body"] is None
+    assert result["error"].startswith("invalid JSON response:")
+
+
+def test_get_follows_a_same_origin_redirect(origin: SimpleNamespace) -> None:
+    origin.routes["/hop"] = (302, {"Location": "/ok", "Content-Length": "0"}, b"")
+    origin.routes["/ok"] = _json_route(b'{"ready": true}')
+    result = probe.get(origin.base + "/hop")
+    assert result == {"ok": True, "status": 200, "body": {"ready": True}, "error": None}
+    assert origin.hits == ["/hop", "/ok"]
+
+
+def test_get_does_not_drain_a_same_origin_redirect_body(origin: SimpleNamespace) -> None:
+    # The 3xx claims a 1 GB body and sends none. urllib's default handler would
+    # try to read all of it before following, and fail on the short read.
+    origin.routes["/hop"] = (302, {"Location": "/ok", "Content-Length": str(10**9)}, b"")
+    origin.routes["/ok"] = _json_route(b'{"ready": true}')
+    result = probe.get(origin.base + "/hop")
+    assert result == {"ok": True, "status": 200, "body": {"ready": True}, "error": None}
+
+
+@pytest.mark.parametrize(
+    ("location", "target_label"),
+    [
+        ("http://localhost:{port}/ok", "http://localhost:{port}"),
+        ("http://127.0.0.1:1/ok", "http://127.0.0.1:1"),
+        ("https://127.0.0.1:{port}/ok", "https://127.0.0.1:{port}"),
+        ("//example.invalid/ok", "http://example.invalid"),
+    ],
+    ids=["other-host", "other-port", "other-scheme", "scheme-relative"],
+)
+def test_get_refuses_a_cross_origin_redirect(
+    origin: SimpleNamespace, location: str, target_label: str
+) -> None:
+    origin.routes["/hop"] = (302, {"Location": location.format(port=origin.port), "Content-Length": "0"}, b"")
+    origin.routes["/ok"] = _json_route(b'{"ready": true}')
+    result = probe.get(origin.base + "/hop")
+    assert result == {
+        "ok": False,
+        "status": 302,
+        "body": None,
+        "error": (
+            "HTTP Error 302: cross-origin redirect refused: "
+            f"{origin.base} -> {target_label.format(port=origin.port)}"
+        ),
+    }
+    assert origin.hits == ["/hop"]
+
+
+@pytest.mark.parametrize(
+    ("newurl", "allowed"),
+    [
+        ("https://a-11-oy.com/readyz/", True),
+        ("https://A-11-OY.com:443/readyz", True),
+        ("https://a-11-oy.com:0/readyz", False),
+        ("http://a-11-oy.com/readyz", False),
+        ("https://a-11-oy.com:8443/readyz", False),
+        ("https://a-11-oy.com.example.invalid/readyz", False),
+        ("https://a-11-oy.com@example.invalid/readyz", False),
+        ("https://a-11-oy.com:notaport/readyz", False),
+    ],
+)
+def test_redirect_handler_allows_only_the_requested_origin(newurl: str, allowed: bool) -> None:
+    handler = probe.SameOriginRedirectHandler()
+    req = urllib.request.Request("https://a-11-oy.com/readyz")
+    fp = io.BytesIO(b"redirect body")
+    if allowed:
+        follow = handler.redirect_request(req, fp, 301, "Moved", {}, newurl)
+        assert follow is not None
+        assert follow.full_url == newurl
+    else:
+        with pytest.raises(urllib.error.HTTPError) as refused:
+            handler.redirect_request(req, fp, 301, "Moved", {}, newurl)
+        assert refused.value.code == 301
+        assert "cross-origin redirect refused" in str(refused.value)
+    assert fp.closed
+
+
+@pytest.mark.parametrize(("scheme", "default_port"), [("http", 80), ("https", 443)])
+@pytest.mark.parametrize("port", [None, "default", 0, 8443])
+def test_origin_defaults_only_an_omitted_port(scheme: str, default_port: int, port: int | str | None) -> None:
+    explicit_port = default_port if port == "default" else port
+    suffix = "" if explicit_port is None else f":{explicit_port}"
+    expected_port = default_port if explicit_port is None else explicit_port
+    assert probe._origin(f"{scheme}://EXAMPLE.test{suffix}/readyz") == (
+        scheme,
+        "example.test",
+        expected_port,
+    )
+
+
+def _run_main(capsys: pytest.CaptureFixture[str]) -> dict:
+    assert probe.main() == 0
+    return json.loads(capsys.readouterr().out)
+
+
+def test_main_emits_schema_and_never_certifies_on_healthy_upstream(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    healthy = {
+        "ok": True,
+        "status": 200,
+        "body": {
+            "git_sha": "a" * 40,
+            "locked_formula_count": 749,
+            "doctrine_lock": {"lambda": 14, "commit": "c7c0ba17", "locked_formula_count": 749},
+            "sha": "b" * 40,
+            "signer": "yachay",
+        },
+        "error": None,
+    }
+    monkeypatch.setattr(probe, "get", lambda _url: healthy)
+
+    report = _run_main(capsys)
+
+    assert report["schema"] == "szl.origin-drift/v1"
+    # The load-bearing assertion: a fully healthy estate is still not certified.
+    assert report["certified_production_ready"] is False
+    assert report["product_honest"]["locked_formula_count"] == 749
+    assert report["product_honest"]["lambda"] == 14
+    assert report["product_honest"]["kernel"] == "c7c0ba17"
+    assert report["proof_health"]["signer"] == "yachay"
+    assert report["errors"] == {"honest": None, "readyz": None, "health": None}
+
+
+@pytest.mark.parametrize("explicit_value", [0, None, False, ""])
+def test_main_preserves_explicit_falsy_locked_formula_count(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    explicit_value: object,
+) -> None:
+    """An explicit top-level observation must never be hidden by fallback data."""
+
+    observed = {
+        "ok": True,
+        "status": 200,
+        "body": {
+            "locked_formula_count": explicit_value,
+            "doctrine_lock": {"locked_formula_count": 8},
+        },
+        "error": None,
+    }
+    monkeypatch.setattr(probe, "get", lambda _url: observed)
+
+    report = _run_main(capsys)
+
+    assert report["product_honest"]["locked_formula_count"] is explicit_value
+    assert report["certified_production_ready"] is False
+
+
+def test_main_uses_nested_locked_formula_count_only_when_top_level_is_absent(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    observed = {
+        "ok": True,
+        "status": 200,
+        "body": {"doctrine_lock": {"locked_formula_count": 8}},
+        "error": None,
+    }
+    monkeypatch.setattr(probe, "get", lambda _url: observed)
+
+    report = _run_main(capsys)
+
+    assert report["product_honest"]["locked_formula_count"] == 8
+
+
+def test_main_degrades_without_raising_when_everything_is_down(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    down = {"ok": False, "status": None, "body": None, "error": "unreachable"}
+    monkeypatch.setattr(probe, "get", lambda _url: down)
+
+    report = _run_main(capsys)
+
+    assert report["certified_production_ready"] is False
+    assert report["product_honest"]["status"] is None
+    assert report["product_honest"]["locked_formula_count"] is None
+    assert report["proof_health"]["sha"] is None
+    assert set(report["errors"].values()) == {"unreachable"}
+
+
+@pytest.mark.parametrize("weird_body", [["not", "a", "dict"], "a string", 42, True])
+def test_main_fails_closed_on_valid_json_that_is_not_an_object(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], weird_body: object
+) -> None:
+    """Main stays defensive even if a caller substitutes get() with bad data."""
+    monkeypatch.setattr(
+        probe,
+        "get",
+        lambda _url: {"ok": True, "status": 200, "body": weird_body, "error": None},
+    )
+
+    report = _run_main(capsys)
+
+    assert report["certified_production_ready"] is False
+    assert report["product_honest"]["locked_formula_count"] is None
+    assert report["product_honest"]["lambda"] is None
+    assert report["proof_health"]["sha"] is None
+    assert report["proof_health"]["signer"] is None
+
+
+def test_report_is_json_serialisable_and_sorted(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(probe, "get", lambda _url: {"ok": True, "status": 200, "body": {}, "error": None})
+    probe.main()
+    out = capsys.readouterr().out
+    assert json.loads(out)  # parses
+    keys = list(json.loads(out).keys())
+    assert keys == sorted(keys)  # main() prints with sort_keys=True

szl_drift-0.1.0/tests/test_verdict.py

@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""Offline tests for the scheduled availability verdict.
+
+The verdict reads a finished report and never touches the network. These
+tests pin the property the scheduled job relies on: any probed origin that did
+not answer 200 or had a rejected response makes the verdict exit 1, and a
+healthy report exits 0.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import probe
+import verdict
+
+
+def _report(honest=200, readyz=200, health=200, errors=None):
+    return {
+        "schema": "szl.origin-drift/v1",
+        "certified_production_ready": False,
+        "product_honest": {"status": honest},
+        "product_readyz": {"status": readyz},
+        "proof_health": {"status": health},
+        "errors": errors or {"honest": None, "readyz": None, "health": None},
+    }
+
+
+def test_all_200_passes():
+    assert verdict.reasons(_report()) == []
+
+
+@pytest.mark.parametrize("field", ["honest", "readyz", "health"])
+@pytest.mark.parametrize("status", [503, 404, 301, None])
+def test_any_unavailable_origin_fails(field, status):
+    failed = verdict.reasons(_report(**{field: status}))
+    assert len(failed) == 1
+    assert repr(status) in failed[0]
+
+
+def test_outage_reports_every_origin_and_its_error():
+    # The shape recorded by the 2026-10-04..06 a11oy outage reports.
+    outage = "HTTP Error 503: Service Unavailable"
+    report = _report(honest=503, readyz=503, errors={"honest": outage, "readyz": outage, "health": None})
+    failed = verdict.reasons(report)
+    assert [line.split(":")[0] for line in failed] == ["product_honest", "product_readyz"]
+    assert all("503: Service Unavailable" in line for line in failed)
+
+
+@pytest.mark.parametrize("bad", [None, [], "x", {}, {"schema": "other/v1"}])
+def test_missing_or_foreign_report_fails(bad):
+    assert verdict.reasons(bad) == ["report is missing or not szl.origin-drift/v1"]
+
+
+def test_missing_section_fails():
+    report = _report()
+    del report["proof_health"]
+    assert verdict.reasons(report) == ["proof_health: status None"]
+
+
+def test_cli_exit_codes(tmp_path, capsys):
+    good = tmp_path / "good.json"
+    good.write_text(json.dumps(_report()), encoding="utf-8")
+    bad = tmp_path / "bad.json"
+    bad.write_text(json.dumps(_report(readyz=503)), encoding="utf-8")
+    assert verdict.main(["verdict.py", str(good)]) == 0
+    assert verdict.main(["verdict.py", str(bad)]) == 1
+    assert "ORIGIN UNAVAILABLE" in capsys.readouterr().out
+    assert verdict.main(["verdict.py", str(tmp_path / "absent.json")]) == 1
+    assert verdict.main(["verdict.py"]) == 2
+
+
+def test_verdict_reads_real_probe_output(monkeypatch, capsys, tmp_path):
+    # Drive probe.main with get() stubbed, then feed its exact stdout to the verdict.
+    def fake_get(url):
+        if url.endswith("/readyz"):
+            return {"ok": False, "status": 503, "body": None, "error": "HTTP Error 503: Service Unavailable"}
+        return {"ok": True, "status": 200, "body": {}, "error": None}
+
+    monkeypatch.setattr(probe, "get", fake_get)
+    assert probe.main() == 0
+    path = tmp_path / "drift-report.json"
+    path.write_text(capsys.readouterr().out, encoding="utf-8")
+    assert verdict.main(["verdict.py", str(path)]) == 1
+    assert "product_readyz: status 503 (HTTP Error 503: Service Unavailable)" in capsys.readouterr().out
+
+
+@pytest.mark.parametrize("origin", ["honest", "readyz", "health"])
+@pytest.mark.parametrize(
+    "payload",
+    [b"<html>proxy error</html>", b"[]", b'{"padding":"' + b"x" * 64 + b'"}'],
+    ids=["invalid-json", "non-object", "oversized"],
+)
+def test_verdict_rejects_http_200_when_real_probe_rejects_body(
+    monkeypatch, capsys, tmp_path, origin, payload
+):
+    """A 200 proxy/error page must not become a green scheduled artifact."""
+    urls = {
+        "honest": f"{probe.PRODUCT}/api/a11oy/v1/honest",
+        "readyz": f"{probe.PRODUCT}/readyz",
+        "health": f"{probe.PROOF}/health.json",
+    }
+
+    def fake_open(request, **_kwargs):
+        response = io.BytesIO(payload if request.full_url == urls[origin] else b"{}")
+        response.status = 200
+        return response
+
+    monkeypatch.setattr(probe, "MAX_BODY_BYTES", 64)
+    monkeypatch.setattr(probe._OPENER, "open", fake_open)
+    assert probe.main() == 0
+    output = capsys.readouterr().out
+    report = json.loads(output)
+    section = next(name for name, key in verdict.ERROR_KEYS.items() if key == origin)
+    assert report[section]["status"] == 200
+    assert report["errors"][origin]
+    assert report["certified_production_ready"] is False
+    assert verdict.reasons(report) == [f"{section}: status 200 ({report['errors'][origin]})"]
+    path = tmp_path / "drift-report.json"
+    path.write_text(output, encoding="utf-8")
+    assert verdict.main(["verdict.py", str(path)]) == 1
+    assert report["errors"][origin] in capsys.readouterr().out

szl_drift-0.1.0/verdict.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 SZL Holdings
+"""Availability verdict for a drift report. Reads a report; never probes.
+
+probe.py always exits 0 so a degraded report is still published. This verdict
+is the separate, scheduled-only alert: it exits 1 when any probed origin did
+not answer HTTP 200 or the probe rejected its response, so an outage or invalid
+response turns the scheduled run red instead of being archived as a green
+artifact. It does not judge doctrine values, and a pass is not a production
+certificate.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+ORIGINS = ("product_honest", "product_readyz", "proof_health")
+ERROR_KEYS = {"product_honest": "honest", "product_readyz": "readyz", "proof_health": "health"}
+
+
+def reasons(report: Any) -> list[str]:
+    """Return one line per unavailable origin or rejected response."""
+    if not isinstance(report, dict) or report.get("schema") != "szl.origin-drift/v1":
+        return ["report is missing or not szl.origin-drift/v1"]
+    errors = report.get("errors") if isinstance(report.get("errors"), dict) else {}
+    out = []
+    for name in ORIGINS:
+        section = report.get(name)
+        status = section.get("status") if isinstance(section, dict) else None
+        error = errors.get(ERROR_KEYS[name])
+        if status != 200 or error:
+            out.append(f"{name}: status {status!r}" + (f" ({error})" if error else ""))
+    return out
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        print("usage: verdict.py DRIFT_REPORT.json", file=sys.stderr)
+        return 2
+    try:
+        with open(argv[1], encoding="utf-8") as fh:
+            report = json.load(fh)
+    except (OSError, ValueError) as exc:
+        report = None
+        print(f"cannot read report: {exc}", file=sys.stderr)
+    failed = reasons(report)
+    if failed:
+        print("ORIGIN UNAVAILABLE")
+        for line in failed:
+            print(f"- {line}")
+        return 1
+    print("All probed origins answered HTTP 200 without probe errors. Not a production certificate.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))