feat: update admission gate - entries refuse while an update runs (Issue #72, decision 8, U2)

The update skill publishes .mam/update-in-progress (pid + lstart, the
loop_lock.sh rules) while it holds .mam/update-admission.lock exclusively.
create, resume, run_loop.sh and delegate submit (decision 8) and stop and
orc-onboard (U2: a rollback would restore the registry without their write)
take that lock shared (lib.sh mam_update_admit, fd 7), refuse while the marker
is live or unknown, and hold the lock until their record is written. A stale
marker refuses nothing. lib_py.pane_lock acquire gains --shared and
--wait-env (MAM_UPDATE_ADMISSION_WAIT_S, default 120); create's wrapper path
closes fd 7 for the long-lived child. The exit-1 rows of create/resume/stop
name the refusal; skill_code_blocks.json pins follow the shifted lines.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.agents/skills/lib_py/pane_lock.py

@@ -18,6 +18,9 @@ one lock per server from the choice to the claim.
   pane_lock.py acquire --fd N     flock(LOCK_EX) on the inherited fd N; prints
                                   `locked`, or `timeout` once MAM_PANE_CLAIM_WAIT_S
                                   (default 120, minimum 1) has passed
+     [--shared] [--wait-env VAR]  Issue #72: LOCK_SH instead, and the wait read
+                                  from VAR (same default and minimum) - the
+                                  update admission lock (lib.sh mam_update_admit)
 
 The lock is a BSD flock, which belongs to the open file on fd 9: it outlives
 this helper and ends when the last process holding that fd ends, however it
@@ -63,11 +66,11 @@ def lock_path(session: Optional[str], env: Mapping[str, str]) -> str:
     return os.path.join(home, ".local", "state", "mam", "pane-lock", session + ".lock")
 
 
-def wait_s(env: Mapping[str, str]) -> int:
-    return ints.positive_int(env.get("MAM_PANE_CLAIM_WAIT_S"), 1) or DEFAULT_WAIT_S
+def wait_s(env: Mapping[str, str], var: str = "MAM_PANE_CLAIM_WAIT_S") -> int:
+    return ints.positive_int(env.get(var), 1) or DEFAULT_WAIT_S
 
 
-def acquire(fd: int, wait: float) -> str:
+def acquire(fd: int, wait: float, shared: bool = False) -> str:
     """`locked`, or `timeout` when the lock was not free within `wait` s. The
     deadline is on the monotonic clock; a step of the wall clock does not
     stretch or cut it. Only contention is waited out: any other error (a bad
@@ -75,7 +78,7 @@ def acquire(fd: int, wait: float) -> str:
     deadline = time.monotonic() + wait
     while True:
         try:
-            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            fcntl.flock(fd, (fcntl.LOCK_SH if shared else fcntl.LOCK_EX) | fcntl.LOCK_NB)
             return "locked"
         except BlockingIOError:
             if time.monotonic() >= deadline:
@@ -90,11 +93,13 @@ def main(argv: Optional[List[str]] = None) -> int:
     s.add_argument("--session", default="")
     s = sub.add_parser("acquire")
     s.add_argument("--fd", type=int, required=True)
+    s.add_argument("--shared", action="store_true")
+    s.add_argument("--wait-env", default="MAM_PANE_CLAIM_WAIT_S")
     a = p.parse_args(argv)
     if a.cmd == "path":
         print(lock_path(a.session, os.environ))
     else:
-        print(acquire(a.fd, wait_s(os.environ)))
+        print(acquire(a.fd, wait_s(os.environ, a.wait_env), a.shared))
     return 0