comate-cli 0.5.4__tar.gz → 0.5.5__tar.gz

{comate_cli-0.5.4 → comate_cli-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.5.4
+Version: 0.5.5
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/event_renderer.py

@@ -279,12 +279,13 @@ class EventRenderer:
         self._show_thinking_cb: Callable[[], bool] = lambda: True
         self._turn_received_text_delta: bool = False
         self._turn_received_thinking_delta: bool = False
+        self._text_delta_started: bool = False
         # ━━━━━ spec §4.1 新管道状态字段（Phase 1.2 引入，Phase 4-6 接入） ━━━━━
         # Pipeline A: text line-commit
         self._text_pending: str = ""
         self._held_pipe_line: str | None = None
         self._container: ContainerState | None = None
-        # Pipeline B: thinking batch
+        # Pipeline B: thinking line-commit + tail
         self._thinking_batch: str = ""
         # Pipeline C: loading 行 aux
         self._loading_aux_text: str = ""
@@ -367,7 +368,7 @@ class EventRenderer:
         self._loading_aux_text = ""
 
     def _flush_thinking_batch(self) -> None:
-        """spec §6.5：thinking batch 整段 → HistoryEntry（受 _show_thinking_cb 过滤）。
+        """spec §6.5：thinking 残段 → HistoryEntry（受 _show_thinking_cb 过滤）。
         即使 hidden 也清空 batch 避免持续累积。"""
         text = self._thinking_batch
         self._thinking_batch = ""
@@ -379,6 +380,22 @@ class EventRenderer:
             HistoryEntry(entry_type="thinking", text=text)
         )
 
+    def _consume_thinking_delta(self, delta: str) -> None:
+        """spec §6.1：thinking delta 主入口。
+
+        与 text delta 对称：按完整行即时 commit 到 scrollback，未换行尾巴留在
+        _thinking_batch，等待 text/tool/turn 边界通过 _flush_thinking_batch 落盘。
+        """
+        if not delta:
+            return
+        self._thinking_batch += delta
+        while "\n" in self._thinking_batch:
+            line, self._thinking_batch = self._thinking_batch.split("\n", 1)
+            if self._show_thinking_cb():
+                self._append_history_entry(
+                    HistoryEntry(entry_type="thinking", text=line + "\n")
+                )
+
     # ── 行级路由（spec §6.2，Task 4.1-4.4 渐进扩展）──
 
     def _handle_complete_line(self, line: str) -> None:
@@ -457,7 +474,7 @@ class EventRenderer:
 
         把 delta 累到 _text_pending，按 \\n 切完整行送 _handle_complete_line。
 
-        关键顺序保证：text 进入前先 flush 待 thinking batch —— 保证
+        关键顺序保证：text 进入前先 flush 待 thinking 残段 —— 保证
         scrollback 看到 "thinking → text" 而非 "text → thinking" 错序。
         """
         if not delta:
@@ -467,6 +484,9 @@ class EventRenderer:
         self._text_pending += delta
         while "\n" in self._text_pending:
             line, self._text_pending = self._text_pending.split("\n", 1)
+            if line == "" and not self._text_delta_started:
+                continue
+            self._text_delta_started = True
             self._handle_complete_line(line)
 
     # ── turn 边界（spec §6.4）──
@@ -509,6 +529,7 @@ class EventRenderer:
         self._container = None
         self._thinking_batch = ""
         self._loading_aux_text = ""
+        self._text_delta_started = False
 
     def _should_drop_duplicate_system_message(
         self,
@@ -541,6 +562,7 @@ class EventRenderer:
         self._pending_tool_starts.clear()
         self._turn_received_text_delta = False
         self._turn_received_thinking_delta = False
+        self._text_delta_started = False
         # spec §6.4：清空新 5 字段（每 turn 起点保证状态干净）
         self._text_pending = ""
         self._held_pipe_line = None
@@ -630,6 +652,7 @@ class EventRenderer:
         self._pending_tool_starts.clear()
         self._turn_received_text_delta = False
         self._turn_received_thinking_delta = False
+        self._text_delta_started = False
         # spec §6.4：清空 5 个新字段（与 start_turn 同语义）
         self._text_pending = ""
         self._held_pipe_line = None
@@ -1444,10 +1467,9 @@ class EventRenderer:
                     self._turn_received_text_delta = True
             case ThinkingDeltaEvent(delta=delta, message_id=_):
                 if delta:
-                    # spec §6.1：thinking delta → batch 累加，段结束（StopEvent /
-                    # text delta 来时）才一次性 commit
-                    self._thinking_batch += delta
+                    # spec §6.1：thinking delta → 按 \n 切完整行入队，残段留 batch
                     self._turn_received_thinking_delta = True
+                    self._consume_thinking_delta(delta)
             case ToolCallStartEvent(tool_call_id=tool_call_id, tool=tool_name):
                 # tool 调用前先把 _text_pending / _thinking_batch 落到 scrollback，
                 # 保证说明文字出现在 tool UI 之前（无 \n 结尾的模型也适用）。

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/history_printer.py

@@ -103,6 +103,7 @@ def render_history_group(
         in_run_continuation = is_assistant and prev_was_assistant
         next_entry = entries[idx + 1] if idx + 1 < len(entries) else None
         next_is_assistant = next_entry is not None and next_entry.entry_type == "assistant"
+        next_is_thinking = next_entry is not None and next_entry.entry_type == "thinking"
 
         # 跳过位于两个块标记 entry 之间的空 assistant entry（loose list 视觉对齐）
         if is_assistant and _is_blank_assistant(entry):
@@ -127,7 +128,13 @@ def render_history_group(
                 line_text.append("  ", style="dim")
                 line_text.append(line, style="dim")
             renderables.append(line_text)
-            renderables.append(Text(""))
+            is_batch_tail = next_entry is None
+            suppress_trailing_gap = (
+                is_batch_tail
+                and assume_run_continues_at_tail
+            )
+            if not next_is_thinking and not suppress_trailing_gap:
+                renderables.append(Text(""))
             prev_was_assistant = False
             continue
 

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/rpc_stdio.py

@@ -228,7 +228,7 @@ class StdioRPCBridge:
         self._active_prompt_result = result_future
 
         try:
-            await self._session.send(user_input)
+            _ = await self._session.send(user_input)
         except Exception as exc:
             self._clear_active_prompt(result_future)
             await self._send(

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/tool_view.py

@@ -93,11 +93,10 @@ def should_show_tool_in_scrollback(
         return is_result and is_error
 
     if lowered == "taskcreate":
-        return is_result
+        return is_result and is_error
 
     if lowered == "taskupdate":
-        status = str(args.get("status", "")).strip().lower()
-        return is_result and (is_error or status == "completed")
+        return is_result and is_error
 
     # Read-only task tools: only show errors.
     if lowered in _SILENT_TASK_TOOLS:

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/tui.py

@@ -9,7 +9,6 @@ import asyncio
 import logging
 import random
 import time
-from collections import deque
 from collections.abc import Callable
 from contextlib import suppress
 from pathlib import Path
@@ -34,10 +33,14 @@ from comate_agent_sdk.agent import ChatSession
 from comate_agent_sdk.agent.events import (
     ExternalTurnScheduledEvent,
     PlanApprovalRequiredEvent,
+    QueueDirtyEvent,
+    QueueDirtyReason,
+    QueuedMessageInjectedEvent,
     SessionInitEvent,
     StopEvent,
     TeamMessageEvent,
 )
+from comate_agent_sdk.agent.queue_types import MessageOrigin
 
 from comate_cli.terminal_agent.animations import (
     DEFAULT_STATUS_PHRASES,
@@ -196,22 +199,21 @@ class TerminalAgentTUI(
             "AGENT_SDK_TUI_TODO_PANEL_EXPANDED_MAX_LINES",
             12,
         )
-        self._message_queue_max_size = read_env_int(
-            "AGENT_SDK_TUI_MESSAGE_QUEUE_MAX_SIZE",
-            3,
-        )
         self._queued_preview_max_chars = read_env_int(
             "AGENT_SDK_TUI_QUEUED_PREVIEW_MAX_CHARS",
             24,
         )
+        self._queued_preview_max_rows = read_env_int(
+            "AGENT_SDK_TUI_QUEUED_PREVIEW_MAX_ROWS",
+            3,
+        )
 
         self._busy = False
-        self._initializing = False  # MCP 加载中
         self._is_compacting = False
         self._compact_task: asyncio.Task[Any] | None = None
         self._compact_cancel_requested = False
         self._pending_exit_after_compact_cancel = False
-        self._queued_messages: deque[str] = deque()  # busy 时入队的消息（FIFO）
+        self._queued_display_by_message_id: dict[str, str] = {}
         self._waiting_for_input = False
         self._pending_questions: list[dict[str, Any]] | None = None
         self._pending_plan_approval: dict[str, str] | None = None
@@ -288,10 +290,6 @@ class TerminalAgentTUI(
         self._ctrl_c_press_count: int = 0
         ctrl_c_window_ms = read_env_int("AGENT_SDK_TUI_CTRL_C_EXIT_WINDOW_MS", 700)
         self._ctrl_c_exit_window_seconds = ctrl_c_window_ms / 1000.0
-        self._mcp_init_gate_timeout_s = read_env_float(
-            "AGENT_SDK_TUI_MCP_INIT_GATE_TIMEOUT_S",
-            8.0,
-        )
         self._mcp_init_cancel_timeout_s = read_env_float(
             "AGENT_SDK_TUI_MCP_INIT_CANCEL_TIMEOUT_S",
             1.0,
@@ -559,8 +557,8 @@ class TerminalAgentTUI(
                 "status.transient.warning": "bg:default italic fg:ansiyellow",
                 "input.placeholder": "bg:default #9CA3AF",
                 "auto-suggestion": "bg:default #94a3b8",
-                "queue": "bg:#1d222a #d8dee9",
-                "queue.item": "bg:#1d222a #cbd5e1",
+                "queue": "bg:default #d8dee9",
+                "queue.item": "bg:default #cbd5e1",
                 "git-diff.added": "#4ade80",
                 "git-diff.removed": "#f87171",
                 "question.tabs": "bg:default #c7d2fe",
@@ -638,9 +636,7 @@ class TerminalAgentTUI(
         )
 
     def _should_show_queue_panel(self) -> bool:
-        return self._ui_mode == UIMode.NORMAL and len(self._queued_messages) >= 1
-
-    _QUEUED_SLASH_PREFIX = "__COMATE_QUEUED_SLASH__::"
+        return self._ui_mode == UIMode.NORMAL and bool(self._queued_human_messages())
 
     def _build_slash_registry(self) -> None:
         handlers: dict[str, Callable[[str], Any]] = {
@@ -729,26 +725,6 @@ class TerminalAgentTUI(
             return None
         return entry.spec
 
-    def _encode_queued_slash(self, raw_command: str) -> str:
-        return f"{self._QUEUED_SLASH_PREFIX}{raw_command}"
-
-    def _is_encoded_queued_slash(self, value: str) -> bool:
-        return value.startswith(self._QUEUED_SLASH_PREFIX)
-
-    def _decode_queued_slash(self, value: str) -> str:
-        if not self._is_encoded_queued_slash(value):
-            return value
-        return value[len(self._QUEUED_SLASH_PREFIX) :]
-
-    def _queued_preview_text(self, value: str) -> str:
-        return self._decode_queued_slash(value)
-
-    def _dispatch_queued_item(self, queued: str) -> None:
-        if self._is_encoded_queued_slash(queued):
-            self._schedule_background(self._execute_command(self._decode_queued_slash(queued)))
-            return
-        self._schedule_background(self._submit_user_message(queued))
-
     def _create_input_history(self) -> FileHistory | InMemoryHistory:
         """Create persistent FileHistory based on cwd, with fallback to InMemoryHistory."""
         try:
@@ -771,15 +747,16 @@ class TerminalAgentTUI(
     def _input_placeholder_hint(self) -> str | None:
         if self._ui_mode != UIMode.NORMAL:
             return None
-        if not self._queued_messages:
+        queued_messages = self._queued_human_messages()
+        if not queued_messages:
             return None
         input_text = str(getattr(getattr(self, "_input_area", None), "text", ""))
         if input_text.strip():
             return None
-        if len(self._queued_messages) >= 2:
+        if len(queued_messages) >= 2:
             return self._queued_input_hint
 
-        preview = " ".join(self._queued_preview_text(self._queued_messages[0]).split())
+        preview = self._queued_message_preview(queued_messages[0])
         max_chars = max(8, int(self._queued_preview_max_chars))
         if len(preview) > max_chars:
             preview = f"{preview[: max_chars - 3]}..."
@@ -931,6 +908,28 @@ class TerminalAgentTUI(
                 await self._animation_controller.on_event(event)
                 if isinstance(event, SessionInitEvent):
                     self._initialized_session_id = str(event.session_id)
+                if isinstance(event, QueueDirtyEvent):
+                    if event.reason in {
+                        QueueDirtyReason.CANCELLED,
+                        QueueDirtyReason.CLEARED,
+                    }:
+                        for message_id in event.message_ids:
+                            self._queued_display_by_message_id.pop(
+                                str(message_id),
+                                None,
+                            )
+                    self._refresh_layers()
+                    self._invalidate()
+                if isinstance(event, QueuedMessageInjectedEvent):
+                    for message_id, origin in zip(event.message_ids, event.origins):
+                        if origin is not MessageOrigin.HUMAN:
+                            continue
+                        display_text = self._queued_display_by_message_id.pop(
+                            str(message_id),
+                            None,
+                        )
+                        if display_text:
+                            self._renderer.seed_user_message(display_text)
                 if isinstance(event, ExternalTurnScheduledEvent) and not self._busy:
                     self._session.run_controller.clear()
                     self._interrupt_requested_at = None
@@ -1013,14 +1012,6 @@ class TerminalAgentTUI(
 
                     self._refresh_layers()
 
-                    if (
-                        self._queued_messages
-                        and not waiting_for_input
-                        and plan_approval is None
-                    ):
-                        queued = self._queued_messages.popleft()
-                        self._dispatch_queued_item(queued)
-
                     waiting_for_input = False
                     questions = None
                     plan_approval = None
@@ -1285,17 +1276,16 @@ class TerminalAgentTUI(
                 if self._renderer.has_running_tools():
                     # Keep repainting for breathing animation.
                     self._render_dirty = True
-                elif self._busy or self._initializing:
+                elif self._busy:
                     self._render_dirty = True
 
                 if self._render_dirty:
                     self._invalidate()
                     self._render_dirty = False
 
-                # 动态帧率：busy/动画/initializing 时降为 6fps（缓解 scrollback 污染），idle 时 4fps
+                # 动态帧率：busy/动画时降为 6fps（缓解 scrollback 污染），idle 时 4fps
                 fast = (
                     self._busy
-                    or self._initializing
                     or self._animator.is_active
                     or self._renderer.has_running_tools()
                 )
@@ -1408,45 +1398,23 @@ class TerminalAgentTUI(
             logger.exception("Plugin init failed at startup; continuing without plugins")
 
         if mcp_init is not None:
-            self._initializing = True
-
             async def _do_init() -> None:
-                init_task = asyncio.create_task(mcp_init(), name="terminal-mcp-init-worker")
                 try:
-                    await asyncio.wait_for(
-                        asyncio.shield(init_task),
-                        timeout=self._mcp_init_gate_timeout_s,
-                    )
-                except asyncio.TimeoutError:
-                    logger.debug(
-                        "MCP init timed out after "
-                        f"{self._mcp_init_gate_timeout_s:.1f}s; continuing in background",
-                    )
-                    self._status_bar.show_transient(
-                        f"MCP: init timed out, continuing in background{ELLIPSIS}",
-                        duration_s=5.0,
-                    )
-                    # Don't cancel init_task — let it complete in background.
-                    # asyncio.shield above already protects it from wait_for's
-                    # auto-cancellation. When it finishes, runtime._mcp_manager
-                    # will be set and tools become available for the next turn.
+                    await mcp_init()
                 except asyncio.CancelledError:
-                    await self._cancel_task_with_timeout(
-                        init_task,
-                        timeout_s=self._mcp_init_cancel_timeout_s,
-                        task_name="terminal-mcp-init-worker",
-                    )
-                    return
+                    raise
                 except Exception as exc:
-                    logger.debug(f"MCP init failed in TUI bootstrap: {exc}", exc_info=True)
+                    logger.debug(
+                        f"MCP init failed in TUI bootstrap: {exc}",
+                        exc_info=True,
+                    )
                 finally:
-                    self._initializing = False
-                    if self._queued_messages and not self._busy:
-                        queued = self._queued_messages.popleft()
-                        self._dispatch_queued_item(queued)
                     self._refresh_layers()
 
-            self._mcp_init_task = asyncio.create_task(_do_init(), name="terminal-mcp-init")
+            self._mcp_init_task = asyncio.create_task(
+                _do_init(),
+                name="terminal-mcp-init",
+            )
 
         self._ui_tick_task = asyncio.create_task(
             self._ui_tick(),

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/tui_parts/commands.py

@@ -81,7 +81,7 @@ class CommandsMixin:
             self._refresh_layers()
             return
 
-        is_busy = self._busy or self._initializing
+        is_busy = self._busy
         if is_busy and not entry.allow_when_busy:
             self._renderer.append_system_message(
                 f"当前任务运行中，暂不可执行 /{entry.spec.name}。",

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/tui_parts/input_behavior.py

@@ -5,6 +5,8 @@ from typing import Any
 
 from prompt_toolkit.document import Document
 
+from comate_agent_sdk.agent.chat_session import ChatSessionQueueFullError
+
 from comate_cli.terminal_agent.input_geometry import (
     compute_visual_line_ranges,
     index_for_visual_col,
@@ -333,8 +335,9 @@ class InputBehaviorMixin:
             self._input_area.buffer.cancel_completion()
         self._clear_input_area(save_to_history=True)
 
-        # busy 或 initializing 时：非斜杠命令 → 入队，斜杠命令 → 交由命令分发决定
-        is_busy = self._busy or self._initializing
+        # busy 时：TUI 不再维护本地消息 deque，统一交给 SDK 队列。
+        # MCP preload 只在后台准备工具，不阻塞首条用户消息的回显与提交。
+        is_busy = self._busy
         if is_busy:
             if raw_text.startswith("/"):
                 normalized_slash = display_text.strip()
@@ -343,39 +346,31 @@ class InputBehaviorMixin:
                 entry = registry.resolve(parsed.name) if (registry is not None and parsed is not None) else None
 
                 if entry is not None and str(getattr(entry, "source", "")) == "custom":
-                    queue_size = len(self._queued_messages)
-                    if queue_size >= int(self._message_queue_max_size):
-                        self._renderer.append_system_message(
-                            f"消息队列已满（{queue_size}/{self._message_queue_max_size}），请等待当前任务完成。",
-                            severity="error",
-                        )
-                        self._refresh_layers()
-                        return
-
-                    encode_fn = getattr(self, "_encode_queued_slash", None)
-                    queued_value = (
-                        str(encode_fn(normalized_slash))
-                        if callable(encode_fn)
-                        else normalized_slash
+                    self._renderer.append_system_message(
+                        "当前任务运行中，custom slash command 不能排队执行，请等待当前任务结束后再运行。",
+                        severity="error",
                     )
-                    self._queued_messages.append(queued_value)
-                    self._invalidate()
+                    self._refresh_layers()
                     return
 
                 self._schedule_background(self._execute_command(normalized_slash))
                 return
 
             if not raw_text.startswith("/"):
-                queue_size = len(self._queued_messages)
-                if queue_size >= int(self._message_queue_max_size):
-                    self._renderer.append_system_message(
-                        f"消息队列已满（{queue_size}/{self._message_queue_max_size}），请等待当前任务完成。",
-                        severity="error",
-                    )
-                    self._refresh_layers()
-                    return
-                self._queued_messages.append(submit_text)
-                self._invalidate()
+                async def _send_busy_message(content: str, display: str) -> None:
+                    try:
+                        message_id = await self._session.send(content)
+                        self._queued_display_by_message_id[str(message_id)] = display
+                    except ChatSessionQueueFullError:
+                        self._renderer.append_system_message(
+                            "消息队列已满，请等待当前任务完成。",
+                            severity="error",
+                        )
+                        self._refresh_layers()
+
+                self._schedule_background(
+                    _send_busy_message(submit_text, display_text)
+                )
                 return
 
         if raw_text.startswith("/"):

{comate_cli-0.5.4 → comate_cli-0.5.5}/comate_cli/terminal_agent/tui_parts/key_bindings.py

@@ -6,6 +6,8 @@ from prompt_toolkit.filters import Condition, has_completions, has_focus
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.keys import Keys
 
+from comate_agent_sdk.agent.queue_types import MessageOrigin
+
 from comate_cli.terminal_agent.slash_commands import parse_slash_command_call
 from comate_cli.terminal_agent.tui_parts.ui_mode import UIMode
 
@@ -334,18 +336,6 @@ class KeyBindingsMixin:
         @bindings.add("up", filter=normal_mode & ~diff_panel_open & ~todo_panel_expanded)
         def _active_prev_up(event) -> None:
             buffer = event.current_buffer
-            # busy + 有 queue + input 为空 → 取回最近一条 queue，加载回 input
-            is_busy = self._busy or self._initializing
-            if is_busy and self._queued_messages and not buffer.text.strip():
-                queued = self._queued_messages.pop()
-                decode_fn = getattr(self, "_queued_preview_text", None)
-                if callable(decode_fn):
-                    buffer.text = str(decode_fn(queued))
-                else:
-                    buffer.text = str(queued)
-                buffer.cursor_position = len(buffer.text)
-                self._invalidate()
-                return
             if self._move_completion_selection(buffer, backward=True):
                 return
             if self._move_cursor_visual(buffer, backward=True):
@@ -375,6 +365,67 @@ class KeyBindingsMixin:
                 self._esc_last_pressed_at = now
                 return
 
+            is_busy = False
+            is_busy_fn = getattr(self._session, "is_busy", None)
+            if callable(is_busy_fn):
+                is_busy = bool(is_busy_fn())
+            else:
+                is_busy = bool(self._busy)
+            if is_busy:
+                self._session.run_controller.interrupt(reason="user_esc")
+                self._esc_press_count = 0
+                self._esc_last_pressed_at = now
+                return
+
+            peek_queue = getattr(self._session, "peek_queue", None)
+            queued_messages = tuple(peek_queue()) if callable(peek_queue) else ()
+            human_messages = [
+                message
+                for message in queued_messages
+                if getattr(message, "origin", None) == MessageOrigin.HUMAN
+            ]
+            if human_messages:
+                def _editable_text(message) -> str:  # type: ignore[no-untyped-def]
+                    content = getattr(message, "content", "")
+                    if isinstance(content, str):
+                        return content
+                    if isinstance(content, list):
+                        pieces: list[str] = []
+                        for part in content:
+                            if isinstance(part, dict):
+                                part_type = str(part.get("type", ""))
+                                if part_type == "text":
+                                    pieces.append(str(part.get("text", "")))
+                                elif "image" in part_type:
+                                    pieces.append("[image]")
+                            else:
+                                pieces.append(str(part))
+                        return "\n".join(piece for piece in pieces if piece)
+                    return str(content)
+
+                text = "\n\n".join(
+                    piece
+                    for piece in (_editable_text(message) for message in human_messages)
+                    if piece
+                )
+                buffer.text = text
+                buffer.cursor_position = len(text)
+                message_ids = tuple(
+                    str(getattr(message, "message_id"))
+                    for message in human_messages
+                )
+                cancel_many = getattr(self._session, "cancel_many", None)
+                if callable(cancel_many):
+                    cancel_many(message_ids)
+                queued_display = getattr(self, "_queued_display_by_message_id", None)
+                if isinstance(queued_display, dict):
+                    for message_id in message_ids:
+                        queued_display.pop(message_id, None)
+                self._esc_press_count = 0
+                self._esc_last_pressed_at = now
+                self._invalidate()
+                return
+
             if now - self._esc_last_pressed_at > self._esc_clear_window_seconds:
                 self._esc_press_count = 0
             self._esc_press_count += 1