letify 2.5.1__tar.gz → 2.5.3__tar.gz

{letify-2.5.1 → letify-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.5.1
+Version: 2.5.3
 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.5.1 → letify-2.5.3}/docs/SPEC.md

@@ -656,7 +656,15 @@ A **persistent channel** keeps one worker process alive behind a pipe pair. Mess
 
 A **one-shot channel** can only run a command and collect its output. Every call starts a fresh process, so nothing persists. It exists because some transports offer nothing more, and it refuses the operations that need persistence rather than pretending.
 
-The worker source cannot be sent on standard input as a script, because `python -` reads to end of file before compiling anything and the pipe has to stay open for requests. A small bootstrap stub passed with `-c` reads one line holding a decimal byte count from `sys.stdin.buffer`, reads that many bytes of UTF-8 worker source, executes them, and leaves standard input where it was. From then on both pipes carry frames only. The stub compares what it read against the count and raises `SystemExit` with `the letify worker source arrived short: <read> of <expected> bytes` rather than compiling a truncated program, because a program cut anywhere fails as a `SyntaxError` at whatever construct the cut landed inside, which names the symptom and hides the cause.
+The worker source cannot be sent on standard input as a script, because `python -` reads to end of file before compiling anything and the pipe has to stay open for requests. A small bootstrap stub passed with `-c` reads one line holding a decimal byte count from `sys.stdin.buffer`, reads that many bytes of UTF-8 worker source, executes them, and leaves standard input where it was. From then on both pipes carry frames only. The count line is `<byte count> <digest>`, where the digest is the first 16 bytes of the source's
+blake2b in hexadecimal, from `hashlib` so the stub needs nothing installed. The stub exits rather
+than compiling when either disagrees: `the letify worker source arrived short: <read> of <expected>
+bytes`, or `the letify worker source arrived corrupted: <read> bytes, digest <found>, expected
+<wanted>`. A program cut or shifted anywhere fails as a `SyntaxError` at whatever construct the
+damage landed inside, which names the symptom and hides the cause. The count alone is not enough,
+because a transport that loses one run of bytes and gains another of the same length keeps the count
+intact: a Kaggle session reported an unterminated triple-quoted string at a line that holds no quote
+in the source, which is what a shifted source looks like and what a digest catches.
 
 ### Frames <!-- id: frames -->
 
@@ -1090,6 +1098,15 @@ A detected path that exists is an input. A detected directory and a detected pat
 
 Any other path is pickled unchanged, so the body receives the local path as it was. Only `os.PathLike` objects are detected. A string that happens to name a local file is left alone, because no rule tells a path from any other string.
 
+One other path is refused rather than pickled unchanged: an `os.PathLike` naming a file or directory that exists on this machine and lies outside every allowed root. Passing it on leaves the body reading a path that is not there, which fails as `FileNotFoundError` on the runtime and names neither the cause nor the rule, and on a runtime where something does sit at that path it reads the wrong bytes instead. So the call raises `ValueError` before it is sent:
+
+```
+<path> is outside the roots letify may send data from. The project root is <root>. Add its
+directory to [tool.letify] data_roots in <root>/pyproject.toml, or move the file inside the root.
+```
+
+A path that exists here and is inside a root is data; a path that does not exist here is a runtime path and still travels unchanged, because that is how a body is told where to write.
+
 A directory is walked without following symbolic links to directories. Regular files and symbolic links to regular files are included. Entries named `.git`, `.venv` and `__pycache__` are skipped.
 
 #### Digests and the digest cache <!-- id: project-data-digests -->
@@ -1282,6 +1299,10 @@ A call that detected data prints one line on standard error:
 
 The line is printed when the call has at least one input file, after the call's outcome is known, because what was sent during the call is not known before then. Sizes are in MiB with one decimal. `<the bucket>` is named when the bytes come from the bucket. `before the call` counts the first wave of The send order and the first wave, `during it` counts what the background sender delivered while the call ran, and the rate covers both. `first access waited` is the wall clock time in which at least one reader was blocked on a blob that had not arrived, and it is `0.0` when the send order was right.
 
+`already on` counts the blobs the runtime answered `data_have` with, not what is left after subtracting what was sent. The two differ whenever a blob was neither already there nor fully sent, and subtracting reports such a blob as having been there all along, which is the opposite of what happened. A blob the background sender was still carrying when the call returned is one of those, so the line ends with `, <files> files <size> dropped when the call ended` whenever there is one, and omits that clause when there is none. A dropped blob is not a failure: the call is over and its bytes are no longer needed, which is why the sender is cancelled. It is reported because a line that accounts for every detected file except the dropped ones cannot be read.
+
+Cancelling the sender removes the partial file of a blob it was writing, in the runtime's blob cache as well as a parallel put's staged ranges. A full sized partial left behind counts against the cache budget and is never completed, because the digest it would be sealed under is only written when every range has arrived.
+
 A call with an output location that returned prints a second line after the write-back:
 
 `letify: data wrote back <files> files <size> in <seconds> s (<rate> MiB/s), <files> files <size> during the call, <files> files <size> already on the client`
@@ -1348,7 +1369,7 @@ Sizes are in MiB with one decimal and `<budget>` in GiB with one decimal.
 
 `letify cache` shows the client digest cache, every local tree letify owns with its file count and size, and each provider's runtime file blob cache. `letify cache clear <target>` (or `letify cache clean <target>`) empties what is safe to clean. Credentials and configuration are never cleaned.
 
-`letify cache` first removes every digest cache entry whose file no longer exists, then prints the digest cache's entry count and how many were removed. It measures every local directory under `~/.letify`: `cache` (including digest cache, filesystem stores, and redirected CLI homes), `tools` (installed binaries), `tmp` (temporary session files), `ssh` (multiplexing control sockets), `runtime` (local provider workspace), and `accounts` (credentials, marked non-cleanable). For each provider in the configuration whose runtime disk persists between sessions, it starts a session on the provider's first instance, asks the worker with one `data_cache` request, and prints the alias, the blob count, the total size and the budget. A provider whose runtime disk does not persist is listed with `not kept between sessions` and no session is started. `--json` prints the same records under `digests`, `local` and `providers`.
+`letify cache` first removes every digest cache entry whose file no longer exists, then prints the digest cache's entry count and how many were removed. It measures every local directory under `~/.letify`: `cache` (including digest cache, filesystem stores, and redirected CLI homes), `tools` (installed binaries), `tmp` (temporary session files), `ssh` (multiplexing control sockets), `runtime` (local provider workspace), and `accounts` (credentials, marked non-cleanable). For each provider in the configuration whose runtime disk persists between sessions and already has a session running, it asks the worker with one `data_cache` request and prints the alias, the blob count, the total size and the budget. It starts a session only where starting one bills nothing, which is a provider whose runtime is this machine: a command that shows what is there must not create what is billed, and a configuration naming several providers would bill for all of them at once to print a listing. A provider with no session running is listed with `no session running`, and a provider whose runtime disk does not persist with `not kept between sessions`. Clearing a named provider still starts a session, because there the user named the provider and asked for the work. `--json` prints the same records under `digests`, `local` and `providers`.
 
 `letify cache clear <target>` (or `letify cache clean <target>`) clears caches:
 1. When `<target>` is a provider alias, it sends `data_cache` with `clear` set to that runtime. The worker removes committed blobs whose link count is 1, and the command prints `<alias>: removed <files> files <size>`.

{letify-2.5.1 → letify-2.5.3}/letify/__init__.py

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

{letify-2.5.1 → letify-2.5.3}/letify/cli.py

@@ -322,8 +322,41 @@ def _setup_tool(args: argparse.Namespace) -> int:
     return 0
 
 
+def _running_runtime(let: Launcher, alias: str):
+    """A session this process already holds on that provider, or None.
+
+    Spec "The cache command": the listing asks only what is already running, because a
+    session it started would bill for the listing.
+    """
+    for runtime in let.pool.live:
+        if getattr(runtime.provider, "alias", None) == alias:
+            return runtime
+    return None
+
+
+def _data_cache_reply(let: Launcher, runtime, clear: bool) -> dict:
+    """One ``data_cache`` request to a session that is already up."""
+    from .store import pathdata
+
+    provider = runtime.provider
+    root = (runtime.workspace or provider.workspace_root).rstrip("/")
+    return runtime.request(
+        {
+            "op": "data_cache",
+            "dir": f"{root}/data/blobs",
+            "budget": pathdata.budget_bytes(provider),
+            "clear": clear,
+        },
+        timeout=600,
+    )
+
+
 def _data_cache_request(let: Launcher, alias: str, clear: bool) -> dict:
-    """Ask a session on the provider's first instance about its file blob cache."""
+    """Ask a session on the provider's first instance about its file blob cache.
+
+    This starts one when none is running, so only a named provider reaches it. Spec "The
+    cache command".
+    """
     from .declare import Env
     from .store import pathdata
 
@@ -462,7 +495,16 @@ def _cache(let: Launcher, args: argparse.Namespace) -> int:
             if not provider.persistent:
                 records.append({"alias": alias, "kept": False})
                 continue
-            result = _data_cache_request(let, alias, False)
+            # Spec "The cache command": a listing bills nothing, so it starts a session
+            # only where starting one is free, and otherwise asks one that is already up.
+            if provider.kind == "local":
+                result = _data_cache_request(let, alias, False)
+            else:
+                runtime = _running_runtime(let, alias)
+                if runtime is None:
+                    records.append({"alias": alias, "kept": True, "running": False})
+                    continue
+                result = _data_cache_reply(let, runtime, False)
         except LetifyError as exc:
             records.append({"alias": alias, "unavailable": str(exc)})
             continue
@@ -470,6 +512,7 @@ def _cache(let: Launcher, args: argparse.Namespace) -> int:
             {
                 "alias": alias,
                 "kept": True,
+                "running": True,
                 "files": result["files"],
                 "bytes": result["bytes"],
                 "budget": result["budget"],
@@ -498,6 +541,8 @@ def _cache(let: Launcher, args: argparse.Namespace) -> int:
             rows.append([row["alias"], f"unavailable: {row['unavailable']}", "", ""])
         elif not row["kept"]:
             rows.append([row["alias"], "not kept between sessions", "", ""])
+        elif not row.get("running"):
+            rows.append([row["alias"], "no session running", "", ""])
         else:
             rows.append(
                 [

{letify-2.5.1 → letify-2.5.3}/letify/protocol/worker.py

@@ -37,17 +37,35 @@ from . import wire as _wire
 #: enough to survive shell quoting reads a byte count line and that many bytes of source,
 #: execs them, and leaves standard input where it was.
 BOOTSTRAP = (
-    "import sys;"
+    "import sys,hashlib;"
     "b=sys.stdin.buffer;"
-    "n=int(b.readline());"
+    "h=b.readline().split();"
+    "n=int(h[0]);"
     "s=b.read(n);"
-    # Spec "Channels": a source cut anywhere compiles as whatever construct the cut landed
-    # inside, or runs and exits without serving, so the count is checked before it is run.
+    # Spec "Channels": a source cut or shifted anywhere compiles as whatever construct the
+    # damage landed inside, or runs and exits without serving. The count catches a cut and
+    # the digest catches a shift, which keeps the count intact.
     "len(s)==n or sys.exit("
     "'the letify worker source arrived short: %d of %d bytes'%(len(s),n));"
+    "d=hashlib.blake2b(s,digest_size=16).hexdigest();"
+    "d==h[1].decode() or sys.exit("
+    "'the letify worker source arrived corrupted: %d bytes, digest %s, expected %s'"
+    "%(len(s),d,h[1].decode()));"
     "exec(compile(s.decode(),'letify-worker','exec'))"
 )
 
+def count_line(body: bytes) -> bytes:
+    """The line the bootstrap stub reads before the source: its length and its digest.
+
+    Spec "Channels": the digest is the first 16 bytes of blake2b in hexadecimal, from
+    ``hashlib`` so the stub needs nothing installed.
+    """
+    import hashlib
+
+    digest = hashlib.blake2b(body, digest_size=16).hexdigest()
+    return b"%d %s\n" % (len(body), digest.encode("ascii"))
+
+
 _BODY = r'''
 import hashlib, io, queue, sys, tarfile, time, traceback
 
@@ -837,6 +855,40 @@ def _parallel_partial(root, digest):
     return "%s%s.parallel" % (_data_file(root, digest), _DATA_PARTIAL)
 
 
+def _op_data_drop(request):
+    """Remove the partials of a blob nobody is going to finish.
+
+    Spec "Data log line": a sender cancelled when the call ended leaves a partial that no
+    later request completes, because the digest it would be sealed under is written only
+    once every piece has arrived. A single put's partial is invisible to the budget scan,
+    so without this it stays for the life of the runtime.
+    """
+    digest = request["digest"]
+    final = _data_file(request["dir"], digest)
+    open_handle = _DATA_OPEN.pop(digest, None)
+    if open_handle is not None:
+        try:
+            open_handle[0].close()
+        except OSError:
+            pass
+    removed = 0
+    directory = os.path.dirname(final)
+    name = os.path.basename(final)
+    try:
+        entries = os.listdir(directory)
+    except OSError:
+        entries = []
+    for entry in entries:
+        if entry == name or not entry.startswith(name + "."):
+            continue
+        try:
+            os.remove(os.path.join(directory, entry))
+            removed += 1
+        except OSError:
+            pass
+    return {"ok": True, "value": removed}
+
+
 def _op_data_begin(request):
     """Make the file parallel senders will fill, of the size it will end up.
 
@@ -2236,6 +2288,7 @@ _OPS = {
     "data_have": _op_data_have,
     "data_put": _op_data_put,
     "data_begin": _op_data_begin,
+    "data_drop": _op_data_drop,
     "data_put_at": _op_data_put_at,
     "data_seal": _op_data_seal,
     "data_pull": _op_data_pull,

{letify-2.5.1 → letify-2.5.3}/letify/providers/kaggle_adapter.py

@@ -31,14 +31,20 @@ UNREACHABLE = 4
 #: The stub the shim starts the worker with, the one Channels describes: a byte count line,
 #: then that many bytes of source.
 STUB = (
-    "import sys;"
+    "import sys,hashlib;"
     "b=sys.stdin.buffer;"
-    "n=int(b.readline());"
+    "h=b.readline().split();"
+    "n=int(h[0]);"
     "s=b.read(n);"
-    # Spec "Channels": a source cut anywhere compiles as whatever construct the cut landed
-    # inside, or runs and exits without serving, so the count is checked before it is run.
+    # Spec "Channels": a source cut or shifted anywhere compiles as whatever construct the
+    # damage landed inside, or runs and exits without serving. The count catches a cut and
+    # the digest catches a shift, which keeps the count intact.
     "len(s)==n or sys.exit("
     "'the letify worker source arrived short: %d of %d bytes'%(len(s),n));"
+    "d=hashlib.blake2b(s,digest_size=16).hexdigest();"
+    "d==h[1].decode() or sys.exit("
+    "'the letify worker source arrived corrupted: %d bytes, digest %s, expected %s'"
+    "%(len(s),d,h[1].decode()));"
     "exec(compile(s.decode(),'letify-worker','exec'))"
 )
 

{letify-2.5.1 → letify-2.5.3}/letify/remoting/device/client.py

@@ -99,9 +99,21 @@ class Pending:
 
 
 #: Passed to ``python -c`` to start the worker: read a length-prefixed source, execute it.
+#: Spec "Channels": the count catches a cut and the digest catches a shift, which keeps the
+#: count intact, so neither failure reaches the compiler as a syntax error.
 BOOTSTRAP = (
-    "import sys;n=int(sys.stdin.buffer.readline());"
-    "exec(compile(sys.stdin.buffer.read(n),'letify-device','exec'))"
+    "import sys,hashlib;"
+    "b=sys.stdin.buffer;"
+    "h=b.readline().split();"
+    "n=int(h[0]);"
+    "s=b.read(n);"
+    "len(s)==n or sys.exit("
+    "'the letify device source arrived short: %d of %d bytes'%(len(s),n));"
+    "d=hashlib.blake2b(s,digest_size=16).hexdigest();"
+    "d==h[1].decode() or sys.exit("
+    "'the letify device source arrived corrupted: %d bytes, digest %s, expected %s'"
+    "%(len(s),d,h[1].decode()));"
+    "exec(compile(s,'letify-device','exec'))"
 )
 
 
@@ -1089,7 +1101,9 @@ def connect(
         target=client._drain_stderr, args=(process.stderr,), name=f"{name}-stderr", daemon=True
     ).start()
     try:
-        transport.raw(b"%d\n" % len(source) + source)
+        from ...protocol.worker import count_line
+
+        transport.raw(count_line(source) + source)
         client.start()
     except (TransportClosed, RuntimeLost) as exc:
         process.kill()

{letify-2.5.1 → letify-2.5.3}/letify/runtime/channel.py

@@ -654,14 +654,14 @@ class FramedChannel(Channel):
 
     def _send_worker(self) -> None:
         """Hand the worker source to the bootstrap stub: a byte count line, then the source."""
-        from ..protocol.worker import source
+        from ..protocol.worker import count_line, source
 
         connection = self._connection
         assert connection is not None
         data = source(text_frames=self.text_frames).encode("utf-8")
         connection.hello = None
         try:
-            connection.sender.raw(b"%d\n" % len(data) + data)
+            connection.sender.raw(count_line(data) + data)
         except OSError:
             # The worker is already gone. Waiting for its hello reports why.
             pass

{letify-2.5.1 → letify-2.5.3}/letify/store/pathdata.py

@@ -370,6 +370,17 @@ class Collector:
         if resolved == project or resolved in project.parents:
             return None
         if not any(_inside(resolved, root) for root in roots):
+            if info is not None:
+                # Spec "Where the bytes come from": a file that exists here and cannot be
+                # sent would travel as a path the body cannot read, which fails on the
+                # runtime naming neither the cause nor this rule, or reads the wrong bytes
+                # where something does sit at that path.
+                raise ValueError(
+                    f"{resolved} is outside the roots letify may send data from. The "
+                    f"project root is {project}. Add its directory to [tool.letify] "
+                    f"data_roots in {project}/pyproject.toml, or move the file inside "
+                    f"the root."
+                )
             return None
         index = len(self.placed)
         placed = Placed(resolved, f"{self.call_dir}/{index}/{resolved.name}", is_dir)
@@ -601,6 +612,9 @@ class Stream:
         self.runtime = runtime
         self.blobs = blobs
         self.plan = plan
+        #: Digests whose send finished. ``_sent`` holds the ones it began, so a blob the
+        #: sender was carrying when the call ended is in one and not the other.
+        self.done: set[str] = set()
         self.before_files = self.before_bytes = 0
         self.during_files = self.during_bytes = 0
         self.before_seconds = self.during_seconds = 0.0
@@ -703,6 +717,22 @@ class Stream:
         if (thread is None or not thread.is_alive()) and self._pipeline is not None:
             self._pipeline.close()
             self._pipeline = None
+        self._drop_partials()
+
+    def _drop_partials(self) -> None:
+        """Remove the partial of every blob the sender was carrying. Spec "Data log line"."""
+        for digest in self.dropped:
+            try:
+                _worker(self.runtime, {"op": "data_drop", "dir": self.blobs, "digest": digest})
+            except (RuntimeFailure, RemoteError):
+                # The runtime is going away, which removes the partial with it.
+                return
+
+    @property
+    def dropped(self) -> list[str]:
+        """Blobs that were neither already on the runtime nor fully sent."""
+        with self._lock:
+            return [digest for digest in self.plan.missing if digest not in self.done]
 
     # -- the stream ---------------------------------------------------------------
 
@@ -760,6 +790,8 @@ class Stream:
         if not uploaded:
             return
         files, total = self.plan.weight(digest)
+        with self._lock:
+            self.done.add(digest)
         if self._thread is None:
             self.before_files += files
             self.before_bytes += total
@@ -780,19 +812,31 @@ class Stream:
 
         stats = stats or {}
         plan = self.plan
-        sent_files = self.before_files + self.during_files
         sent_bytes = self.before_bytes + self.during_bytes
         seconds = self.before_seconds + self.during_seconds
         rate = sent_bytes / (1 << 20) / seconds if seconds > 0 else 0.0
-        install.log(
+        # Spec "Data log line": counted from what the runtime answered data_have with,
+        # because subtracting what was sent reports a blob that was neither as having
+        # been there all along.
+        missing_weight = [plan.weight(digest) for digest in plan.missing]
+        already_files = plan.detected_files - sum(files for files, _b in missing_weight)
+        already_bytes = plan.detected_bytes - sum(total for _f, total in missing_weight)
+        dropped_weight = [plan.weight(digest) for digest in self.dropped]
+        dropped_files = sum(files for files, _b in dropped_weight)
+        dropped_bytes = sum(total for _f, total in dropped_weight)
+        line = (
             f"data {plan.detected_files} files {_mib(plan.detected_bytes)} detected, "
-            f"{plan.detected_files - sent_files} files "
-            f"{_mib(plan.detected_bytes - sent_bytes)} already on {plan.where}, "
+            f"{already_files} files {_mib(already_bytes)} already on {plan.where}, "
             f"sent {self.before_files} files {_mib(self.before_bytes)} before the call in "
             f"{self.before_seconds:.1f} s, {self.during_files} files "
             f"{_mib(self.during_bytes)} during it in {self.during_seconds:.1f} s "
             f"({rate:.1f} MiB/s), first access waited {float(stats.get('seconds', 0.0)):.1f} s"
         )
+        if dropped_files:
+            line += (
+                f", {dropped_files} files {_mib(dropped_bytes)} dropped when the call ended"
+            )
+        install.log(line)
         if stats.get("files"):
             install.log(
                 f"data waited for {stats['files']} files {_mib(int(stats.get('bytes', 0)))} "

{letify-2.5.1 → letify-2.5.3}/letify-core/Cargo.lock

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

{letify-2.5.1 → letify-2.5.3}/letify-core/Cargo.toml

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

{letify-2.5.1 → letify-2.5.3}/letify-ext/package-lock.json

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

{letify-2.5.1 → letify-2.5.3}/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.5.1",
+  "version": "2.5.3",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.5.1 → letify-2.5.3}/pyproject.toml

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

{letify-2.5.1 → letify-2.5.3}/tests/fake_kaggle_adapter.py

@@ -63,13 +63,9 @@ except (urllib.error.URLError, OSError) as exc:
 # The cell a real bridge executes carries a shim, because a kernel answers input() and not a
 # binary read. Here the same shape is a subprocess whose standard input and output are pipes:
 # the bridge copies lines in and out, exactly as it would copy them to input_request replies
-# and from stream messages.
-STUB = (
-    "import sys;"
-    "b=sys.stdin.buffer;"
-    "n=int(b.readline());"
-    "exec(compile(b.read(n).decode(),'letify-worker','exec'))"
-)
+# and from stream messages. The stub is the real one rather than a copy: a copy of it drifted
+# from the real stub when the count line gained a digest, and the drift read as a dead worker.
+from letify.providers.kaggle_adapter import STUB  # noqa: E402
 
 worker = subprocess.Popen(
     [sys.executable, "-u", "-c", STUB],

{letify-2.5.1 → letify-2.5.3}/tests/test_cli.py

@@ -1606,3 +1606,61 @@ def test_stop_orphans_exits_one_when_a_delete_failed(isolated_home, capsys, monk
     )
     assert main(["stop", "--orphans", "-y"]) == 1
     assert "refused" in capsys.readouterr().out
+
+
+def test_the_cache_listing_starts_no_session(isolated_home, monkeypatch, capsys) -> None:
+    """Spec "The cache command": a command that shows what is there starts nothing.
+
+    KICT ran `letify cache` and it booted a Modal CPU session, which then failed its own
+    uv sync. A configuration naming several persistent providers would bill for all of
+    them to print a listing.
+    """
+    import letify
+    from letify.cli import main
+    from letify.runtime import pool
+
+    (isolated_home / ".letify" / "config.toml").write_text(
+        '[lab]\nkind = "shell"\naddress = "gpu.example.edu"\npersistent = true\n',
+        encoding="utf-8",
+    )
+    started: list[str] = []
+
+    real = pool.RuntimePool.acquire
+
+    def watch(self, instance, env, volumes=(), **kwargs):
+        provider = instance.provider
+        started.append(provider.alias)
+        assert provider.kind == "local", f"the listing started a billed session on {provider.alias}"
+        return real(self, instance, env, volumes, **kwargs)
+
+    monkeypatch.setattr(pool.RuntimePool, "acquire", watch)
+    assert main(["cache", "--json"]) == 0
+    assert all(alias == "local" for alias in started), started
+    out = capsys.readouterr().out
+    assert "providers" in out
+    assert letify  # the import is what makes the launcher reachable in this process
+
+
+def test_the_cache_listing_says_a_provider_has_no_session_running(
+    isolated_home, capsys
+) -> None:
+    """Spec "The cache command": a provider with no session is named, not skipped."""
+    import json
+
+    from letify.cli import main
+
+    (isolated_home / ".letify" / "config.toml").write_text(
+        '[lab]\nkind = "shell"\naddress = "gpu.example.edu"\npersistent = true\n',
+        encoding="utf-8",
+    )
+    assert main(["cache", "--json"]) == 0
+    record = json.loads(capsys.readouterr().out)
+    remote = [
+        row
+        for row in record["providers"]
+        if row.get("kept") and row["alias"] != "local"
+    ]
+    assert remote, "no billed persistent provider in the fixture, so this pins nothing"
+    for row in remote:
+        assert row.get("running") is False, row
+        assert "files" not in row, row

{letify-2.5.1 → letify-2.5.3}/tests/test_data.py

@@ -106,9 +106,12 @@ def test_a_path_that_does_not_exist_outside_the_roots_is_left_as_a_plain_path(
     assert not absent.exists()
 
 
-def test_a_path_outside_the_allowed_roots_is_left_as_a_plain_path(
-    let, cpu, project, tmp_path, capsys
-) -> None:
+def test_a_file_outside_the_allowed_roots_is_refused(let, cpu, project, tmp_path) -> None:
+    """Spec "Where the bytes come from": it used to travel as a plain path.
+
+    The body then read a path that is not on the runtime, which failed there as a
+    FileNotFoundError naming neither the cause nor the rule. KICT hit that twice.
+    """
     outside = tmp_path / "elsewhere.txt"
     outside.write_text("not project data", encoding="utf-8")
 
@@ -116,8 +119,9 @@ def test_a_path_outside_the_allowed_roots_is_left_as_a_plain_path(
     def where(path: Path) -> str:
         return str(path)
 
-    assert where(outside) == str(outside)
-    assert data_lines(capsys.readouterr().err) == []
+    with pytest.raises(ValueError) as failure:
+        where(outside)
+    assert "outside the roots letify may send data from" in str(failure.value)
 
 
 def test_a_data_root_named_in_pyproject_is_allowed(let, cpu, project, tmp_path) -> None:
@@ -780,3 +784,40 @@ def test_blobs_a_write_back_adds_keep_the_cache_within_its_budget(
     root = _blobs_root()
     assert sum(p.stat().st_size for p in root.glob("*/*")) <= 20 << 10
     assert len(evictions(capsys.readouterr().err)) == 1
+
+
+def test_a_file_outside_the_allowed_roots_is_refused_rather_than_sent_as_a_path(
+    let, cpu, project, tmp_path
+) -> None:
+    """Spec "Where the bytes come from": passing it on leaves the body reading nothing.
+
+    KICT hit this twice on Kaggle: a shard outside the project root travelled as a plain
+    path and the call died on the runtime with FileNotFoundError naming only the file.
+    """
+    outside = tmp_path / "outside" / "shard.pt"
+    outside.parent.mkdir(parents=True, exist_ok=True)
+    outside.write_bytes(b"x" * 4096)
+
+    @let.function(device=cpu, host="remote")
+    def read(path) -> int:
+        import os
+
+        return os.path.getsize(path)
+
+    with pytest.raises(ValueError) as failure:
+        read(path=outside)
+    message = str(failure.value)
+    assert str(outside) in message
+    assert "data_roots" in message
+    assert "outside the roots letify may send data from" in message
+
+
+def test_a_path_that_does_not_exist_here_still_travels_unchanged(let, cpu, project) -> None:
+    """Spec "Where the bytes come from": that is how a body is told where to write."""
+
+    @let.function(device=cpu, host="remote")
+    def name(path) -> str:
+        return str(path)
+
+    target = Path("/not/on/this/machine/out.pt")
+    assert name(path=target) == str(target)