From 95dfcd5cdb43fb1c11e143a85eedeeb37008f4e1 Mon Sep 17 00:00:00 2001 From: Teknium <127238744+teknium1@users.noreply.github.com> Date: Mon, 19 Oct 2026 11:54:27 -0700 Subject: [PATCH] fix(cli): a slash command typed after /queue X runs after X's turn /queue X then /new (or /undo, /retry) typed during a turn: on main both sat in _pending_input in that order. With X in the owner's FIFO, the input loop took /new first; X's turn is adopted only once the owner's message.start arrives, so /new could detach the session and X ran in a session this terminal had left. The input loop now holds a local item while this viewer's own /queue admission is at the head of the owner's queue (gateway_queue .OwnQueueHold). A turn the owner runs meanwhile (the adopted admission, a notification header) runs first; the held item runs once that admission was taken or left the queue. The wait is bounded: an unknown row (a paused FIFO) never starts a hold, an idle list beyond the one a settling turn publishes ends it, and OWN_QUEUE_HOLD_S (2 s) caps it. The admission itself is never touched. Refs #134889 (N5) --- hermes_cli/cli_tui_runtime_mixin.py | 25 ++++- hermes_cli/gateway_queue.py | 89 ++++++++++++++++++ .../hermes_cli/test_cli_queue_gateway_fifo.py | 91 +++++++++++++++++++ 3 files changed, 204 insertions(+), 1 deletion(-) diff --git a/hermes_cli/cli_tui_runtime_mixin.py b/hermes_cli/cli_tui_runtime_mixin.py index 75d9af9753..5dc81cd048 100644 --- a/hermes_cli/cli_tui_runtime_mixin.py +++ b/hermes_cli/cli_tui_runtime_mixin.py @@ -30,15 +30,24 @@ class CLITuiRuntimeMixin: def _tui_process_loop(self): """REPL worker thread: drain ``_pending_input``, run idle housekeeping, dispatch each input.""" + held = None while not self._should_exit: try: + if held is not None: + held, user_input = self._tui_hold_step(held) + if user_input is not None: + self._tui_process_one_input(user_input) + continue try: user_input = self._pending_input.get(timeout=0.1) except queue.Empty: if not self._agent_running: self._tui_idle_tick() continue - self._tui_process_one_input(user_input) + from hermes_cli.gateway_queue import OwnQueueHold + held = OwnQueueHold.begin(self, user_input) + if held is None: + self._tui_process_one_input(user_input) except Exception as e: if isinstance(e, OSError) and e.errno == errno.EIO: self._mark_terminal_io_broken("process_loop") @@ -46,6 +55,20 @@ class CLITuiRuntimeMixin: continue logger.warning("process_loop unhandled error (msg may be lost): %s", e) + def _tui_hold_step(self, hold): + """One step of holding a local input behind this viewer's own ``/queue`` admission (#134889 N5): + ``(hold or None, input to run now or None)``. A turn the owner runs now goes first; the held + input runs once that admission was taken, left the queue, or the bounded wait ran out.""" + with suppress(Exception): + self._drain_process_notifications("cli-idle") # adopts the admission on its message.start + item = hold.take_gateway_turn(self._pending_input) + if item is not None: + return hold, item + if hold.done(): + return None, hold.item + time.sleep(0.05) + return hold, None + def _tui_idle_tick(self): """Idle housekeeping between inputs (agent not running).""" self._check_config_mcp_changes() # auto-reload MCP on mcp_servers change diff --git a/hermes_cli/gateway_queue.py b/hermes_cli/gateway_queue.py index def8dd43fe..f55d20d3f6 100644 --- a/hermes_cli/gateway_queue.py +++ b/hermes_cli/gateway_queue.py @@ -107,6 +107,95 @@ def published_queue(cli, store) -> list[str]: return [str(row.get("text") or "") for row in rows if row.get("status") == "queued"] + fresh +# How long the input loop holds a local input behind this viewer's own ``/queue`` admission at most. +OWN_QUEUE_HOLD_S = 2.0 + + +def _own_head(state): + """This viewer's ``/queue`` admission at the head of the owner's queue, not yet adopted; None when + the head is someone else's, nothing is queued, or the FIFO is paused on an ``unknown`` row.""" + rows = [row for row in state.pending or () if isinstance(row, dict)] + if any(row.get("status") == "unknown" for row in rows): + return None # paused until the owner resolves that row: never hold typing behind it + queued = sorted((row for row in rows if row.get("status") == "queued" and row.get("admission_id")), + key=lambda row: int(row.get("sequence") or 0)) + if queued: + head = queued[0]["admission_id"] + else: # submitted after the last published list (``published_queue``'s fresh rows) + listed = {row.get("admission_id") for row in rows} + head = next((a for a in state.queued_inputs + if a not in listed and state.queued_at.get(a, -1) >= state.pending_seq), None) + return head if head in state.queued_inputs and head not in state.adopted else None + + +class OwnQueueHold: + """A local input (a slash command, a typed turn) taken while this viewer's own ``/queue`` admission + is the owner's next turn. On main both sat in ``_pending_input`` in entry order; now the admission + is in the owner's FIFO and its turn is adopted only when the owner's ``message.start`` arrives, so + the input loop holds the local item until that admission was taken (or left the queue). + + Bounded: an ``unknown`` row (a paused FIFO) never starts a hold; an owner that publishes an idle + list still queuing it (beyond the one a just-settled turn publishes before its claim) releases it; + and ``OWN_QUEUE_HOLD_S`` caps the wait. The admission itself is never touched. + """ + + def __init__(self, item, state, admission): + import time + self.item, self.state, self.admission = item, state, admission + self.seq = state.pending_seq + # A turn the owner reports running settles with one idle list (still queuing this admission) + # before its drain claims it: that list is expected, a further one means the FIFO is paused. + self.allowed_idle_lists = 1 if state.info.get("running") else 0 + self.idle_lists = 0 + self.deadline = time.monotonic() + OWN_QUEUE_HOLD_S + self.taken = False + + @classmethod + def begin(cls, cli, item): + from cli import _SeededQueryMessage + from hermes_cli.gateway_tools_notify import gateway_store + from tools.process_registry_notifications import TimelineNotification + if getattr(cli, "_agent_running", False) or isinstance(item, (_SeededQueryMessage, TimelineNotification)): + return None # a turn the owner already runs (or a seeded prompt) is never held + store = gateway_store(cli) if getattr(cli, "session_id", None) else None + if store is None: + return None + state = _state(cli, store) + admission = _own_head(state) + return cls(item, state, admission) if admission else None + + def take_gateway_turn(self, pending): + """Pop a turn the owner is running now (an adopted admission, a notification header) from the + head of ``_pending_input``: those run before the held item, typed items stay behind it.""" + from tools.process_registry_notifications import TimelineNotification + with pending.mutex: + if not pending.queue: + return None + head = pending.queue[0] + if not (getattr(head, "admission_id", None) or isinstance(head, TimelineNotification)): + return None + pending.queue.popleft() + pending.unfinished_tasks = max(0, pending.unfinished_tasks - 1) + if getattr(head, "admission_id", None) == self.admission: + self.taken = True + return head + + def done(self) -> bool: + import time + if self.taken or time.monotonic() >= self.deadline: + return True + state = self.state + if _own_head(state) != self.admission: + # Adopted: its item is at the head of ``_pending_input``, taken on the next step. Otherwise + # it started unseen (the idle tick recovers it), was cancelled, or is no longer next. + return self.admission not in state.adopted + if state.pending_seq != self.seq: + self.seq = state.pending_seq + if not state.info.get("running"): + self.idle_lists += 1 + return self.idle_lists > self.allowed_idle_lists # idle and still not claiming it: stop waiting + + STARTED_REFUSALS = frozenset({"stale_generation", "admission_started"}) diff --git a/tests/hermes_cli/test_cli_queue_gateway_fifo.py b/tests/hermes_cli/test_cli_queue_gateway_fifo.py index f8ef594e43..d9f8b1f150 100644 --- a/tests/hermes_cli/test_cli_queue_gateway_fifo.py +++ b/tests/hermes_cli/test_cli_queue_gateway_fifo.py @@ -590,3 +590,94 @@ def test_a_steer_that_falls_back_to_queue_is_a_gateway_admission_and_images_stay _busy_enter(local, "queue", "plain") assert local._pending_input.get_nowait() == "plain" + + +def _run_loop(cli, until): + """Run main's ``_tui_process_loop`` in a thread; returns ``(processed, stop)``.""" + import threading + import time + processed = [] + + def one(item): + processed.append((time.monotonic(), item)) + if len(processed) >= until: + cli._should_exit = True + cli._should_exit = False + cli._tui_process_one_input = one + cli._tui_idle_tick = lambda: cli._drain_process_notifications("cli-idle") + thread = threading.Thread(target=cli._tui_process_loop, daemon=True) + thread.start() + + def stop(timeout): + thread.join(timeout) + cli._should_exit = True + thread.join(2) + return processed, stop + + +def test_probe_slash_command_typed_after_queue_runs_after_it(): + """Review round 2, major 2: ``/queue X`` then ``/new`` typed while busy. On main both sat in + ``_pending_input`` in that order; with X in the owner's FIFO the input loop must still run X first, + not let ``/new`` detach the session before the owner claims X.""" + from tests.waiting import wait_until + from tests.hermes_cli.test_gateway_agent import SID, frame + from tests.hermes_cli.test_gateway_tools_notify import _connected, _idle_cli + conn, client = _connected() + try: + cli = _idle_cli(conn) + state = conn.state(SID) + state.queued_inputs["adm-q"] = TEXT + state.apply_event("session.info", {"running": True, "pending": [ + {"admission_id": "adm-1", "status": "started", "sequence": 1, "text": "turn"}, + {"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}]}) + cli._pending_input.put("/new") # typed while the CLI's turn ran; that turn just returned + processed, stop = _run_loop(cli, 2) + wait_until(lambda: cli._pending_input.empty(), timeout=5) # the loop took /new and holds it + # The owner settles the turn, then claims X. + frames = [frame("session.info", {"running": False, "pending": [ + {"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}]}, admission=None), + frame("message.start", {}, admission="adm-q")] + + async def put(): # not _play: the held loop consumes the frames as they land + for item in frames: + await client.events.put(item) + asyncio.run_coroutine_threadsafe(put(), conn.loop).result(5) + stop(5) + order = [str(item) for _, item in processed] + assert order == [TEXT, "/new"], f"input loop runs {order[0]!r} before the /queue prompt" + assert getattr(processed[0][1], "admission_id", None) == "adm-q" + finally: + conn.close() + + +@pytest.mark.parametrize("pending, running", [ + ([{"admission_id": "adm-0", "status": "unknown", "sequence": 1, "text": "lost"}, + {"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}], False), + ([{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}], False), + ([{"admission_id": "adm-q", "status": "queued", "sequence": 2, "text": TEXT}], True), +]) +def test_typing_stays_responsive_when_the_owner_queue_is_paused(pending, running): + """The hold is bounded: a FIFO paused on an ``unknown`` row runs a typed command at once, and an owner + that never claims this viewer's admission (idle, or busy with someone else's turn) delays it by at + most ``OWN_QUEUE_HOLD_S``; the admission stays queued, never dropped.""" + import time + from hermes_cli.gateway_queue import OWN_QUEUE_HOLD_S + from tests.hermes_cli.test_gateway_agent import SID + from tests.hermes_cli.test_gateway_tools_notify import _connected, _idle_cli + assert OWN_QUEUE_HOLD_S >= 2.0 + conn, _client = _connected() + try: + cli = _idle_cli(conn) + state = conn.state(SID) + state.queued_inputs["adm-q"] = TEXT + state.apply_event("session.info", {"running": running, "pending": pending}) + started = time.monotonic() + cli._pending_input.put("/help") + processed, stop = _run_loop(cli, 1) + stop(OWN_QUEUE_HOLD_S + 2) + assert [str(item) for _, item in processed] == ["/help"] + waited = processed[0][0] - started + assert waited < (0.5 if pending[0]["status"] == "unknown" else OWN_QUEUE_HOLD_S + 1.0), waited + assert state.queued_inputs == {"adm-q": TEXT} + finally: + conn.close()