letify 2.8.3__tar.gz → 2.8.4__tar.gz

{letify-2.8.3 → letify-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.8.3
+Version: 2.8.4
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs

{letify-2.8.3 → letify-2.8.4}/docs/SPEC.md

@@ -924,6 +924,8 @@ A top-level argument whose serialized size is 64 KiB or more is replaced by a `B
 
 A `bytes` argument is hashed as it is. Any other argument is pickled with protocol 5 and a `buffer_callback` through `codec.pickle_value_parts`, cloudpickle underneath rather than the standard library's `pickle.Pickler`, and the digest is taken over the pickle and then each out-of-band buffer in order, with no joined copy. The digest is blake3 with 16 byte output, or blake2b from the standard library where blake3 is missing.
 
+A digest names its own algorithm. A blake3 digest is the 32 hexadecimal characters of the 16 byte output, unchanged, so every digest already stored in a cache, a volume or Drive stays valid. A digest computed with blake2b because blake3 is missing is `b2-` followed by the 32 hexadecimal characters of the 16 byte blake2b output. Whoever checks a digest picks the algorithm from the digest, through `codec.hasher_for`, so a worker without blake3 and a client with it agree on every blob, archive, write-back file and handoff, and no handshake is needed. A side that cannot compute the algorithm of a digest it was given, a worker without blake3 handed a blake3 digest, does not check it and trusts the sender, and a name it computes itself uses its own algorithm. A placed file is compared by the algorithm of its recorded digest, so a worker without blake3 does not report an unchanged file as an output.
+
 cloudpickle rather than plain `pickle` because a `pickle.Pickler` writes a class or function defined in the caller's own run script as a name reference, `__main__.<name>`, and the worker's own `__main__` is not that script, so unpickling such a blob fails with `AttributeError: Can't get attribute '<name>' on <module '__main__' ...>`. cloudpickle ships such an object by value instead, the same as it already does for the call itself in `codec.dumps_call_parts`, so an argument too large to inline behaves the same as one that is not. The cost of cloudpickle's extra dispatch over plain `pickle` is in the noise: it only intercepts function, class and module objects, not the bulk of a large value, so a 256 MiB buffer or a multi-megabyte list of plain values serializes within a few percent of the same time either way, measured on this machine. There is accordingly no branch between the two picklers.
 
 The digest of an immutable argument is cached on the `Runtime` for the life of the session, so a repeated argument is not hashed again. Immutable means a `bytes` object, or an object that supports weak references and exposes a read-only buffer, such as a NumPy array with `writeable` set to `False`. A `bytes` entry holds a reference to its object so its id cannot be reused, and at most 16 such entries are kept, least recently used first out. Any other argument is pickled and hashed on every call, because it may have changed.
@@ -1088,7 +1090,7 @@ neither side holds it whole:
   returns `{"digest", "size", "dir"}`. The client receives the file with the stream a write-back
   uses, checks the digest as the pieces arrive into a scratch file beside the store, and renames it
   into the store with `Store.adopt_file`. The staging directory is removed afterwards. The digest
-  is the store's content digest (blake3 truncated to 16 bytes, blake2b without blake3).
+  is the store's content digest (blake3 truncated to 16 bytes, or `b2-` and blake2b where the worker has no blake3), and the client checks it with the algorithm the digest names.
 - Restore: a blob of more than one piece (8 MiB) that the store holds as a file is sent with
   `data_put` pieces into a staging directory beside the destination, then moved into place and
   unpacked by the worker op `place_blob`. Smaller blobs, and any blob from a store that does not
@@ -1114,6 +1116,8 @@ the kind this rule exists to catch, and the session that syncs instead both reco
 decides afresh whether the archive is worth keeping. The cost of that is one sync; the cost of
 trusting it is the transfer this rule was measured to avoid.
 
+A failure to cache the environment through the client's own store at boot, the pack, the stream back or the store write, never fails the session: it says `letify: <runtime>: not caching the environment (<reason>)` and the session goes on, the same as a failed pack on the workspace root.
+
 Packing is said, because it is a step that can take minutes and had nothing reporting it:
 `letify: <runtime>: caching the environment, 2.1 GB`. Skipping it is said too, because it is a
 decision letify made rather than a thing that did not
@@ -1949,7 +1953,7 @@ Colab limits outbound UDP to roughly 200 packets per second, so rank 3 is expect
 
 Kaggle reports 2.0 MiB/s, measured on a live account sending 64 MiB over the kernel bridge, and an account overrides it with `fallback_mib_per_s`. Without this a live session refused a punched link at down 8.1 MiB/s for being under the 10 MiB/s floor and then carried 26 GB over the 2 MiB/s bridge instead, which is the opposite of what the floor is for. Taking the fallback is also never silent: the reason is printed, because a session that quietly changed channel is one nobody can account for.
 
-A `channel = "exec"` entry skips the pipeline and uses the fallback directly. A Colab VM has no SSH server on the port letify splices to, so the rendezvous request asks the remote half to start one first. The remote half connects to `127.0.0.1:<ssh_port>`, and when no line starting with `SSH-` arrives within 3 s it installs `openssh-server` if `/usr/sbin/sshd` is missing, creates `/run/sshd`, runs `ssh-keygen -A` so the server has host keys, and starts `/usr/sbin/sshd -p <ssh_port> -o ListenAddress=127.0.0.1`. `ssh-keygen -A` creates only the keys that are missing, and it is needed because a Kaggle image ships `sshd` with no host key at all: the install step above is skipped since the package is already there, and a server with no host key accepts the connection and closes it before the banner, which the client reports as `Connection closed by 127.0.0.1 port <port>` with no reason. The port is explicit because a Colab image ships `sshd` configured for `127.0.0.1:2222`, so starting it with its own configuration leaves port 22 closed. An SSH server that already answers on the port is used as it is. The request carries the account's public key, `key` with `.pub` appended, which the remote side adds to `authorized_keys`. An account with no `key`, or whose `.pub` file is missing, has nothing the VM could authorize, so its Colab rendezvous is unavailable with the reason `no key`: `tcp_punch` and `tailcat` are skipped with that reason and the fallback carries the session. SSH over a punched or Tailcat link logs in as `root` unless `user` says otherwise.
+A `channel = "exec"` entry skips the pipeline and uses the fallback directly. A Colab VM has no SSH server on the port letify splices to, so the rendezvous request asks the remote half to start one first. The remote half connects to `127.0.0.1:<ssh_port>`, and when no line starting with `SSH-` arrives within 3 s it installs `openssh-server` if `/usr/sbin/sshd` is missing, creates `/run/sshd`, runs `ssh-keygen -A` so the server has host keys, and starts `/usr/sbin/sshd -f /etc/ssh/sshd_config.letify -p <ssh_port> -o ListenAddress=127.0.0.1`. That file is the image's `/etc/ssh/sshd_config` with every `MaxStartups` line removed and `MaxStartups 64:30:128` as its first line, or that line alone when the image has no file. A Colab image's file sets `MaxStartups 1`, so the server dropped every connection that arrived while another was still authenticating, and a command-line `-o MaxStartups` does not override the file. Over `reverse_ssh` the transfer streams of a session arrive at once, so every one after the first ended with `Connection closed by 127.0.0.1 port <port>` and the call failed with `the worker exited before it was ready`. With the file, one 190.7 MiB blob crossed a reverse SSH link from a Colab CPU runtime in 5.4 s, 35.5 MiB/s. `ssh-keygen -A` creates only the keys that are missing, and it is needed because a Kaggle image ships `sshd` with no host key at all: the install step above is skipped since the package is already there, and a server with no host key accepts the connection and closes it before the banner, which the client reports as `Connection closed by 127.0.0.1 port <port>` with no reason. The port is explicit because a Colab image ships `sshd` configured for `127.0.0.1:2222`, so starting it with its own configuration leaves port 22 closed. An SSH server that already answers on the port is used as it is. The request carries the account's public key, `key` with `.pub` appended, which the remote side adds to `authorized_keys`. An account with no `key`, or whose `.pub` file is missing, has nothing the VM could authorize, so its Colab rendezvous is unavailable with the reason `no key`: `tcp_punch` and `tailcat` are skipped with that reason and the fallback carries the session. SSH over a punched or Tailcat link logs in as `root` unless `user` says otherwise.
 
 A Colab VM keeps its GPU driver libraries in `/usr/lib64-nvidia`, and only the notebook kernel's own environment names that directory in `LD_LIBRARY_PATH`. A login shell does not, so a worker started over SSH finds no `libnvidia-ml.so` and no `libcuda.so`: `nvidia-smi` fails and `torch.cuda.is_available()` is false on a session that holds a GPU. Every command letify runs over a Colab link, the worker and the `check` command included, is therefore prefixed with `LD_LIBRARY_PATH=/usr/lib64-nvidia${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}`, which keeps a path the machine already set. The `colab exec` fallback needs no prefix, because it runs inside the kernel.
 

{letify-2.8.3 → letify-2.8.4}/letify/__init__.py

@@ -68,7 +68,7 @@ distributed: Final = Host.distributed
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "2.8.3"
+__version__ = "2.8.4"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.8.3 → letify-2.8.4}/letify/protocol/codec.py

@@ -130,6 +130,10 @@ class _CallPickler(cloudpickle.Pickler):
         return super().reducer_override(obj)
 
 
+#: Prefix of a digest computed with blake2b because blake3 was missing. A blake3 digest has none.
+BLAKE2B_PREFIX = "b2-"
+
+
 def _hasher() -> Any:
     """A fresh incremental hasher: blake3 on every core, or blake2b where blake3 is missing."""
     try:
@@ -146,10 +150,28 @@ def new_hasher() -> Any:
     return _hasher()
 
 
+def hasher_for(digest: str) -> Any | None:
+    """A fresh hasher of the algorithm ``digest`` names, or None where it cannot be computed.
+
+    Spec "Argument addressing": a digest names its own algorithm, so a side checking one
+    follows the side that computed it. None means blake3 is missing here and the digest is
+    blake3, so the check cannot be made.
+    """
+    if digest.startswith(BLAKE2B_PREFIX):
+        import hashlib
+
+        return hashlib.blake2b(digest_size=16)
+    try:
+        import blake3
+    except ImportError:
+        return None
+    return blake3.blake3(max_threads=blake3.blake3.AUTO)
+
+
 def finish_digest(hasher: Any) -> str:
-    """The content address a hasher from ``new_hasher`` has accumulated."""
+    """The content address a hasher from ``new_hasher`` or ``hasher_for`` has accumulated."""
     if hasher.name == "blake2b":
-        return str(hasher.hexdigest())
+        return BLAKE2B_PREFIX + str(hasher.hexdigest())
     return str(hasher.hexdigest(length=16))
 
 
@@ -158,14 +180,13 @@ def digest_parts(parts: Iterable[Any]) -> str:
 
     blake3 is preferred because it hashes at several gigabytes per second, which
     keeps hashing orders of magnitude away from being the bottleneck on any real
-    network link. blake2b from the standard library is the fallback.
+    network link. blake2b from the standard library is the fallback, and its digests
+    carry ``BLAKE2B_PREFIX``.
     """
     hasher = _hasher()
     for part in parts:
         hasher.update(part)
-    if hasher.name == "blake2b":
-        return hasher.hexdigest()
-    return hasher.hexdigest(length=16)
+    return finish_digest(hasher)
 
 
 def digest_of(payload: bytes) -> str:
@@ -297,6 +318,7 @@ __all__ = [
     "dumps_call",
     "dumps_call_parts",
     "finish_digest",
+    "hasher_for",
     "new_hasher",
     "parse",
     "split_output",

{letify-2.8.3 → letify-2.8.4}/letify/protocol/worker.py

@@ -247,11 +247,9 @@ def _release_output():
 
 
 def _digest(payload):
-    try:
-        import blake3
-        return blake3.blake3(payload).hexdigest(length=16)
-    except ImportError:
-        return hashlib.blake2b(payload, digest_size=16).hexdigest()
+    hasher = _data_new_hasher()
+    hasher.update(payload)
+    return _data_finish(hasher)
 
 
 def _resolve(value):
@@ -394,20 +392,22 @@ def _letify_replica(replica):
     _replicas._WHO.rate_bps = replica.get("rate_bps")
 
 
-def _data_hash_file(path):
-    """The file digest of a file on the runtime: blake3 when present, else blake2b."""
-    hasher = _data_hasher()
+def _data_hash_file(path, like=None):
+    """The file digest of a file on the runtime: blake3 when present, else blake2b.
+
+    With ``like``, a digest the file may already be named by, the algorithm that digest
+    names is used when it can be, so the result is comparable with it.
+    """
+    hasher = _data_hasher(like) if like is not None else None
     if hasher is None:
-        hasher = hashlib.blake2b(digest_size=16)
+        hasher = _data_new_hasher()
     with open(path, "rb") as handle:
         while True:
             piece = handle.read(1 << 22)
             if not piece:
                 break
             hasher.update(piece)
-    if hasher.name == "blake2b":
-        return hasher.hexdigest()
-    return hasher.hexdigest(length=16)
+    return _data_finish(hasher)
 
 
 def _data_same_bytes(path, digest):
@@ -418,7 +418,7 @@ def _data_same_bytes(path, digest):
     Never raises; a file that cannot be read is not the file the digest promised.
     """
     try:
-        return _data_hash_file(path) == digest
+        return _data_hash_file(path, digest) == digest
     except OSError:
         return False
 
@@ -453,7 +453,7 @@ def _data_collect(data, placed):
             # The placed record ends with the cache stamp, which is not part of the comparison.
             if known is not None and known[1:4] == (info.st_ino, info.st_size, info.st_mtime_ns):
                 continue
-            digest = _data_hash_file(full)
+            digest = _data_hash_file(full, known[0] if known is not None else None)
             if known is not None and known[0] == digest:
                 continue
             final = _data_file(data["blobs"], digest)
@@ -667,7 +667,14 @@ def _data_file(root, digest):
     return os.path.join(root, digest[:2], digest)
 
 
-def _data_hasher():
+def _data_hasher(digest):
+    """A hasher of the algorithm ``digest`` names, or None where it cannot be computed here.
+
+    A digest with the ``b2-`` prefix is blake2b and one without is blake3, so a runtime
+    without blake3 cannot check a blake3 digest and trusts the sender.
+    """
+    if digest.startswith("b2-"):
+        return hashlib.blake2b(digest_size=16)
     try:
         import blake3
     except ImportError:
@@ -675,10 +682,23 @@ def _data_hasher():
     return blake3.blake3(max_threads=blake3.blake3.AUTO)
 
 
+def _data_new_hasher():
+    """The hasher this runtime names new content with: blake3 when present, else blake2b."""
+    hasher = _data_hasher("")
+    return hasher if hasher is not None else hashlib.blake2b(digest_size=16)
+
+
+def _data_finish(hasher):
+    """The digest a hasher has accumulated, with the prefix a blake2b digest carries."""
+    if hasher.name == "blake2b":
+        return "b2-" + hasher.hexdigest()
+    return hasher.hexdigest(length=16)
+
+
 def _data_commit(partial, final, digest, hasher):
     """Rename a received file into the cache once its digest matches, read-only."""
     if hasher is not None:
-        found = hasher.hexdigest(length=16)
+        found = _data_finish(hasher)
         if found != digest:
             os.remove(partial)
             raise ValueError("file blob %s arrived with digest %s" % (digest, found))
@@ -838,7 +858,7 @@ def _op_data_put(request):
         stale = _DATA_OPEN.pop(digest, None)
         if stale is not None:
             stale[0].close()
-        _DATA_OPEN[digest] = (open(partial, "wb"), _data_hasher())
+        _DATA_OPEN[digest] = (open(partial, "wb"), _data_hasher(digest))
     handle, hasher = _DATA_OPEN[digest]
     handle.write(chunk)
     if hasher is not None:
@@ -938,7 +958,7 @@ def _op_data_seal(request):
         raise ValueError(
             "file blob %s is short: %d of %d bytes arrived" % (digest, found, int(size))
         )
-    hasher = _data_hasher()
+    hasher = _data_hasher(digest)
     if hasher is not None:
         with open(partial, "rb") as handle:
             while True:
@@ -946,7 +966,7 @@ def _op_data_seal(request):
                 if not piece:
                     break
                 hasher.update(piece)
-        got = hasher.hexdigest(length=16)
+        got = _data_finish(hasher)
         if got != digest:
             os.remove(partial)
             raise ValueError("file blob %s arrived with digest %s" % (digest, got))
@@ -979,7 +999,7 @@ def _op_data_pull(request):
             partial = "%s.partial.%d.%d" % (final, os.getpid(), threading.get_ident())
             try:
                 os.makedirs(os.path.dirname(final), exist_ok=True)
-                hasher = _data_hasher()
+                hasher = _data_hasher(digest)
                 wanted = urllib.request.Request(url, headers=headers)
                 with urllib.request.urlopen(wanted, timeout=3600) as response, \
                         open(partial, "wb") as out:
@@ -2334,16 +2354,14 @@ def _op_pack_blob(request):
     directory = os.path.expanduser(request["dir"])
     os.makedirs(directory, exist_ok=True)
     partial = os.path.join(directory, ".pack.%d.partial" % os.getpid())
-    hasher = _data_hasher()
-    if hasher is None:
-        hasher = hashlib.blake2b(digest_size=16)
+    hasher = _data_new_hasher()
     try:
         with open(partial, "wb") as handle:
             hashed = _HashedFile(handle, hasher)
             mode = "w:gz" if request.get("gzip", True) else "w"
             with tarfile.open(fileobj=hashed, mode=mode) as archive:
                 archive.add(root, arcname=os.path.basename(root.rstrip("/")), recursive=True)
-        digest = hasher.hexdigest() if hasher.name == "blake2b" else hasher.hexdigest(length=16)
+        digest = _data_finish(hasher)
         final = _data_file(directory, digest)
         os.makedirs(os.path.dirname(final), exist_ok=True)
         os.replace(partial, final)

{letify-2.8.3 → letify-2.8.4}/letify/runtime/session.py

@@ -86,6 +86,13 @@ def _against_the_build(size: int, rate: float, build_s: float) -> str:
     )
 
 
+def _reason_of(error: BaseException) -> str:
+    """One line naming an error's type and first message line, for a status message."""
+    lines = str(error).strip().splitlines()
+    reason = f"{type(error).__name__}: {lines[0]}" if lines else type(error).__name__
+    return reason[:197] + "..." if len(reason) > 200 else reason
+
+
 def _sync_rather_than_restore(archive_bytes: int, rate: float, build_s: float) -> str:
     """The line explaining why a session syncs instead of restoring a cached archive.
 
@@ -243,9 +250,14 @@ class Runtime:
                 if volume.store.backend.moves_on_runtime:
                     self._start_drive_pack(volume, root)
                 else:
-                    volume.cache_env_from(
-                        self, self.env, root, platform=self.platform, build_s=self.env_build_s
-                    )
+                    try:
+                        volume.cache_env_from(
+                            self, self.env, root, platform=self.platform, build_s=self.env_build_s
+                        )
+                    except Exception as error:
+                        # The environment is built and checked, so a failed cache must not
+                        # fail the session. Spec "Materializing into a runtime".
+                        self._say(f"not caching the environment ({_reason_of(error)})")
         self.keep_blobs_on_disk()
         for volume in self.volumes:
             self.attach(volume)
@@ -831,11 +843,7 @@ class Runtime:
             self.eval(source, timeout=3600)
         except Exception as error:
             # The environment is built and checked, so a failed cache must not fail the call.
-            lines = str(error).strip().splitlines()
-            reason = f"{type(error).__name__}: {lines[0]}" if lines else type(error).__name__
-            if len(reason) > 200:
-                reason = reason[:197] + "..."
-            self._say(f"not caching the environment on the workspace root ({reason})")
+            self._say(f"not caching the environment on the workspace root ({_reason_of(error)})")
 
     def _environment_volumes(self) -> tuple[Volume, ...]:
         """Explicit archive volumes, or the automatic cache where the project does not survive.

{letify-2.8.3 → letify-2.8.4}/letify/store/handoff.py

@@ -248,7 +248,13 @@ def unstash(name: str, path: str | os.PathLike[str]) -> Path | None:
 
 
 def _verify(name: str, archive: Path, digest: str) -> None:
-    found = digest_of_file(archive)
+    hasher = codec.hasher_for(digest)
+    if hasher is None:
+        return
+    with open(archive, "rb") as handle:
+        while chunk := handle.read(1 << 20):
+            hasher.update(chunk)
+    found = codec.finish_digest(hasher)
     if found != digest:
         raise RuntimeFailure(
             f"handoff {name!r}: the blob downloaded from Drive has digest {found}, "

{letify-2.8.3 → letify-2.8.4}/letify/store/pathdata.py

@@ -139,9 +139,9 @@ def hash_file(path: Path, size: int) -> str:
         else:
             while chunk := handle.read(1 << 20):
                 hasher.update(chunk)
-    if hasher.name == "blake2b":
-        return hasher.hexdigest()
-    return hasher.hexdigest(length=16)
+    from ..protocol.codec import finish_digest
+
+    return finish_digest(hasher)
 
 
 class DigestCache:
@@ -1608,7 +1608,7 @@ def _get(
     Spec "Writing back". One writing thread takes the pieces, so receiving the next one
     overlaps writing and hashing the one before it and the link does not idle.
     """
-    from ..protocol.codec import _hasher
+    from ..protocol.codec import finish_digest, hasher_for
 
     # Spec "Writing back": a stream that fails after these were created would leave them
     # empty, and a resume that picks the newest directory by name then trusts a checkpoint
@@ -1617,7 +1617,8 @@ def _get(
     partial = target.with_name(
         f".{target.name}.letify-partial.{os.getpid()}.{threading.get_ident()}"
     )
-    hasher = _hasher()
+    # The algorithm the digest names, which is the worker's when its venv has no blake3.
+    hasher = hasher_for(digest)
     pieces: queue.Queue = queue.Queue(maxsize=WRITE_QUEUE)
     failure: list[BaseException] = []
 
@@ -1630,7 +1631,8 @@ def _get(
                     if piece is None:
                         return
                     handle.write(piece)
-                    hasher.update(piece)
+                    if hasher is not None:
+                        hasher.update(piece)
         except BaseException as exc:  # pragma: no cover - a local disk failure
             failure.append(exc)
             # Drained, so the receiving thread is never left waiting on a full queue.
@@ -1657,7 +1659,7 @@ def _get(
             raise RuntimeFailure(
                 f"{runtime.name}: file blob {digest} arrived with {received} bytes, not {size}"
             )
-        found = hasher.hexdigest() if hasher.name == "blake2b" else hasher.hexdigest(length=16)
+        found = finish_digest(hasher) if hasher is not None else digest
         if found != digest:
             raise RuntimeFailure(f"{runtime.name}: file blob {digest} arrived with digest {found}")
         os.replace(partial, target)

{letify-2.8.3 → letify-2.8.4}/letify/transport/nat.py

@@ -659,6 +659,31 @@ def _authorize(public_key: str) -> None:
 #: The SSH server binary the remote half starts on a machine that has none on the port.
 SSHD = "/usr/sbin/sshd"
 
+#: The image's own server configuration, which the started server's is copied from.
+SSHD_CONFIG = "/etc/ssh/sshd_config"
+
+#: The configuration the remote half starts the server with.
+LETIFY_SSHD_CONFIG = "/etc/ssh/sshd_config.letify"
+
+#: Unauthenticated connections the server takes at once. Spec "Colab": a Colab image sets 1,
+#: and the transfer streams of one session arrive together.
+SSHD_MAX_STARTUPS = "64:30:128"
+
+
+def _write_sshd_config(source: str, target: str) -> None:
+    """Copy ``source`` to ``target`` with its MaxStartups replaced by ``SSHD_MAX_STARTUPS``.
+
+    A command-line ``-o MaxStartups`` does not override the file's value, so the file the
+    server reads has to carry it.
+    """
+    try:
+        lines = Path(source).read_text().splitlines()
+    except OSError:
+        lines = []
+    kept = [line for line in lines if not line.strip().lower().startswith("maxstartups")]
+    # First, ahead of any Match block, so it applies to the whole server.
+    Path(target).write_text("\n".join([f"MaxStartups {SSHD_MAX_STARTUPS}", *kept]) + "\n")
+
 
 def _ssh_answers(port: int, timeout: float = 3.0) -> bool:
     """Whether a line starting with ``SSH-`` arrives from ``127.0.0.1:<port>``."""
@@ -691,7 +716,11 @@ def _start_sshd(port: int = 22) -> None:
     # server closes every connection before the banner. ssh-keygen -A makes only what is
     # missing, so an image that already has its keys is untouched.
     subprocess.run(["ssh-keygen", "-A"], check=False)
-    subprocess.run([SSHD, "-p", str(port), "-o", "ListenAddress=127.0.0.1"], check=False)
+    _write_sshd_config(SSHD_CONFIG, LETIFY_SSHD_CONFIG)
+    subprocess.run(
+        [SSHD, "-f", LETIFY_SSHD_CONFIG, "-p", str(port), "-o", "ListenAddress=127.0.0.1"],
+        check=False,
+    )
 
 
 def run_detached(request_json: str, source: str) -> None:  # pragma: no cover - remote entry

{letify-2.8.3 → letify-2.8.4}/letify-core/Cargo.lock

@@ -138,7 +138,7 @@ dependencies = [
 
 [[package]]
 name = "letify-agent"
-version = "2.8.3"
+version = "2.8.4"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "2.8.3"
+version = "2.8.4"
 dependencies = [
  "letify-wire",
 ]
@@ -164,7 +164,7 @@ dependencies = [
 
 [[package]]
 name = "letify-wire"
-version = "2.8.3"
+version = "2.8.4"
 
 [[package]]
 name = "libc"

{letify-2.8.3 → letify-2.8.4}/letify-core/Cargo.toml

@@ -8,7 +8,7 @@ resolver = "3"
 members = ["letify-wire", "letify-driver", "letify-agent", "letify-quic"]
 
 [workspace.package]
-version = "2.8.3"
+version = "2.8.4"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

{letify-2.8.3 → letify-2.8.4}/letify-ext/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "letify-status",
-  "version": "2.8.3",
+  "version": "2.8.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "letify-status",
-      "version": "2.8.3",
+      "version": "2.8.4",
       "license": "SEE LICENSE IN LICENSE",
       "devDependencies": {
         "@types/node": "^18.19.0",

{letify-2.8.3 → letify-2.8.4}/letify-ext/package.json

@@ -2,7 +2,7 @@
   "name": "letify-status",
   "displayName": "letify Status",
   "description": "letify quota and GPU activity in the status bar, read from the letify CLI.",
-  "version": "2.8.3",
+  "version": "2.8.4",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.8.3 → letify-2.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "letify"
-version = "2.8.3"
+version = "2.8.4"
 description = "Declarations that become infrastructure."
 readme = "README.md"
 requires-python = ">=3.11"

{letify-2.8.3 → letify-2.8.4}/tests/conftest.py

@@ -124,6 +124,23 @@ class PreparingLocal(Local):
     remote_env = True
 
 
+class NoBlake3Local(Local):
+    """A local provider whose worker cannot import blake3, like a runtime venv without letify.
+
+    The worker is the real one behind the real framed protocol. Hiding the module before
+    the bootstrap runs makes it hash with blake2b, which the client then has to follow.
+    """
+
+    def open_channel(self, runtime: Any) -> Any:
+        from letify.protocol.worker import BOOTSTRAP
+        from letify.runtime.channel import PersistentChannel
+
+        hide = "import sys; sys.modules['blake3'] = None\n"
+        return PersistentChannel(
+            [sys.executable, "-u", "-c", hide + BOOTSTRAP], name=runtime.name
+        )
+
+
 @pytest.fixture
 def uv_project(tmp_path: Path, monkeypatch) -> Path:
     """A tiny uv project that depends on this checkout of letify, locked with the real uv.

{letify-2.8.3 → letify-2.8.4}/tests/test_protocol.py

@@ -60,8 +60,10 @@ def test_content_addressing_falls_back_to_the_standard_library(no_module) -> Non
     # blake3 is preferred for speed, but it is a wheel, so blake2b has to carry the same
     # guarantee when it is absent.
     no_module("blake3")
+    # Its digests carry the b2- prefix, so a side with blake3 does not mistake them for its own.
     digest = codec.digest_of(b"same contents")
-    assert len(digest) == 32
+    assert digest.startswith("b2-")
+    assert len(digest) == 35
     assert digest == codec.digest_of(b"same contents")
 
 

{letify-2.8.3 → letify-2.8.4}/tests/test_runtime.py

@@ -2982,3 +2982,37 @@ def test_a_small_environment_is_still_packed_and_says_so(
         runtime.shutdown()
     assert volume.cached_env(env, platform)
     assert "caching the environment" in capsys.readouterr().err
+
+
+def test_a_failure_to_cache_the_environment_through_the_client_store_does_not_fail_the_session(
+    uv_project: Path, tmp_path: Path, monkeypatch, capsys
+) -> None:
+    # Spec "Materializing into a runtime": a failed cache at boot is said and the
+    # session goes on, the same as a failed pack on the workspace root.
+    from letify.runtime.session import Runtime
+    from letify.store.volume import Volume
+
+    provider = provider_of(PreparingLocal, "lab", persistent=False)
+    volume = provider.volume(
+        "cache", backend="filesystem", root=str(tmp_path / "store"), mount=str(tmp_path / "mount")
+    )
+    env = Env()
+    instance = Instance(provider, gpu=None)._placed("remote")
+    real = Runtime.install_env
+
+    def slow_build(self: Runtime) -> None:
+        real(self)
+        self.env_build_s = 10_000.0
+
+    def refuse(*args: object, **kwargs: object) -> str:
+        raise RuntimeFailure("lab-1: file blob 9870 arrived with digest d0aa")
+
+    monkeypatch.setattr(Runtime, "install_env", slow_build)
+    monkeypatch.setattr(Volume, "cache_env_from", refuse)
+    runtime = provider.start(instance, env, name="lab-1", volumes=(volume,))
+    try:
+        assert runtime.ready
+    finally:
+        runtime.shutdown()
+    err = capsys.readouterr().err
+    assert "not caching the environment (RuntimeFailure: lab-1: file blob 9870" in err, err

{letify-2.8.3 → letify-2.8.4}/tests/test_store.py

@@ -875,3 +875,57 @@ def test_a_one_shot_runtime_pulls_an_archive_without_relaying_it_through_the_cli
     blobs = [r for r in fake_gcs.downloads() if "/blobs/" in unquote(r["path"])]
     assert [r["authorization"] for r in blobs] == ["Bearer down-token-1"]
     let.pool.shutdown()
+
+
+# -- Spec: Argument addressing, a digest names its own algorithm -----------------
+
+
+def test_an_environment_packed_by_a_worker_without_blake3_is_checked_with_blake2b(
+    tmp_path: Path,
+) -> None:
+    # The worker hashes the archive with blake2b because its venv has no blake3. The
+    # client has blake3, so a client that checked with its own algorithm called the same
+    # bytes corrupted: "file blob ... arrived with digest ...".
+    from conftest import NoBlake3Local, provider_of
+
+    from letify.declare.env import Env
+    from letify.declare.instance import Instance
+
+    provider = provider_of(NoBlake3Local, "nob3")
+    volume = provider.volume("cache", backend="filesystem", root=str(tmp_path / "store"))
+    runtime = provider.start(
+        Instance(provider, gpu=None)._placed("remote"), Env(lock=str(tmp_path / "x.lock")),
+        name="nob3-1",
+    )
+    try:
+        installed = tmp_path / "site"
+        installed.mkdir()
+        (installed / "marker.txt").write_text("installed", encoding="utf-8")
+        digest = volume.cache_env_from(runtime, Env(lock=str(tmp_path / "x.lock")), str(installed))
+    finally:
+        runtime.shutdown()
+    assert digest.startswith("b2-")
+    assert volume.store.backend.has(digest)
+
+
+def test_a_digest_is_checked_with_the_algorithm_it_names() -> None:
+    from letify.protocol import codec
+
+    hasher = codec.hasher_for("b2-" + "0" * 32)
+    hasher.update(b"x")
+    assert codec.finish_digest(hasher).startswith("b2-")
+    other = codec.hasher_for("0" * 32)
+    other.update(b"x")
+    assert not codec.finish_digest(other).startswith("b2-")
+    assert codec.digest_of(b"x") == codec.finish_digest(other)
+
+
+def test_blake2b_is_named_by_a_prefix_when_blake3_is_missing(no_module) -> None:
+    from letify.protocol import codec
+
+    no_module("blake3")
+    digest = codec.digest_of(b"same contents")
+    assert digest.startswith("b2-")
+    assert len(digest) == 35
+    assert codec.hasher_for("0" * 32) is None
+    assert codec.hasher_for(digest).name == "blake2b"