ccx-native 0.1.0 → 0.2.0

package/README.md

@@ -1,11 +1,10 @@
 # ccx
 
-**Control and monitor native Claude Code and Codex sessions from the CLI, Python
-or RPC.**
+**Run native Claude Code and Codex as persistent shared workers.**
 
-You, your agents and your scripts share the same persistent sessions. They run
-on your own Claude and ChatGPT subscriptions with your existing setup, and you
-can open any of them live with `ccx attach`.
+You, your agents and your scripts can all start, message, steer and check on the
+same workers. They run on your own Claude and ChatGPT subscriptions with your
+existing setup, and you can open any of them live with `ccx attach`.
 
 ```bash
 npm install -g ccx-native

package/ccx/__init__.py

@@ -56,6 +56,8 @@ from .types import (
     CompactOperationResult,
     CompactResult,
     Event,
+    ModelCatalog,
+    ModelInfo,
     PendingInput,
     Question,
     Report,
@@ -146,6 +148,8 @@ __all__ = [
     "CompactOperationResult",
     "WaitResult",
     "Event",
+    "ModelCatalog",
+    "ModelInfo",
     "Usage",
     # Codex types
     "CodexSessionInfo",

package/ccx/claude/attach.py

@@ -1,4 +1,4 @@
-"""One authenticated, bounded shared terminal stream for a managed Claude PTY.
+"""Authenticated, bounded shared terminal streams for a managed Claude PTY.
 
 Only the host select loop reads/writes the PTY.  This module owns framing and
 local TTY lifecycle; it never launches, parks or resumes a native Claude.
@@ -27,6 +27,7 @@ MAX_PENDING_INPUT = 64 * 1024
 MAX_PENDING_OUTPUT = 1024 * 1024
 MAX_ATTACH_LINE = 48 * 1024  # 32 KiB base64 + envelope
 MAX_DIMENSION = 1000
+MAX_VIEWERS = 8  # terminals attached to one worker at once
 
 
 def frame(op: str, **fields) -> bytes:
@@ -52,8 +53,23 @@ def decode_input(data) -> bytes:
     return raw
 
 
+class _Viewer:
+    """One attached terminal: its lease token, size and byte queues."""
+
+    def __init__(self, rows, cols):
+        self.token = uuid.uuid4().hex
+        self.size = (rows, cols)
+        self.input = bytearray()
+        self.output = bytearray()
+
+
 class HostAttachment:
-    """Hot-only lease and byte queues. Host invokes all methods on its I/O loop."""
+    """Hot-only leases and byte queues for up to MAX_VIEWERS terminals.
+
+    Every terminal sees the same PTY output and may type. The PTY takes the
+    smallest rows and columns among them, so each one displays correctly.
+    The host invokes all methods on its I/O loop.
+    """
 
     def __init__(self, master_fd, resize, event, disconnect, on_release):
         self.master_fd = master_fd
@@ -61,121 +77,150 @@ class HostAttachment:
         self.event = event
         self.disconnect = disconnect
         self.on_release = on_release
-        self.conn = None
-        self.token = None
-        self.input = bytearray()
-        self.output = bytearray()
+        self.viewers: dict = {}
         self.saved_size = None
-        self.requested = None
         self.repaint_at = None
 
     @property
     def attached(self):
-        return self.conn is not None
+        return bool(self.viewers)
+
+    def has(self, conn):
+        return conn in self.viewers
+
+    def pending(self):
+        """Connections with queued output (the host's select write set)."""
+        return [conn for conn, viewer in self.viewers.items() if viewer.output]
+
+    def busy(self):
+        return self.repaint_at is not None or any(
+            viewer.input or viewer.output for viewer in self.viewers.values())
+
+    def size(self):
+        return (min(v.size[0] for v in self.viewers.values()),
+                min(v.size[1] for v in self.viewers.values()))
 
     def open(self, conn, msg, *, epoch):
-        if self.attached:
-            return {"ok": False, "error": "another terminal is already attached"}
+        if conn in self.viewers:
+            return {"ok": False, "error": "this connection is already attached"}
+        if len(self.viewers) >= MAX_VIEWERS:
+            return {"ok": False, "error": f"too many terminals attached (max {MAX_VIEWERS})"}
         if msg.get("version") != VERSION or type(msg.get("version")) is not int:
             return {"ok": False, "error": "unsupported shared attach protocol version"}
         try:
             rows, cols = dimensions(msg.get("rows"), msg.get("cols"))
-            saved = fcntl.ioctl(self.master_fd, termios.TIOCGWINSZ, b"\0" * 8)
-            # Save the complete ioctl payload, including pixel dimensions.
-            if len(saved) != 8:
-                raise OSError("PTY size unavailable")
-            self.resize(rows, cols - 1 if cols > 1 else 2)
+            saved = self.saved_size
+            if saved is None:
+                saved = fcntl.ioctl(self.master_fd, termios.TIOCGWINSZ, b"\0" * 8)
+                # Save the complete ioctl payload, including pixel dimensions.
+                if len(saved) != 8:
+                    raise OSError("PTY size unavailable")
+            viewer = _Viewer(rows, cols)
+            self.viewers[conn] = viewer
+            try:
+                # A one-column nudge makes Claude redraw for the newcomer.
+                rows, cols = self.size()
+                self.resize(rows, cols - 1 if cols > 1 else 2)
+            except OSError:
+                del self.viewers[conn]
+                raise
         except (ValueError, OSError) as exc:
             return {"ok": False, "error": str(exc)}
-        self.conn = conn
-        self.token = uuid.uuid4().hex
         self.saved_size = saved
-        self.requested = (rows, cols)
         self.repaint_at = time.monotonic() + .12
-        self.input.clear()
-        self.output.clear()
         self.event({"type": "attach_opened"})
         return {"ok": True, "op": "attach-opened", "version": VERSION,
-                "token": self.token, "epoch": epoch}
+                "token": viewer.token, "epoch": epoch}
 
     def owns(self, conn, msg):
-        return (self.conn is conn and isinstance(msg.get("token"), str)
-                and msg["token"] == self.token)
+        viewer = self.viewers.get(conn)
+        return (viewer is not None and isinstance(msg.get("token"), str)
+                and msg["token"] == viewer.token)
 
     def accept_input(self, conn, msg):
         if not self.owns(conn, msg):
             raise ValueError("invalid attachment token or connection")
         raw = decode_input(msg.get("data"))
-        if len(self.input) + len(raw) > MAX_PENDING_INPUT:
+        viewer = self.viewers[conn]
+        if len(viewer.input) + len(raw) > MAX_PENDING_INPUT:
             self.release(conn, "input-overflow")
             self.disconnect(conn)
             return
-        self.input.extend(raw)
+        viewer.input.extend(raw)
 
     def accept_resize(self, conn, msg):
         if not self.owns(conn, msg):
             raise ValueError("invalid attachment token or connection")
-        rows, cols = dimensions(msg.get("rows"), msg.get("cols"))
-        self.requested = (rows, cols)
+        self.viewers[conn].size = dimensions(msg.get("rows"), msg.get("cols"))
         if self.repaint_at is None:
-            self.resize(rows, cols)
+            self.resize(*self.size())
 
     def tick(self, write):
-        if self.conn is None:
+        if not self.viewers:
             return
         if self.repaint_at is not None and time.monotonic() >= self.repaint_at:
             self.repaint_at = None
-            self.resize(*self.requested)
-        if self.input:
-            # Fairness: at most one small PTY write, then serve ordinary RPCs.
-            part = bytes(self.input[:4096])
-            del self.input[:len(part)]
+            self.resize(*self.size())
+        for conn, viewer in list(self.viewers.items()):
+            if not viewer.input:
+                continue
+            # Fairness: at most one small PTY write per terminal, then serve
+            # ordinary RPCs.
+            part = bytes(viewer.input[:4096])
+            del viewer.input[:len(part)]
             if not write(part):
-                conn = self.conn
                 self.release(conn, "pty-write-error")
                 self.disconnect(conn)
 
     def feed_output(self, data: bytes):
-        if not self.attached or not data:
+        if not self.viewers or not data:
             return
         packet = frame("attach-output", data=base64.b64encode(data).decode("ascii"))
-        if len(self.output) + len(packet) > MAX_PENDING_OUTPUT:
-            conn = self.conn
-            self.release(conn, "output-overflow")
-            self.disconnect(conn)
-        else:
-            self.output.extend(packet)
+        for conn, viewer in list(self.viewers.items()):
+            if len(viewer.output) + len(packet) > MAX_PENDING_OUTPUT:
+                # A terminal that fell behind is dropped on its own.
+                self.release(conn, "output-overflow")
+                self.disconnect(conn)
+            else:
+                viewer.output.extend(packet)
 
-    def flush(self):
-        if not self.attached or not self.output:
+    def flush(self, conn):
+        viewer = self.viewers.get(conn)
+        if viewer is None or not viewer.output:
             return
-        conn = self.conn
         try:
-            sent = conn.send(self.output[:32768])
+            sent = conn.send(viewer.output[:32768])
             if not sent:
                 raise OSError("attachment connection closed")
-            del self.output[:sent]
+            del viewer.output[:sent]
         except BlockingIOError:
             return
         except OSError:
             self.release(conn, "connection-lost")
             self.disconnect(conn)
 
+    def release_all(self, reason):
+        for conn in list(self.viewers):
+            self.release(conn, reason)
+            self.disconnect(conn)
+
     def release(self, conn, reason):
-        if self.conn is not conn or conn is None:
-            return
-        self.conn = None  # exactly-once restore, even when callbacks re-enter
-        self.token = None
-        self.input.clear()
-        self.output.clear()
-        self.requested = None
-        self.repaint_at = None
-        saved, self.saved_size = self.saved_size, None
-        if saved is not None:
+        if conn is None or self.viewers.pop(conn, None) is None:
+            return  # exactly once, even when callbacks re-enter
+        if self.viewers:
+            # The remaining terminals may allow a larger size now.
             try:
-                fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, saved)
+                self.resize(*self.size())
             except OSError:
                 pass
+        else:
+            self.repaint_at = None
+            saved, self.saved_size = self.saved_size, None
+            if saved is not None:
+                try:
+                    fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, saved)
+                except OSError:
+                    pass
         self.on_release()
         self.event({"type": "attach_closed", "reason": reason})
         if reason != "client-eof":

package/ccx/claude/host/pty.py

@@ -19,6 +19,19 @@ from ccx.constants import (
     PTY_QUIESCENCE_S,
     PTY_WRITE_TIMEOUT_S,
 )
+from ccx.claude.transcript import BARE_IMAGE_PATH_RE
+
+# Claude (2.1.319) checks every pasted line that, trimmed, unquoted and with
+# backslash escapes removed, ends in .png, .jpg, .jpeg, .gif or .webp: it
+# looks for the image file asynchronously and inserts the paste only then,
+# after any pastes that arrived meanwhile, and drops an Enter pressed during
+# the check. So a paste boundary goes right after the dot of every image
+# extension. More formats than Claude checks today: extra boundaries are free.
+_IMAGE_EXTENSIONS = ("png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg",
+                     "avif", "heic", "heif", "tif", "tiff")
+_IMAGE_EXTENSION_DOT = re.compile(
+    r"\.(?=\\*(?:%s))" % "|".join(r"\\*".join(ext) for ext in _IMAGE_EXTENSIONS),
+    re.IGNORECASE)
 
 
 def set_winsize(fd, rows, cols):
@@ -70,7 +83,13 @@ def paste_chunks(text: str, max_newlines: int,
     A CRLF pair is never split. Returns None when the text has a line break but
     no paste may carry one (a PTY under ``PASTE_INLINE_ROWS_RESERVED + 1``
     rows), so the caller falls back to a single paste.
+
+    No paste holds an image extension whole (see ``_IMAGE_EXTENSION_DOT``),
+    except in a prompt that is only an image path, which Claude attaches as
+    the image.
     """
+    breaks = (set() if BARE_IMAGE_PATH_RE.match(text.strip())
+              else {m.end() for m in _IMAGE_EXTENSION_DOT.finditer(text)})
     chunks: list[str] = []
     cur: list[str] = []
     units = newlines = 0
@@ -83,7 +102,7 @@ def paste_chunks(text: str, max_newlines: int,
         if is_newline and max_newlines < 1:
             return None
         cost = 4 if ch == "\t" else 2 if ord(ch[0]) > 0xFFFF else 1
-        if cur and units + cost > max_units:
+        if cur and (units + cost > max_units or i in breaks):
             chunks.append("".join(cur))
             cur, units, newlines = [], 0, 0
         cur.append(ch)

package/ccx/claude/host/session.py

@@ -127,9 +127,10 @@ from ccx.claude.transcript import (
     is_compact_command_text,
     normalize_semantic_prompt_text,
     prompt_matches,
+    prompt_mismatch_event,
     queued_prompt_accepted,
     read_ai_title,
-    render_transcript_json,
+    refresh_context_observation,
 )
 from ccx.claude.usage import _merge_caps, cap_tripped, fetch_usage, read_usage_cached, unknown_cap_metrics
 from ccx.claude.host.events import _count_lines, _elicitation_request, _hook_tool_use_id, _oldest_native_gate, _open_event_journal, _permission_preview, _rotate_events_file, _stamp_event, _subagent_finished_event, _tool_finished_event, _tool_started_event
@@ -250,6 +251,39 @@ def adopt_ai_title(short: str, transcript_path) -> bool | None:
     return True
 
 
+def _interrupt_refusal_for_delivery(slot: dict | None) -> str | None:
+    """Why an interrupt must wait for the in-flight delivery, or None.
+
+    A delivery CCX still holds (nothing written to the PTY yet) is unaffected
+    by Escape: once the turn ends, a held steer falls back to the next turn
+    and a held send goes out when the worker is idle. Only text that may
+    already be in Claude's editor or queue makes Escape ambiguous, and that
+    window lasts seconds.
+    """
+    if slot is None:
+        return None
+    if not slot.get("delivery_id"):
+        return ("An earlier message is unresolved; inspect the worker and "
+                "reconcile its delivery before interrupting.")
+    if not slot.get("maybe_written"):
+        return None
+    if slot.get("route") == "steer":
+        return "a steer is being handed to Claude; retry in a few seconds"
+    return "a message is being handed to Claude; retry in a few seconds"
+
+
+def unresolved_delivery_refusal(delivery_id: str, receipt: dict | None) -> str:
+    """Why a send is refused while an earlier delivery is unresolved."""
+    if (receipt or {}).get("evidenceStatus") == "foreign-start-after-possible-write":
+        return (f"Claude started a turn whose text didn't match an earlier message "
+                f"(delivery {delivery_id}), so CCX can't tell whether that message "
+                "was delivered. `ccx kill` the worker to clear it (the conversation "
+                "is kept).")
+    return (f"An earlier message (delivery {delivery_id}) is still unresolved; "
+            "wait for it, or if it is stuck, `ccx kill` the worker to clear it "
+            "(the conversation is kept).")
+
+
 def _semantic_slot_from_receipt(receipt: dict, hot: dict | None = None) -> dict:
     """Recover the original immutable cap even if the hot journal was evicted."""
     hot = hot or {}
@@ -999,6 +1033,16 @@ def _run_host(args):
                 continue
             new_items = current_bg_items()
             changes = diff_items(bg["items"], new_items)
+            if (state["current"] == S.IDLE
+                    and any(item["status"] == "running" for item in bg["items"])
+                    and not any(item["status"] == "running" for item in new_items)):
+                # Native background work was not user idleness. Its final
+                # completion starts a NEW configured idle window, allowing
+                # Claude's queued completion notification to begin its turn.
+                # No new polling, fixed grace duration, state/turn invention,
+                # or replayed bootstrap facts; only this fresh native edge.
+                state["last_activity"] = time.time()
+                state["bg_idle_grace"] = False
             bg["items"] = new_items
             if publish and changes:
                 publish_bg(new_items, changes)
@@ -1158,9 +1202,7 @@ def _run_host(args):
             if prior is not None and prior.get("state") in ("accepted", "rejected", "delivered", "abandoned"):
                 state["semantic_delivery"] = None
             else:
-                return (f"An earlier message (delivery {delivery_id}) is still unresolved; "
-                        "wait for it, or if it is stuck, `ccx kill` the worker to clear it "
-                        "(the conversation is kept).")
+                return unresolved_delivery_refusal(delivery_id, prior)
         if state.get("compacting") is not None or state.get("compact_clear") is not None:
             return "Compaction is in progress; try again after it finishes."
         if state.get("pending_permission"):
@@ -2656,6 +2698,8 @@ def _run_host(args):
 
         # A mismatched prompt is foreign. If our write may already exist, this
         # only makes the semantic placement ambiguous; it never permits resend.
+        if slot.get("maybe_written"):
+            broadcast(prompt_mismatch_event(slot["delivery_id"], expected, prompt))
         semantic_foreign_turn_start("user-prompt-submit")
         return False
 
@@ -2760,6 +2804,13 @@ def _run_host(args):
             return None
         if slot.get("maybe_written"):
             return {"ok": True, "delivered": False, "pending": True}
+        interrupting = state.get("interrupt_observation") or {}
+        if (interrupting.get("turn_ref") == target and interrupting.get("passive") is False
+                and interrupting.get("interrupt_at") is not None):
+            # CCX sent Escape to this turn: keep the steer for the next turn
+            # rather than queueing it into a turn that is stopping.
+            return {"ok": True, "delivered": False, "pending": True,
+                    "reason": "target turn is being interrupted"}
 
         transcript_path = data.get("transcript_path")
         if not transcript_path:
@@ -2791,8 +2842,19 @@ def _run_host(args):
         state["active_cap"] = _merge_caps([state.get("active_cap"), slot.get("cap")])
         state["last_cap_poll"] = 0.0
         deadline = now + STEER_BOUNDARY_ACK_S
+        # Scan only what Claude wrote after the paste fence. The fence is a
+        # size of the worker's own transcript; any other file is scanned whole.
+        fence = slot.get("paste_offset")
+        try:
+            same_file = (transcript_path == rec["transcript"]
+                         or os.path.samefile(transcript_path, rec["transcript"]))
+        except OSError:
+            same_file = False
+        if not same_file or type(fence) is not int or fence < 0:
+            fence = 0
         while time.time() < deadline:
-            if queued_prompt_accepted(transcript_path, slot["text"], after_ms=before_ms):
+            if queued_prompt_accepted(transcript_path, slot["text"], after_ms=before_ms,
+                                      after_offset=fence):
                 reconcile_semantic_delivery()
                 return {"ok": True, "delivered": True,
                         "delivery_id": slot["delivery_id"]}
@@ -3972,13 +4034,13 @@ def _run_host(args):
                 "turns": state["turns"],
                 "activeTurnRef": state.get("active_turn_ref"),
                 "lastTurnAt": r.get("lastTurnAt"),
-                "transcript": r.get("transcriptJson"),
                 "pendingDeliveries": pending_steers,
                 "steerJournalError": steer_journal_error,
                 "waitingFor": current_waiting_preview(),
                 # Brokered requests waiting behind `waitingFor`, oldest first.
                 "queuedInputs": len(state["permission_queue"]),
                 "attached": hub.attached,
+                "attachedTerminals": len(hub.viewers),
                 # Is the local /compact pump still running? The pump is bounded
                 # by its own deadline and can give up without writing a
                 # boundary, so a client waiting for one needs to know when to
@@ -4017,16 +4079,12 @@ def _run_host(args):
                     "state": state["current"], "turnRef": current_ref,
                 }) + "\n").encode())
                 return
-            if state.get("semantic_delivery") is not None:
+            refusal = _interrupt_refusal_for_delivery(state.get("semantic_delivery"))
+            if refusal is not None:
                 client_sock.sendall((json.dumps({
                     "ok": False,
                     "definitive": True,
-                    "error": (
-                        "queued steer is still pending; ccx kill <worker> discards "
-                        "the queue after checking the transcript (delivered or abandoned)"
-                        if (state["semantic_delivery"] or {}).get("route") == "steer"
-                        else "semantic delivery in flight; retry after it settles"
-                    ),
+                    "error": refusal,
                     "state": state["current"],
                 }) + "\n").encode())
                 return
@@ -4332,7 +4390,7 @@ def _run_host(args):
                     continue
                 progress = True
                 buf.extend(data)
-                if (hub.conn is conn and len(buf) > MAX_ATTACH_LINE
+                if (hub.has(conn) and len(buf) > MAX_ATTACH_LINE
                         and b"\n" not in buf):
                     hub.release(conn, "oversized-attachment-frame")
                     drop_client(conn)
@@ -4345,20 +4403,20 @@ def _run_host(args):
                     buf.extend(rest)
                     if not line.strip():
                         continue
-                    if hub.conn is conn and len(line) > MAX_ATTACH_LINE:
+                    if hub.has(conn) and len(line) > MAX_ATTACH_LINE:
                         hub.release(conn, "oversized-attachment-frame")
                         drop_client(conn)
                         break
                     try:
                         msg = json.loads(line)
                     except (UnicodeError, ValueError):
-                        if hub.conn is conn:
+                        if hub.has(conn):
                             hub.release(conn, "malformed-attachment-frame")
                             drop_client(conn)
                             break
                         continue
                     if not isinstance(msg, dict):
-                        if hub.conn is conn:
+                        if hub.has(conn):
                             hub.release(conn, "malformed-attachment-frame")
                             drop_client(conn)
                             break
@@ -4396,7 +4454,7 @@ def _run_host(args):
     threading.Thread(target=_usage_refresher, name="ccx-usage-refresh",
                      daemon=True).start()
 
-    # Keep whole-history transcript rendering off the host's event loop.
+    # Keep the context/model observation refresh off the host's event loop.
     refresh_wanted = threading.Event()
     refresh_stop = threading.Event()
 
@@ -4408,7 +4466,7 @@ def _run_host(args):
             refresh_wanted.wait()
             refresh_wanted.clear()
             try:
-                render_transcript_json(short)
+                refresh_context_observation(short)
             except Exception:
                 pass
             if refresh_stop.is_set() and not refresh_wanted.is_set():
@@ -4887,9 +4945,14 @@ def _run_host(args):
                             state["bg_idle_grace"] = True
                             broadcast({"type": "idle_grace_bg", "idle_for_s": idle_for})
                     else:
-                        set_state(S.IDLE_KILLED, reason=f"idle for {idle_for:.0f}s > timeout {idle_timeout_s}s")
-                        broadcast({"type": "idle_killed", "idle_for_s": idle_for})
-                        break
+                        # The forced read above can observe the last task's
+                        # completion and restart the idle clock. Do not reuse
+                        # the pre-read overdue value and kill on that edge.
+                        idle_for = time.time() - state["last_activity"]
+                        if idle_for > idle_timeout_s:
+                            set_state(S.IDLE_KILLED, reason=f"idle for {idle_for:.0f}s > timeout {idle_timeout_s}s")
+                            broadcast({"type": "idle_killed", "idle_for_s": idle_for})
+                            break
 
             # Boot watchdog. BOOTING only ends on a SessionStart hook; if Claude
             # blocks before that (un-pre-seeded --add-dir trust dialog, onboarding
@@ -4941,7 +5004,7 @@ def _run_host(args):
                 part, timeout_s=.01, absolute_timeout_s=.01))
             # Build select set
             rlist = [server, master_fd] + list(state["clients"].keys())
-            wlist = [hub.conn] if hub.attached and hub.output else []
+            wlist = hub.pending()
             try:
                 fast_observe = (
                     state.get("interrupt_observation") is not None
@@ -4949,14 +5012,14 @@ def _run_host(args):
                     or state.get("successor_pending") is not None
                 )
                 select_timeout = INTERRUPT_NATIVE_POLL_S if fast_observe else 1.0
-                if hub.attached and (hub.input or hub.output or hub.repaint_at):
+                if hub.busy():
                     select_timeout = min(select_timeout, .05)
                 r, writable, _ = select.select(rlist, wlist, [], select_timeout)
             except (InterruptedError, OSError):
                 continue
 
-            if hub.attached and hub.conn in writable:
-                hub.flush()
+            for conn in writable:
+                hub.flush(conn)
             for src in r:
                 if src is server:
                     try:
@@ -4989,7 +5052,7 @@ def _run_host(args):
                         drop_client(conn)
                         continue
                     buf.extend(data)
-                    if (hub.conn is conn and len(buf) > MAX_ATTACH_LINE
+                    if (hub.has(conn) and len(buf) > MAX_ATTACH_LINE
                             and b"\n" not in buf):
                         hub.release(conn, "oversized-attachment-frame")
                         drop_client(conn)
@@ -4998,7 +5061,7 @@ def _run_host(args):
                     while b"\n" in buf:
                         if fd not in state["clients"]:
                             break  # attach-close or overflow already removed this fd
-                        if hub.conn is conn and attach_frames >= 64:
+                        if hub.has(conn) and attach_frames >= 64:
                             hub.release(conn, "input-frame-flood")
                             drop_client(conn)
                             break
@@ -5008,20 +5071,20 @@ def _run_host(args):
                         buf.extend(rest)
                         if not line.strip():
                             continue
-                        if hub.conn is conn and len(line) > MAX_ATTACH_LINE:
+                        if hub.has(conn) and len(line) > MAX_ATTACH_LINE:
                             hub.release(conn, "oversized-attachment-frame")
                             drop_client(conn)
                             break
                         try:
                             msg = json.loads(line)
                         except (UnicodeError, ValueError):
-                            if hub.conn is conn:
+                            if hub.has(conn):
                                 hub.release(conn, "malformed-attachment-frame")
                                 drop_client(conn)
                                 break
                             continue
                         if not isinstance(msg, dict):
-                            if hub.conn is conn:
+                            if hub.has(conn):
                                 hub.release(conn, "malformed-attachment-frame")
                                 drop_client(conn)
                                 break
@@ -5049,10 +5112,7 @@ def _run_host(args):
                 state["pending_last_error"] = reason
             break
 
-    if hub.attached:
-        conn = hub.conn
-        hub.release(conn, "host-exit")
-        drop_client(conn)
+    hub.release_all("host-exit")
 
     # Shutdown.  Reconcile an active compact before tearing down its host/PTY.
     # A boundary may have landed on the final loop tick; if not, preserve the