Bound automation preflight waits by the run deadline

README.md

@@ -80,6 +80,8 @@ Input JSON:
 
 The client requires an explicitly supplied inference-token environment variable and the existing prepaid-overage-disabled operator attestation. It does not use the saved deployment owner's token for generation. See `python client.py --help` for the current CLI contract. No paid fallback is configured.
 
+`run --max-wall-seconds` applies one deadline across caller/revision checks, client initialization, health/planning waits and inference waits. Timed-out preflight reads cannot advance to GPU submission; late-created clients close. Local staging, journal writes and bounded cleanup add overhead. A post-submission timeout remains an unknown outcome, not permission to retry.
+
 ## Runtime configuration
 
 Default startup serves the UI and non-inference APIs without downloading weights.

client.py

@@ -18,6 +18,7 @@ there is deliberately no resume, retry, cancellation, or token rotation.
 from __future__ import annotations
 
 import argparse
+from concurrent.futures import Future
 from contextlib import contextmanager, redirect_stderr, redirect_stdout, suppress
 from dataclasses import dataclass
 import hashlib
@@ -318,6 +319,39 @@ def _new_client(factory, src, token, downloads=False):
                    httpx_kwargs={"timeout": 20})
 
 
+def _within_deadline(call, deadline, clock, cleanup=None):
+    """Bound a read-only preflight operation, never an inference submission.
+
+    SDK predict/initialization may wait beyond an HTTP request timeout. The
+    daemon performs only this one read; it cannot advance to a GPU submission
+    or update the journal after the caller times out. Late-created clients close.
+    """
+    if clock() >= deadline:
+        raise TimeoutError()
+    future = Future()
+
+    def invoke():
+        try:
+            future.set_result(call())
+        except BaseException as error:
+            future.set_exception(error)
+
+    threading.Thread(target=invoke, name="workflow-preflight", daemon=True).start()
+    try:
+        remaining = deadline - clock()
+        if remaining <= 0:
+            raise TimeoutError()
+        return future.result(timeout=remaining)
+    except BaseException:
+        if cleanup is not None:
+            def close_late(done):
+                with suppress(Exception):
+                    if not done.cancelled() and done.exception() is None:
+                        cleanup(done.result())
+            future.add_done_callback(close_late)
+        raise
+
+
 def _capture(hop, client, job=None):
     session = getattr(client, "session_hash", None)
     if isinstance(session, str):
@@ -418,7 +452,7 @@ def _run(args, request, token, factory, metadata, identity, wrap, clock):
         journal.data["request"] = {"preset_id": request.preset_id, "prompt": request.prompt,
                                    "canvas": request.canvas, "duration": request.duration, "seed": request.seed}
         journal.save()
-        caller = identity(token).get("name")
+        caller = _within_deadline(lambda: identity(token), deadline, clock).get("name")
         if not isinstance(caller, str) or not caller:
             raise AuthenticationRequired()
         if caller.casefold() == "owenisas":
@@ -426,24 +460,28 @@ def _run(args, request, token, factory, metadata, identity, wrap, clock):
         journal.data["caller"] = caller
         for repo, revision in ((GENERATOR_REPO, args.expected_revision),
                                (CONDITIONER_REPO, CONDITIONER_REVISION)):
-            if metadata(repo, token).get("sha") != revision:
+            if _within_deadline(lambda repo=repo: metadata(repo, token), deadline, clock).get("sha") != revision:
                 raise RevisionMismatch()
         downloads = {}
         for name in ("generator", "conditioner"):
             downloads[name] = journal.directory / (name + "-downloads")
             downloads[name].mkdir(mode=0o700)
-        generator = _new_client(factory, GENERATOR, token, downloads["generator"])
+        generator = _within_deadline(
+            lambda: _new_client(factory, GENERATOR, token, downloads["generator"]),
+            deadline, clock, cleanup=lambda client: client.close())
         clients.append(generator)
-        health = generator.predict(api_name="/health")
+        health = _within_deadline(lambda: generator.predict(api_name="/health"), deadline, clock)
         if (not isinstance(health, dict) or health.get("status") != "ready"
                 or health.get("model_loaded") is not True or health.get("blockers") != []
                 or health.get("conditioner_revision") != CONDITIONER_REVISION):
             raise RuntimeNotReady()
         journal.data["health"] = health
-        plan = _plan(generator, request)
+        plan = _within_deadline(lambda: _plan(generator, request), deadline, clock)
         journal.data["plan"] = plan
         journal.save()
-        conditioner = _new_client(factory, CONDITIONER, token, downloads["conditioner"])
+        conditioner = _within_deadline(
+            lambda: _new_client(factory, CONDITIONER, token, downloads["conditioner"]),
+            deadline, clock, cleanup=lambda client: client.close())
         clients.append(conditioner)
 
         def image(name):