fix(S2): step 9 — the three narrow HOLD defects

1. THE HARNESS GUARD WAS TOO LOOSE. test_harness_contract.py skipped ANY top-level `if`
   (so `if True: sys.exit(0)` slid through) and broke traversal at the first nested
   FunctionDef (so a module-scope exit inside a top-level `try` was missed). The guard is
   rewritten as a proper recursive walk: it skips ONLY a structurally-recognised
   `__name__ == "__main__"` (a real ast.Compare of __name__ == "__main__"), does NOT
   descend into function / class / lambda scopes, and DOES descend through module-scope
   compound statements (if / try / with / for / while) — so an exit inside `if True:` or a
   top-level `try:` is caught. Added 8 guard self-tests: five that MUST be caught (bare
   exit, `if True:` exit, exit in a top-level try, `raise SystemExit`, exit in a for loop)
   and three that MUST pass (the guarded entrypoint, an exit inside a function, an exit
   inside a lambda).

2. NO-NEWLINE STATE WAS PER-HUNK. old_closed/new_closed reset each hunk, so a no-newline
   marker in the first hunk did not forbid a second hunk after it — the marker means
   EOF-without-newline, so nothing can follow on that side. State is now FILE-level
   (`saw_marker`): once any no-newline marker appears, a following hunk header is a
   PATCH_STRUCTURE refusal (previously it would have slipped to APPLY_CHECK — the right
   refusal via the wrong branch). Added a two-hunk fixture asserting PATCH_STRUCTURE.

3. CLAIM/PUBLICATION EQUALITY WAS NOT PLATFORM-AWARE, AND A POST-mkdir FAILURE LEAKED THE
   DIRECTORY. Both the workdir self-resolution proof and the publication parent re-proof
   used a raw string `realpath(x) != y`, which on case-insensitive Windows disagrees with
   the accepted _same_or_inside rule and could give a casing-only false refusal. A new
   platform-aware `_same_path` (normcase+normpath, the same rule) is now used in both. And
   `_claim_workdir` created the directory before the outer cleanup scope began, so a proof
   failure after the mkdir would strand it — the post-mkdir proofs are now wrapped so the
   just-created directory is removed on ANY failure before raising. Added a pure-function
   regression (symlink-capable platforms): a claim under a symlinked parent fails the
   self-resolution proof with PUBLICATION and leaves NO directory behind, plus _same_path
   platform cases.

Nothing else in Step 9 reopened. Steps 10-12 not started.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JxKjqdGEFzq4UzZupw379G

Author: PhysShell

ownlang/fix_gate.py

@@ -98,12 +98,23 @@ def _canonical_bytes(obj: Any) -> bytes:
     return _canonical_json(obj) + b"\n"
 
 
+def _norm(path: str) -> str:
+    return os.path.normcase(os.path.normpath(path))
+
+
+def _same_path(a: str, b: str) -> bool:
+    """Platform-aware path equality — the SAME rule as _same_or_inside (normcase is
+    identity on POSIX, case-fold on Windows), so `C:\\R\\x` and `c:\\r\\x` compare equal on
+    Windows. A raw string `==` would give a casing-only false refusal."""
+    return _norm(a) == _norm(b)
+
+
 def _same_or_inside(parent: str, path: str) -> bool:
     """Is `path` the directory `parent` itself, or under it? Both must be physical.
     Case sensitivity is a PLATFORM property (normcase is identity on POSIX), so `C:\\Repo`
     and `c:\\repo` are one directory on Windows and two elsewhere."""
-    p = os.path.normcase(os.path.normpath(parent))
-    c = os.path.normcase(os.path.normpath(path))
+    p = _norm(parent)
+    c = _norm(path)
     if c == p:
         return True
     return c.startswith(p if p.endswith(os.sep) else p + os.sep)
@@ -572,10 +583,13 @@ def parse_step8_patch(patch: bytes, rel: str, preimage: bytes) -> None:
     i = 3
     prev_old_end = 0
     saw_hunk = False
-    while i < len(recs):
+    saw_marker = False   # FILE-level: a no-newline marker means EOF-without-newline, so no
+    while i < len(recs):  # further hunk may follow it — the marked line is the file's last.
         rec = recs[i]
         if not (rec.startswith(b"@@ -") and rec.endswith(b" @@")):
             raise GateError(PATCH_STRUCTURE, f"patch: expected a hunk header, got {rec[:40]!r}")
+        if saw_marker:
+            raise GateError(PATCH_STRUCTURE, "patch: a hunk after a no-newline-at-EOF marker")
         body = rec[len(b"@@ -"):-len(b" @@")]
         try:
             old_part, new_part = body.split(b" +", 1)
@@ -614,6 +628,7 @@ def parse_step8_patch(patch: bytes, rel: str, preimage: bytes) -> None:
                     raise GateError(PATCH_STRUCTURE, "patch: duplicate no-newline marker")
                 old_closed = old_closed or marks_old
                 new_closed = new_closed or marks_new
+                saw_marker = True
                 last_head = None
                 i += 1
                 continue
@@ -827,8 +842,11 @@ def _out_parent(out: str, root: str) -> tuple[str, str, str]:
 def _claim_workdir(parent_phys: str) -> str:
     """CLAIM an unpredictable working directory: create it here and now (owner-only on
     POSIX, as part of the mkdir), then PROVE we own it — not a link/reparse, resolving to
-    itself under a platform-aware comparison, and empty. A name that is merely checked and
-    then written into is a window; this closes it."""
+    itself under a PLATFORM-AWARE comparison, and empty. A name that is merely checked and
+    then written into is a window; this closes it. If any proof AFTER the mkdir fails, the
+    directory we just created is removed before raising — no leftover."""
+    import shutil
+
     for _ in range(8):
         path = os.path.join(parent_phys, f".owen-gate-{os.urandom(16).hex()}")
         if os.path.exists(path) or os.path.islink(path):
@@ -840,14 +858,19 @@ def _claim_workdir(parent_phys: str) -> str:
         except OSError as exc:
             raise GateError(PUBLICATION,
                             f"cannot claim a work directory ({exc.strerror or exc})") from exc
-        lst = os.lstat(path)
-        if _is_link(lst):
-            raise GateError(PUBLICATION, "the claimed work directory is a link")
-        if not stat.S_ISDIR(lst.st_mode) or os.path.realpath(path) != path \
-                or not _same_or_inside(parent_phys, os.path.realpath(path)):
-            raise GateError(PUBLICATION, "the claimed work directory does not resolve to itself")
-        if any(os.scandir(path)):
-            raise GateError(PUBLICATION, "the claimed work directory is not empty")
+        try:
+            lst = os.lstat(path)
+            if _is_link(lst):
+                raise GateError(PUBLICATION, "the claimed work directory is a link")
+            if not stat.S_ISDIR(lst.st_mode) or not _same_path(os.path.realpath(path), path) \
+                    or not _same_or_inside(parent_phys, os.path.realpath(path)):
+                raise GateError(PUBLICATION,
+                                "the claimed work directory does not resolve to itself")
+            if any(os.scandir(path)):
+                raise GateError(PUBLICATION, "the claimed work directory is not empty")
+        except BaseException:
+            shutil.rmtree(path, ignore_errors=True)
+            raise
         return path
     raise GateError(PUBLICATION, "could not claim a work directory")
 
@@ -860,7 +883,7 @@ def _publish(staging: str, out_phys: str, evidence: bytes, root_phys: str) -> No
     parent = os.path.dirname(out_phys)
     if not os.path.isdir(parent):
         raise GateError(PUBLICATION, "the out-dir parent vanished before publication")
-    if os.path.realpath(parent) != os.path.dirname(out_phys) \
+    if not _same_path(os.path.realpath(parent), os.path.dirname(out_phys)) \
             or _same_or_inside(root_phys, os.path.realpath(parent)):
         raise GateError(PUBLICATION, "the out-dir parent changed to resolve inside the root")
     if os.path.exists(out_phys) or os.path.islink(out_phys):

tests/test_gate_patch.py

@@ -13,7 +13,9 @@
 
 import hashlib
 import os
+import shutil
 import sys
+import tempfile
 from typing import Any
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -24,7 +26,9 @@
     PATCH_STRUCTURE,
     GateError,
     _bundle_sha256,
+    _claim_workdir,
     _same_or_inside,
+    _same_path,
     parse_step8_patch,
     validate_gate_authority,
     validate_manifest_shape,
@@ -381,10 +385,16 @@ def small(hunk: bytes) -> bytes:
     small(b"@@ -1,1 +1,1 @@\n-a\n\\ No newline at end of file\n"
           b"\\ No newline at end of file\n+z\n"), X, PRE3),
     PATCH_STRUCTURE, "patch: a duplicate no-newline marker")
-# A marker on a line that is NOT the last of its side.
+# A marker on a line that is NOT the last of its side (within the hunk).
 refuses(lambda: parse_step8_patch(
     small(b"@@ -1,2 +1,1 @@\n-a\n\\ No newline at end of file\n-b\n+z\n"), X, PRE3),
     PATCH_STRUCTURE, "patch: marker with more of the same side after it")
+# A marker in an EARLIER hunk: the no-newline is EOF, so no later hunk may follow it. This
+# is the file-level invariant (a per-hunk reset would wrongly accept it).
+refuses(lambda: parse_step8_patch(
+    small(b"@@ -1,1 +1,1 @@\n-a\n\\ No newline at end of file\n+x\n"
+          b"@@ -3,1 +3,1 @@\n-c\n+z\n"), X, PRE3),
+    PATCH_STRUCTURE, "patch: a second hunk after a no-newline marker")
 # A zero-length (insertion) range whose start is past the preimage.
 refuses(lambda: parse_step8_patch(small(b"@@ -99,0 +4,1 @@\n+z\n"), X, PRE3),
         PATCH_STRUCTURE, "patch: an insertion range past the preimage")
@@ -396,6 +406,35 @@ def small(hunk: bytes) -> bytes:
 check(True, "patch: a pure insertion at the top parses")
 
 
+# --- claim cleanup + platform-aware path equality -----------------------------------
+
+check(_same_path("/a/b", "/a/b"), "same_path: identical")
+check(not _same_path("/a/b", "/a/c"), "same_path: different")
+if os.name == "nt":
+    check(_same_path("C:\\A\\B", "c:\\a\\b"), "same_path: Windows case-insensitive")
+else:
+    check(not _same_path("/a/B", "/a/b"), "same_path: POSIX case-sensitive")
+
+# A claim whose self-resolution proof fails (a symlinked parent, so realpath(path) != path)
+# must REMOVE the directory it just created — no leftover. Symlink-capable platforms only.
+_tmp = tempfile.mkdtemp()
+_real = os.path.join(_tmp, "real")
+_link = os.path.join(_tmp, "link")
+os.mkdir(_real)
+try:
+    os.symlink(_real, _link, target_is_directory=True)
+    _have_symlink = True
+except (OSError, NotImplementedError):
+    _have_symlink = False
+if _have_symlink:
+    _before = set(os.listdir(_real))
+    refuses(lambda: _claim_workdir(_link), "PUBLICATION",
+            "claim: a non-self-resolving parent is refused")
+    check(set(os.listdir(_real)) == _before,
+          "claim: a failed proof leaves no directory behind")
+shutil.rmtree(_tmp, ignore_errors=True)
+
+
 # --- containment platform rule -----------------------------------------------------
 
 check(_same_or_inside("/repo", "/repo"), "containment: root contains itself")

tests/test_harness_contract.py

@@ -18,20 +18,35 @@
 _HERE = os.path.dirname(os.path.abspath(__file__))
 
 
-def _module_scope_exit(tree: ast.AST) -> bool:
-    """True if a sys.exit(...) / raise SystemExit(...) sits at module scope (i.e. would
-    fire on import) rather than inside a function or an `if __name__ == '__main__'` guard."""
-    for node in ast.iter_child_nodes(tree):
-        if isinstance(node, ast.If):
-            continue  # the `if __name__ == "__main__"` entrypoint is fine
-        for sub in ast.walk(node):
-            if isinstance(sub, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-                # do not descend into nested scopes for THIS module-scope check
-                break
-            if isinstance(sub, ast.Raise) and _is_systemexit(sub.exc):
-                return True
-            if isinstance(sub, ast.Call) and _is_sys_exit(sub.func):
-                return True
+def _is_main_guard(test: ast.expr) -> bool:
+    """Structurally recognise EXACTLY `__name__ == "__main__"` — not any top-level `if`,
+    so `if True: sys.exit(0)` is NOT waved through."""
+    return (isinstance(test, ast.Compare)
+            and isinstance(test.left, ast.Name) and test.left.id == "__name__"
+            and len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq)
+            and len(test.comparators) == 1
+            and isinstance(test.comparators[0], ast.Constant)
+            and test.comparators[0].value == "__main__")
+
+
+def _module_scope_exit(node: ast.AST) -> bool:
+    """True if a sys.exit(...) / raise SystemExit(...) would fire at IMPORT time. Descends
+    through module-scope compound statements (if / try / with / for / while) but NOT into
+    a new scope (function / class / lambda) and NOT into the `if __name__ == "__main__"`
+    entrypoint — so an exit inside `if True:` or a top-level `try:` IS caught, while the
+    real guard and any function body are not."""
+    for child in ast.iter_child_nodes(node):
+        if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef,
+                              ast.Lambda, ast.ClassDef)):
+            continue  # a new scope: its body does not run on import
+        if isinstance(child, ast.If) and _is_main_guard(child.test):
+            continue  # the sanctioned entrypoint
+        if isinstance(child, ast.Raise) and _is_systemexit(child.exc):
+            return True
+        if isinstance(child, ast.Call) and _is_sys_exit(child.func):
+            return True
+        if _module_scope_exit(child):
+            return True
     return False
 
 
@@ -46,8 +61,34 @@ def _is_sys_exit(func: ast.expr) -> bool:
             and isinstance(func.value, ast.Name) and func.value.id == "sys")
 
 
+_SELFTEST_MUST_CATCH = (
+    ("bare sys.exit at module scope", "import sys\nsys.exit(0)\n"),
+    ("exit inside `if True:`", "import sys\nif True:\n    sys.exit(0)\n"),
+    ("exit inside a top-level try",
+     "import sys\ntry:\n    sys.exit(0)\nexcept Exception:\n    pass\n"),
+    ("raise SystemExit at module scope", "raise SystemExit(1)\n"),
+    ("exit inside a for loop", "import sys\nfor _ in range(1):\n    sys.exit(0)\n"),
+)
+_SELFTEST_MUST_PASS = (
+    ("guarded entrypoint", "import sys\nif __name__ == '__main__':\n    sys.exit(0)\n"),
+    ("exit inside a function", "import sys\ndef run():\n    sys.exit(0)\n"),
+    ("exit inside a lambda", "f = lambda: __import__('sys').exit(0)\n"),
+)
+
+
 def run() -> int:
     global checks
+    # Self-test the guard first: it must catch the ways the original bug could recur, and
+    # must NOT flag the sanctioned entrypoint or an exit that only lives inside a scope.
+    for label, src in _SELFTEST_MUST_CATCH:
+        checks += 1
+        if not _module_scope_exit(ast.parse(src)):
+            failures.append(f"guard self-test: failed to catch {label}")
+    for label, src in _SELFTEST_MUST_PASS:
+        checks += 1
+        if _module_scope_exit(ast.parse(src)):
+            failures.append(f"guard self-test: wrongly flagged {label}")
+
     for fname in sorted(os.listdir(_HERE)):
         if not (fname.startswith("test_") and fname.endswith(".py")):
             continue