Sync GitHub source 53cbcb39510694c6b7d9d13720da39d07a1d4b37

Canonical source: https://github.com/noqt/Lumi-Eggcracker/commit/53cbcb39510694c6b7d9d13720da39d07a1d4b37

HUGGINGFACE_MANIFEST.json

@@ -37,7 +37,7 @@
       "size": 10537
     },
     "README.md": {
-      "sha256": "416a714f25f243153fd6918a384826f2afdacb4f0aee2c61a16c0508e7d09451",
+      "sha256": "d0ed57b2b23db58fcb59a5b9a59696355424dc4af805b5f35289029782d4713f",
       "size": 48062
     },
     "RELEASE_NOTES.md": {
@@ -57,8 +57,8 @@
       "size": 1970
     },
     "TRY_IT.md": {
-      "sha256": "60354eb8599bea8bceadb272be3cf8b34f50d58de882f691fe4eed13d008c21d",
-      "size": 20535
+      "sha256": "4d255dee589555818019e5824ba646bcbc341670f994c6b7cf783880a2df43f0",
+      "size": 21557
     },
     "actions/validate-hosted-proof-receipt/action.yml": {
       "sha256": "4f66f6bfe972a945cdb686a570f51aeb7a474c48986608c9de862dfb6cf27ab3",
@@ -109,11 +109,11 @@
       "size": 1704
     },
     "examples/gguf-file/lumi-eggcracker-gguf-file.pyz": {
-      "sha256": "199b651761743d6816970d7c3e0becf9036105670f85431bdeab014ca5683b2b",
-      "size": 89855
+      "sha256": "1b93a8705325c5adaaaa1f49ef1f76a81bf080ad7ed4c73dcb61731c223026c0",
+      "size": 93453
     },
     "examples/gguf-file/lumi-eggcracker-gguf-file.pyz.sha256": {
-      "sha256": "e6fda433da2bfd326069526613878144b6f3bafdfa8014122f96ec51cd074919",
+      "sha256": "7b6e4732ac6a08edc2f46bfed0d6b9fcd325088b9e574adad4ea30253fa8e61a",
       "size": 96
     },
     "examples/observe-first/benign.json": {
@@ -217,7 +217,7 @@
       "size": 4101
     },
     "index.html": {
-      "sha256": "62121afdef8a9716842c192a71d747e51dbd7b68c0e9173aaca4c0847cc124bd",
+      "sha256": "9d37751d0fff2aa127d48e7b57d3a6c08095b910017010f21e4e8697824dac13",
       "size": 23351
     },
     "integrations/prometheus/eggcracker.rules.yml": {
@@ -265,7 +265,7 @@
       "size": 12375
     },
     "scripts/build_gguf_file_zipapp.py": {
-      "sha256": "6dd0886496e1fd01dd9e8817d2870b36690f83635694194aeb315970c5c34f0e",
+      "sha256": "b46c85b0e9dd0f50ad383588579d89a2570bf86f84d5bd6dcd3518a8db1a89d1",
       "size": 13435
     },
     "scripts/build_huggingface_surface.py": {
@@ -513,8 +513,8 @@
       "size": 1505
     },
     "src/lumi_eggcracker/gguf_file_observe.py": {
-      "sha256": "21a267f05a2920087d1518097292b91b38c3f35ba0b986e20f347cf98679fd48",
-      "size": 14092
+      "sha256": "239b4901683c6e60504bd36985e1b6b2f3b3645c913cda8cc94d631916418471",
+      "size": 17690
     },
     "src/lumi_eggcracker/hosted_proof.py": {
       "sha256": "7c2cf795d02eed4e35f0e238f455e3afbd52aeef146df08a9616af3275b0a075",
@@ -697,12 +697,12 @@
       "size": 78910
     },
     "tests/test_gguf_file_observe.py": {
-      "sha256": "c2b7024ef21e0971f1b4dbc2b05c6dee5c1fe939e9a22c95d0585ade347a3a78",
-      "size": 9951
+      "sha256": "1f762898d21c9e1be154c712889f2781565550b0255608d0eacc992f7d4f2ebf",
+      "size": 18747
     },
     "tests/test_gguf_file_zipapp.py": {
-      "sha256": "cd9c019d65c08d2ca320a7b0a1886b4f8cdda481ace50ff1e80108fd8b2ebbee",
-      "size": 11884
+      "sha256": "375563e84705594ee7853ec06b989ea6af7b4de7308f738789445094a6d508dd",
+      "size": 16674
     },
     "tests/test_hosted_probe_result_form.py": {
       "sha256": "08d8e0bd53207712620363c6a38b734c66e47c33b2b362f0548f2f5453b14ea5",
@@ -903,6 +903,6 @@
   },
   "schema": "noqt.huggingface_manifest.v1",
   "source_repository": "https://github.com/noqt/Lumi-Eggcracker",
-  "source_revision": "5346f7920d4d4de4ae92177110867b49f8935a2c",
-  "source_url": "https://github.com/noqt/Lumi-Eggcracker/commit/5346f7920d4d4de4ae92177110867b49f8935a2c"
+  "source_revision": "53cbcb39510694c6b7d9d13720da39d07a1d4b37",
+  "source_url": "https://github.com/noqt/Lumi-Eggcracker/commit/53cbcb39510694c6b7d9d13720da39d07a1d4b37"
 }

HUGGINGFACE_SYNC.json

@@ -1,6 +1,6 @@
 {
   "manifest": "HUGGINGFACE_MANIFEST.json",
-  "manifest_sha256": "4f1ba2c7d5a0e352485b57b460df2762090293020e71b18ac1bdc5abdf7339a3",
+  "manifest_sha256": "59771665acdc47f0898a22a4e5c5b7b6a0a6fadb78df37885909562d2a0fbd4c",
   "mirrored_files": 210,
   "mode": "DERIVED_READ_ONLY_MIRROR",
   "release_reference": {
@@ -65,7 +65,7 @@
   },
   "schema": "noqt.huggingface_sync.v1",
   "source_repository": "https://github.com/noqt/Lumi-Eggcracker",
-  "source_revision": "5346f7920d4d4de4ae92177110867b49f8935a2c",
-  "source_url": "https://github.com/noqt/Lumi-Eggcracker/commit/5346f7920d4d4de4ae92177110867b49f8935a2c",
+  "source_revision": "53cbcb39510694c6b7d9d13720da39d07a1d4b37",
+  "source_url": "https://github.com/noqt/Lumi-Eggcracker/commit/53cbcb39510694c6b7d9d13720da39d07a1d4b37",
   "target": "https://huggingface.co/spaces/noqt/eggcracker"
 }

README.md

@@ -11,7 +11,7 @@ short_description: Native Linux kill switch for supported local-AI workloads
 ---
 
 > Official noqt Hugging Face distribution, generated from GitHub commit
-> [`5346f7920d4d`](https://github.com/noqt/Lumi-Eggcracker/commit/5346f7920d4d4de4ae92177110867b49f8935a2c). This Space distributes the source for
+> [`53cbcb395106`](https://github.com/noqt/Lumi-Eggcracker/commit/53cbcb39510694c6b7d9d13720da39d07a1d4b37). This Space distributes the source for
 > discovery and cloning; Eggcracker itself runs on a supported native Linux
 > host, not on Hugging Face. A snapshot is called current only after the
 > release-linked sync job verifies its returned Hub commit and full manifest.

TRY_IT.md

@@ -169,6 +169,10 @@ bucket, and a SHA-256 digest of only the inspected prefix; it is not a full-file
 hash. Runtime and topology evidence remain empty, and file content alone does
 not complete an Eggcracker profile. The observer reads only the selected
 bounded regular file and performs no actuation.
+Refusals from the downloaded archive use the same fixed `rc=2` contract
+described in the source-checkout section: pre-output refusals leave stdout
+empty, and selected paths or exception details are not reported. A failure
+after output has started is not presented as a rollback.
 
 This source-only preview is unreleased and outside signed v1.0.10 and v1.0.11.
 It is not native-qualified and does not establish workload identity,
@@ -193,6 +197,18 @@ $env:PYTHONPATH = "src"
 python -m lumi_eggcracker.gguf_file_observe path\to\model.gguf
 ```
 
+For this source-checkout observer, a refusal exits with status `2` and writes
+one fixed ASCII token to stderr: `USAGE`,
+`FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE`, `NOT_USABLE_GGUF`,
+`FILE_CHANGED_DURING_OBSERVATION`, or `INTERNAL_REPORT_FAILURE`. The selected
+path and exception details are never included. Stdout is empty when refusal
+happens before report output starts; if output has already started and then
+fails, the observer does not claim that partial output was rolled back.
+An initially accessible regular file shorter than the fixed minimum is
+`NOT_USABLE_GGUF`; an oversized selection remains
+`FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE`. Parser faults are categorized only
+after the safe post-state checks, so an evidenced mutation wins.
+
 Successful output reports only facts read from that selected file: the GGUF
 version and content evidence ID, a size bucket, the number of inspected prefix
 bytes, and a SHA-256 digest whose scope is explicitly `first_prefix_only`.

examples/gguf-file/lumi-eggcracker-gguf-file.pyz.sha256

@@ -1 +1 @@
-199b651761743d6816970d7c3e0becf9036105670f85431bdeab014ca5683b2b  lumi-eggcracker-gguf-file.pyz
+1b93a8705325c5adaaaa1f49ef1f76a81bf080ad7ed4c73dcb61731c223026c0  lumi-eggcracker-gguf-file.pyz

index.html

@@ -4,7 +4,7 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="description" content="Lumi Eggcracker is noqt's native Linux kill switch for unapproved supported local-AI workloads. Clone the complete source from Hugging Face.">
-  <meta name="noqt-source-revision" content="5346f7920d4d4de4ae92177110867b49f8935a2c">
+  <meta name="noqt-source-revision" content="53cbcb39510694c6b7d9d13720da39d07a1d4b37">
   <meta name="theme-color" content="#090a0c">
   <title>Lumi Eggcracker — Native Linux AI kill switch</title>
   <style>
@@ -652,7 +652,7 @@ sudo /usr/bin/python3 -I -S scripts/first_kill.py \
     <section>
       <div class="shell source-bar">
         <div>
-          <div class="source-id">SOURCE COMMIT · 5346f7920d4d</div>
+          <div class="source-id">SOURCE COMMIT · 53cbcb395106</div>
           <h2>Inspect every line.</h2>
           <p>Complete source, tests, qualification documents and reproducible proof tooling are distributed in this repository.</p>
         </div>

scripts/build_gguf_file_zipapp.py

@@ -13,7 +13,7 @@ import zipfile
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[1]
-SOURCE_COMMIT = "5e7e6070fa973016f8ef73e44843e2c4cbbb1f06"
+SOURCE_COMMIT = "7b9b1dcc7242c47c64fcec7d493f1aa5bfc158ef"
 MANIFEST_NAME = "SOURCE-MANIFEST.json"
 MANIFEST_SCHEMA = "lumi-eggcracker.gguf-file-source-manifest.v1"
 MAIN_MODULE = (
@@ -62,7 +62,7 @@ SOURCE_INPUTS = (
     (
         "src/lumi_eggcracker/gguf_file_observe.py",
         "lumi_eggcracker/gguf_file_observe.py",
-        "7463a29d883a324b5c05382c2874f175f5bb4aa0",
+        "5118cd45cf9183d59c8a07abe468a4045f42d4a0",
     ),
     (
         "src/lumi_eggcracker/jsonio.py",

src/lumi_eggcracker/gguf_file_observe.py

@@ -33,7 +33,35 @@ MAX_PROFILE_GROUPS = 8
 MAX_GROUP_VALUES = 16
 MAX_LIST_ITEMS = 32
 
-ERROR_TEXT = "file evidence observation refused\n"
+USAGE = "USAGE"
+FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE = "FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE"
+NOT_USABLE_GGUF = "NOT_USABLE_GGUF"
+FILE_CHANGED_DURING_OBSERVATION = "FILE_CHANGED_DURING_OBSERVATION"
+INTERNAL_REPORT_FAILURE = "INTERNAL_REPORT_FAILURE"
+
+
+class _ObservationFailure(JsonInputError):
+    """Typed refusal boundary for the command-line observer."""
+
+    token = INTERNAL_REPORT_FAILURE
+
+
+class _FileUnavailableFailure(_ObservationFailure):
+    token = FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE
+
+
+class _NotUsableGgufFailure(_ObservationFailure):
+    token = NOT_USABLE_GGUF
+
+
+class _FileChangedFailure(_ObservationFailure):
+    token = FILE_CHANGED_DURING_OBSERVATION
+
+
+class _InternalReportFailure(_ObservationFailure):
+    token = INTERNAL_REPORT_FAILURE
+
+
 CONTENT_GROUPS = ("MODEL_CONTENT", "MODEL_RUNTIME", "MODEL_TOPOLOGY")
 LIMITATIONS = (
     "file evidence does not establish runtime or topology",
@@ -83,15 +111,15 @@ def _path_argument(path: str | os.PathLike[str]) -> str | bytes:
     try:
         value = os.fspath(path)
     except (TypeError, ValueError) as error:
-        raise JsonInputError("selected path is invalid") from error
+        raise _FileUnavailableFailure("selected path is invalid") from error
     if not isinstance(value, (str, bytes)) or not value:
-        raise JsonInputError("selected path is invalid")
+        raise _FileUnavailableFailure("selected path is invalid")
     try:
         encoded = os.fsencode(value)
     except (TypeError, UnicodeError) as error:
-        raise JsonInputError("selected path is invalid") from error
+        raise _FileUnavailableFailure("selected path is invalid") from error
     if not encoded or len(encoded) > MAX_PATH_BYTES or b"\0" in encoded:
-        raise JsonInputError("selected path exceeds the fixed limit")
+        raise _FileUnavailableFailure("selected path exceeds the fixed limit")
     return value
 
 
@@ -110,7 +138,7 @@ def _stable_identity(metadata: os.stat_result) -> _StableIdentity:
             int(metadata.st_mode),
         )
     except (AttributeError, TypeError, ValueError, OverflowError) as error:
-        raise JsonInputError("file identity is unavailable") from error
+        raise _FileUnavailableFailure("file identity is unavailable") from error
 
 
 def _change_marker(metadata: os.stat_result) -> _ChangeMarker:
@@ -118,36 +146,40 @@ def _change_marker(metadata: os.stat_result) -> _ChangeMarker:
     try:
         mtime_ns = int(metadata.st_mtime_ns)
     except (AttributeError, TypeError, ValueError, OverflowError) as error:
-        raise JsonInputError("file change marker is unavailable") from error
+        raise _FileUnavailableFailure("file change marker is unavailable") from error
     return _ChangeMarker(identity, mtime_ns)
 
 
 def _check_regular(metadata: os.stat_result) -> _StableIdentity:
     if stat.S_ISLNK(metadata.st_mode) or _is_reparse(metadata):
-        raise JsonInputError("selected path must not be a link or reparse point")
+        raise _FileUnavailableFailure("selected path must not be a link or reparse point")
     if not stat.S_ISREG(metadata.st_mode):
-        raise JsonInputError("selected path must be a regular file")
+        raise _FileUnavailableFailure("selected path must be a regular file")
     identity = _stable_identity(metadata)
-    if not MIN_FILE_BYTES <= identity.size <= MAX_FILE_BYTES:
-        raise JsonInputError("selected file size is outside the fixed limit")
+    if identity.size < MIN_FILE_BYTES:
+        raise _NotUsableGgufFailure("selected file is too small to be GGUF")
+    if identity.size > MAX_FILE_BYTES:
+        raise _FileUnavailableFailure("selected file size is outside the fixed limit")
     return identity
 
 
-def _lstat(path: str | bytes) -> os.stat_result:
+def _lstat(path: str | bytes, *, check: bool = True) -> os.stat_result:
     try:
         metadata = os.lstat(path)
     except (OSError, ValueError) as error:
-        raise JsonInputError("selected file cannot be inspected") from error
-    _check_regular(metadata)
+        raise _FileUnavailableFailure("selected file cannot be inspected") from error
+    if check:
+        _check_regular(metadata)
     return metadata
 
 
-def _fstat(descriptor: int) -> os.stat_result:
+def _fstat(descriptor: int, *, check: bool = True) -> os.stat_result:
     try:
         metadata = os.fstat(descriptor)
     except (OSError, ValueError) as error:
-        raise JsonInputError("opened file identity is unavailable") from error
-    _check_regular(metadata)
+        raise _FileUnavailableFailure("opened file identity is unavailable") from error
+    if check:
+        _check_regular(metadata)
     return metadata
 
 
@@ -164,7 +196,7 @@ def _open_selected(path: str | bytes) -> int:
     try:
         return os.open(path, _open_flags())
     except (OSError, ValueError) as error:
-        raise JsonInputError("selected file cannot be opened") from error
+        raise _FileUnavailableFailure("selected file cannot be opened") from error
 
 
 def _version(evidence: ArtifactEvidence) -> int:
@@ -300,28 +332,70 @@ def observe_file(path: str | os.PathLike[str]) -> dict[str, object]:
     path_identity = _stable_identity(path_before)
     path_marker = _change_marker(path_before)
     descriptor = _open_selected(selected)
+    evidence: ArtifactEvidence | None = None
+    parser_failure: Exception | None = None
     try:
         fd_before = _fstat(descriptor)
         if _stable_identity(fd_before) != path_identity:
-            raise JsonInputError("selected path changed while opening")
+            raise _FileChangedFailure("selected path changed while opening")
         fd_marker = _change_marker(fd_before)
-        evidence = validate_gguf_fd(descriptor)
-        fd_after = _fstat(descriptor)
+        try:
+            evidence = validate_gguf_fd(descriptor)
+        except (
+            JsonInputError,
+            OSError,
+            TypeError,
+            ValueError,
+            OverflowError,
+            AttributeError,
+            RuntimeError,
+        ) as error:
+            # Parser results are deliberately held until the existing safe
+            # post-state checks complete.  A parser refusal is not evidence of
+            # a malformed file when the selected object cannot be rechecked.
+            parser_failure = error
+        fd_after = _fstat(descriptor, check=False)
+        fd_after_identity = _stable_identity(fd_after)
         if _change_marker(fd_after) != fd_marker:
-            raise JsonInputError("selected file changed during observation")
-        path_after = _lstat(selected)
-        if _stable_identity(path_after) != path_identity:
-            raise JsonInputError("selected path changed during observation")
+            raise _FileChangedFailure("selected file changed during observation")
+        _check_regular(fd_after)
+        path_after = _lstat(selected, check=False)
+        path_after_identity = _stable_identity(path_after)
+        if path_after_identity != path_identity:
+            raise _FileChangedFailure("selected path changed during observation")
         if _change_marker(path_after) != path_marker:
-            raise JsonInputError("selected file changed during observation")
-        if _stable_identity(fd_after) != _stable_identity(path_after):
-            raise JsonInputError("selected path changed during observation")
+            raise _FileChangedFailure("selected file changed during observation")
+        if _is_reparse(path_after) != _is_reparse(path_before):
+            raise _FileChangedFailure("selected path changed during observation")
+        _check_regular(path_after)
+        if fd_after_identity != path_after_identity:
+            raise _FileChangedFailure("selected path changed during observation")
     finally:
         try:
             os.close(descriptor)
         except OSError:
             pass
-    return _report(evidence, load_bundled())
+    if parser_failure is not None:
+        if isinstance(parser_failure, JsonInputError):
+            raise _NotUsableGgufFailure("candidate GGUF is not usable") from parser_failure
+        if isinstance(parser_failure, OSError):
+            raise _FileUnavailableFailure("selected file cannot be validated") from parser_failure
+        raise _InternalReportFailure("file evidence parser failed") from parser_failure
+    if evidence is None:
+        raise _InternalReportFailure("file evidence parser returned no result")
+    try:
+        return _report(evidence, load_bundled())
+    except (
+        JsonInputError,
+        OSError,
+        TypeError,
+        ValueError,
+        OverflowError,
+        AttributeError,
+        KeyError,
+        RuntimeError,
+    ) as error:
+        raise _InternalReportFailure("file evidence report failed") from error
 
 
 def observe(path: str | os.PathLike[str]) -> dict[str, object]:
@@ -334,19 +408,29 @@ def _emit_report(report: dict[str, object]) -> None:
     try:
         raw = canonical_bytes(report)
     except (TypeError, ValueError, JsonInputError) as error:
-        raise JsonInputError("report encoding failed") from error
+        raise _InternalReportFailure("report encoding failed") from error
     if len(raw) > MAX_OUTPUT_BYTES:
-        raise JsonInputError("report exceeds the fixed output limit")
+        raise _InternalReportFailure("report exceeds the fixed output limit")
     try:
-        sys.stdout.write(raw.decode("ascii"))
-    except (UnicodeError, OSError) as error:
-        raise JsonInputError("report output failed") from error
-
-
-def _emit_error() -> None:
-    message = ERROR_TEXT
+        expected = len(raw)
+        binary_stdout = getattr(sys.stdout, "buffer", None)
+        if binary_stdout is not None:
+            written = binary_stdout.write(raw)
+        else:
+            text = raw.decode("ascii")
+            written = sys.stdout.write(text)
+        if written != expected:
+            raise _InternalReportFailure("report output failed")
+    except _InternalReportFailure:
+        raise
+    except (UnicodeError, OSError, TypeError, ValueError) as error:
+        raise _InternalReportFailure("report output failed") from error
+
+
+def _emit_error(token: str) -> None:
+    message = f"{token}\n"
     if len(message.encode("ascii")) > MAX_ERROR_BYTES:
-        message = "file evidence error\n"
+        message = f"{INTERNAL_REPORT_FAILURE}\n"
     try:
         sys.stderr.write(message)
     except OSError:
@@ -358,16 +442,27 @@ def main(argv: list[str] | None = None) -> int:
 
     arguments = sys.argv[1:] if argv is None else argv
     if not isinstance(arguments, list) or len(arguments) != 1:
-        _emit_error()
+        _emit_error(USAGE)
         return 2
     try:
         report = observe_file(arguments[0])
         _emit_report(report)
-    except (OSError, TypeError, ValueError, OverflowError):
-        # The command boundary intentionally reveals neither parser details nor
-        # selected-path data.  KeyboardInterrupt/SystemExit remain outside this
-        # ordinary failure path.
-        _emit_error()
+    except _FileUnavailableFailure:
+        _emit_error(FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE)
+        return 2
+    except _NotUsableGgufFailure:
+        _emit_error(NOT_USABLE_GGUF)
+        return 2
+    except _FileChangedFailure:
+        _emit_error(FILE_CHANGED_DURING_OBSERVATION)
+        return 2
+    except _InternalReportFailure:
+        _emit_error(INTERNAL_REPORT_FAILURE)
+        return 2
+    except (OSError, TypeError, ValueError, OverflowError, AttributeError, RuntimeError):
+        # Any untyped ordinary failure remains a fixed internal refusal.  No
+        # exception text or selected-path data crosses the command boundary.
+        _emit_error(INTERNAL_REPORT_FAILURE)
         return 2
     return 0
 

tests/test_gguf_file_observe.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import contextlib
+import hashlib
 import io
 import json
 import stat
@@ -226,5 +227,203 @@ class GgufFileObserveTests(unittest.TestCase):
             self.assertLessEqual(len(stderr.getvalue().encode("utf-8")), observer.MAX_ERROR_BYTES)
 
 
+class GgufFileObserveRefusalDeltaTests(unittest.TestCase):
+    def _run(self, arguments: list[object]) -> tuple[int, str, str]:
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+        with contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+            status = observer.main(arguments)
+        return status, stdout.getvalue(), stderr.getvalue()
+
+    def test_usage_selection_and_parser_tokens_are_fixed(self) -> None:
+        status, stdout, stderr = self._run([])
+        self.assertEqual((2, "", f"{observer.USAGE}\n"), (status, stdout, stderr))
+
+        with tempfile.TemporaryDirectory() as raw:
+            root = Path(raw)
+            status, stdout, stderr = self._run([str(root / "missing")])
+            self.assertEqual(
+                (2, "", f"{observer.FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE}\n"),
+                (status, stdout, stderr),
+            )
+
+            malformed = root / "malformed"
+            malformed.write_bytes(b"x" * observer.MIN_FILE_BYTES)
+            status, stdout, stderr = self._run([str(malformed)])
+            self.assertEqual((2, "", f"{observer.NOT_USABLE_GGUF}\n"), (status, stdout, stderr))
+
+            with patch.object(observer, "validate_gguf_fd", side_effect=OSError("read detail")):
+                status, stdout, stderr = self._run([str(malformed)])
+            self.assertEqual(
+                (2, "", f"{observer.FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE}\n"),
+                (status, stdout, stderr),
+            )
+
+        self.assertLessEqual(len(stderr.encode("ascii")), observer.MAX_ERROR_BYTES)
+
+    def test_parser_fault_categories_are_typed_and_none_is_internal(self) -> None:
+        with tempfile.TemporaryDirectory() as raw:
+            path = Path(raw) / "model"
+            path.write_bytes(gguf())
+            for fault in (
+                TypeError("parser detail"),
+                ValueError("parser detail"),
+                OverflowError("parser detail"),
+                AttributeError("parser detail"),
+                RuntimeError("parser detail"),
+            ):
+                with self.subTest(fault=type(fault).__name__), patch.object(
+                    observer, "validate_gguf_fd", side_effect=fault
+                ):
+                    status, stdout, stderr = self._run([str(path)])
+                self.assertEqual(
+                    (2, "", f"{observer.INTERNAL_REPORT_FAILURE}\n"),
+                    (status, stdout, stderr),
+                )
+
+            with patch.object(observer, "validate_gguf_fd", return_value=None):
+                status, stdout, stderr = self._run([str(path)])
+            self.assertEqual(
+                (2, "", f"{observer.INTERNAL_REPORT_FAILURE}\n"),
+                (status, stdout, stderr),
+            )
+
+            with patch.object(observer, "validate_gguf_fd", side_effect=JsonInputError("header")):
+                status, stdout, stderr = self._run([str(path)])
+            self.assertEqual(
+                (2, "", f"{observer.NOT_USABLE_GGUF}\n"),
+                (status, stdout, stderr),
+            )
+
+            with patch.object(observer, "validate_gguf_fd", side_effect=OSError("read detail")):
+                status, stdout, stderr = self._run([str(path)])
+            self.assertEqual(
+                (2, "", f"{observer.FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE}\n"),
+                (status, stdout, stderr),
+            )
+
+    def test_regular_size_boundary_tokens_are_distinct(self) -> None:
+        with tempfile.TemporaryDirectory() as raw:
+            root = Path(raw)
+            short = root / "short"
+            short.write_bytes(b"x" * (observer.MIN_FILE_BYTES - 1))
+            status, stdout, stderr = self._run([str(short)])
+            self.assertEqual(
+                (2, "", f"{observer.NOT_USABLE_GGUF}\n"),
+                (status, stdout, stderr),
+            )
+
+            oversized = root / "oversized"
+            oversized.write_bytes(gguf())
+            with patch.object(observer, "MAX_FILE_BYTES", observer.MIN_FILE_BYTES):
+                status, stdout, stderr = self._run([str(oversized)])
+            self.assertEqual(
+                (2, "", f"{observer.FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE}\n"),
+                (status, stdout, stderr),
+            )
+
+    def test_existing_malformed_header_variants_use_not_usable_token(self) -> None:
+        invalid = (
+            b"GGUF" + b"\0" * (observer.MIN_FILE_BYTES - 4),
+            b"GGUF" + struct.pack("<IQQ", 1, 1, 0) + b"\0" * 64,
+            gguf(tensors=0),
+            gguf(tensors=10_000_001),
+            gguf(metadata=10_000_001),
+            gguf(tensors=1, metadata=1, padding=0) + b"\0",
+        )
+        with tempfile.TemporaryDirectory() as raw:
+            root = Path(raw)
+            for index, body in enumerate(invalid):
+                path = root / str(index)
+                path.write_bytes(body)
+                with self.subTest(index=index):
+                    status, stdout, stderr = self._run([str(path)])
+                    self.assertEqual(
+                        (2, "", f"{observer.NOT_USABLE_GGUF}\n"),
+                        (status, stdout, stderr),
+                    )
+
+    def test_parser_failure_checks_change_before_selecting_not_usable(self) -> None:
+        with tempfile.TemporaryDirectory() as raw:
+            root = Path(raw)
+            path = root / "model"
+            path.write_bytes(gguf())
+
+            def fail_after_change(descriptor: int) -> object:
+                with path.open("ab") as handle:
+                    handle.write(b"x")
+                raise JsonInputError("parser detail includes a path")
+
+            with patch.object(observer, "validate_gguf_fd", fail_after_change):
+                status, stdout, stderr = self._run([str(path)])
+            self.assertEqual(
+                (2, "", f"{observer.FILE_CHANGED_DURING_OBSERVATION}\n"),
+                (status, stdout, stderr),
+            )
+            self.assertNotIn(observer.NOT_USABLE_GGUF, stderr)
+
+            path.write_bytes(gguf())
+            original_lstat = observer.os.lstat
+            calls = 0
+
+            def fail_post_lstat(value: object) -> object:
+                nonlocal calls
+                calls += 1
+                if calls == 2:
+                    raise OSError("post-state details")
+                return original_lstat(value)
+
+            with (
+                patch.object(observer, "validate_gguf_fd", side_effect=JsonInputError("bad")),
+                patch.object(observer.os, "lstat", side_effect=fail_post_lstat),
+            ):
+                status, stdout, stderr = self._run([str(path)])
+            self.assertEqual(
+                (2, "", f"{observer.FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE}\n"),
+                (status, stdout, stderr),
+            )
+            self.assertNotIn(observer.FILE_CHANGED_DURING_OBSERVATION, stderr)
+            self.assertNotIn(observer.NOT_USABLE_GGUF, stderr)
+
+    def test_report_refusal_is_internal_and_partial_stdout_is_not_rolled_back(self) -> None:
+        with tempfile.TemporaryDirectory() as raw:
+            path = Path(raw) / "model"
+            path.write_bytes(gguf())
+
+            with patch.object(observer, "_report", side_effect=JsonInputError("report detail")):
+                status, stdout, stderr = self._run([str(path)])
+            self.assertEqual((2, "", f"{observer.INTERNAL_REPORT_FAILURE}\n"), (status, stdout, stderr))
+
+            class PartialWriter(io.StringIO):
+                def write(self, value: str) -> int:
+                    super().write(value[:1])
+                    raise OSError("output detail")
+
+            partial = PartialWriter()
+            stderr = io.StringIO()
+            with patch.object(observer.sys, "stdout", partial), contextlib.redirect_stderr(stderr):
+                status = observer.main([str(path)])
+            self.assertEqual(2, status)
+            self.assertTrue(partial.getvalue())
+            self.assertEqual(f"{observer.INTERNAL_REPORT_FAILURE}\n", stderr.getvalue())
+
+    def test_success_bytes_and_direct_api_inheritance_remain_unchanged(self) -> None:
+        with tempfile.TemporaryDirectory() as raw:
+            path = Path(raw) / "model"
+            path.write_bytes(gguf())
+            status, stdout, stderr = self._run([str(path)])
+            self.assertEqual(0, status)
+            self.assertEqual("", stderr)
+            encoded = stdout.encode("ascii")
+            self.assertEqual(2515, len(encoded))
+            self.assertEqual(
+                "cfd215a8867ee289445b27837c64d3b426834217b3953e629a1206201b142c16",
+                hashlib.sha256(encoded).hexdigest(),
+            )
+
+            with self.assertRaises(JsonInputError):
+                observer.observe_file(path.with_name("missing"))
+
+
 if __name__ == "__main__":
     unittest.main()

tests/test_gguf_file_zipapp.py

@@ -5,6 +5,7 @@ import json
 import os
 import shutil
 import stat
+import struct
 import subprocess
 import sys
 import tempfile
@@ -18,7 +19,7 @@ from scripts import build_gguf_file_zipapp as builder
 
 ROOT = Path(__file__).resolve().parents[1]
 BUILDER = ROOT / "scripts" / "build_gguf_file_zipapp.py"
-SOURCE_COMMIT = "5e7e6070fa973016f8ef73e44843e2c4cbbb1f06"
+SOURCE_COMMIT = "7b9b1dcc7242c47c64fcec7d493f1aa5bfc158ef"
 MANIFEST_NAME = "SOURCE-MANIFEST.json"
 MANIFEST_SCHEMA = "lumi-eggcracker.gguf-file-source-manifest.v1"
 MAIN_MODULE = (
@@ -32,7 +33,7 @@ SOURCE_BLOBS = {
     "lumi_eggcracker/detector_catalogue.json": "23d0592f1df359d954f54d057b9a38ac87d85dff",
     "lumi_eggcracker/detectors.py": "3fa79bc6af1295517da4510985d133444c5a962c",
     "lumi_eggcracker/discovery.py": "10cec85df3931c2b4d775484da9e97cc555927a9",
-    "lumi_eggcracker/gguf_file_observe.py": "7463a29d883a324b5c05382c2874f175f5bb4aa0",
+    "lumi_eggcracker/gguf_file_observe.py": "5118cd45cf9183d59c8a07abe468a4045f42d4a0",
     "lumi_eggcracker/jsonio.py": "d09c32d35df2c423aa504f6e178c3820dae765cd",
     "lumi_eggcracker/procfd.py": "1cb27cd57f064eaf9ed1ca0c14146ae46b4191be",
 }
@@ -268,3 +269,104 @@ class GgufFileZipappTests(unittest.TestCase):
         self.assertEqual(nonblock, flags & nonblock)
         fstat.assert_called_once_with(descriptor)
         close.assert_called_once_with(descriptor)
+
+
+class GgufFileZipappRefusalDeltaTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self._archive_temp = tempfile.TemporaryDirectory(prefix="gguf-file-zipapp-archive-")
+        self.addCleanup(self._archive_temp.cleanup)
+        self._fixture_temp = tempfile.TemporaryDirectory(prefix="gguf-file-zipapp-fixtures-")
+        self.addCleanup(self._fixture_temp.cleanup)
+
+        source_archive = ROOT / "examples/gguf-file/lumi-eggcracker-gguf-file.pyz"
+        source_checksum = source_archive.with_name(f"{source_archive.name}.sha256")
+        self._candidate_path = Path(self._archive_temp.name) / source_archive.name
+        self._checksum_path = Path(self._archive_temp.name) / source_checksum.name
+        shutil.copyfile(source_archive, self._candidate_path)
+        shutil.copyfile(source_checksum, self._checksum_path)
+        self._fixture_path = Path(self._fixture_temp.name)
+
+    def _candidate(self) -> Path:
+        return self._candidate_path
+
+    def _scratch(self) -> Path:
+        return self._fixture_path
+
+    def _run_archive(self, candidate: Path, arguments: list[str]) -> subprocess.CompletedProcess[bytes]:
+        environment = os.environ.copy()
+        environment.pop("PYTHONPATH", None)
+        environment["PYTHONDONTWRITEBYTECODE"] = "1"
+        return subprocess.run(
+            [sys.executable, "-B", str(candidate), *arguments],
+            cwd=self._scratch(),
+            env=environment,
+            capture_output=True,
+            check=False,
+        )
+
+    def _assert_refusal(
+        self,
+        result: subprocess.CompletedProcess[bytes],
+        token: str,
+        leaked_path: Path | None = None,
+    ) -> None:
+        self.assertEqual(2, result.returncode)
+        self.assertEqual(b"", result.stdout)
+        self.assertEqual(token.encode("ascii") + os.linesep.encode("ascii"), result.stderr)
+        self.assertLessEqual(len(result.stderr), 128)
+        self.assertTrue(result.stderr.isascii())
+        if leaked_path is not None:
+            encoded_path = os.fsencode(leaked_path)
+            self.assertNotIn(encoded_path, result.stdout + result.stderr)
+
+    def test_packaged_candidate_members_are_canonical_and_pinned(self) -> None:
+        candidate = self._candidate()
+        checksum = Path(f"{candidate}.sha256")
+        digest = hashlib.sha256(candidate.read_bytes()).hexdigest()
+        self.assertEqual(f"{digest}  {candidate.name}\n", checksum.read_text(encoding="ascii"))
+
+        with zipfile.ZipFile(candidate) as archive:
+            infos = archive.infolist()
+            self.assertEqual(sorted(EXPECTED_MEMBERS), [item.filename for item in infos])
+            self.assertEqual(MAIN_MODULE, archive.read("__main__.py"))
+            for name in SOURCE_BLOBS:
+                source = ROOT / ("LICENSE" if name == "LICENSE" else f"src/{name}")
+                self.assertEqual(source.read_bytes(), archive.read(name))
+            manifest_bytes = archive.read(MANIFEST_NAME)
+            manifest = json.loads(manifest_bytes)
+            self.assertEqual(SOURCE_COMMIT, manifest["base_commit"])
+            self.assertEqual(SOURCE_BLOBS, {item["path"]: item["git_blob"] for item in manifest["source_members"]})
+            self.assertEqual(
+                (json.dumps(manifest, sort_keys=True, separators=(",", ":")) + "\n").encode("ascii"),
+                manifest_bytes,
+            )
+
+    def test_packaged_candidate_refusals_and_success_bytes_are_fixed(self) -> None:
+        candidate = self._candidate()
+        scratch = self._scratch()
+        result = self._run_archive(candidate, [])
+        self._assert_refusal(result, "USAGE")
+
+        missing = scratch / "package-delta-missing.gguf"
+        result = self._run_archive(candidate, [str(missing)])
+        self._assert_refusal(result, "FILE_UNAVAILABLE_OR_UNSUPPORTED_TYPE", missing)
+
+        invalid = scratch / "package-delta-invalid.gguf"
+        invalid.write_bytes(b"x" * 25)
+        result = self._run_archive(candidate, [str(invalid)])
+        self._assert_refusal(result, "NOT_USABLE_GGUF", invalid)
+
+        valid = scratch / "package-delta-valid.gguf"
+        valid.write_bytes(b"GGUF" + struct.pack("<IQQ", 3, 1, 0) + b"\0" * 64)
+        result = self._run_archive(candidate, [str(valid)])
+        self.assertEqual(0, result.returncode)
+        self.assertEqual(b"", result.stderr)
+        self.assertEqual(2515, len(result.stdout))
+        self.assertEqual(
+            "cfd215a8867ee289445b27837c64d3b426834217b3953e629a1206201b142c16",
+            hashlib.sha256(result.stdout).hexdigest(),
+        )
+        self.assertTrue(result.stdout.isascii())
+        self.assertNotIn(os.fsencode(valid), result.stdout)
+        parsed = json.loads(result.stdout)
+        self.assertEqual("FILE_EVIDENCE_ONLY", parsed["result"])