cecli-dev 1.0.0rc9__tar.gz → 1.0.0rc11__tar.gz

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.0rc9
+Version: 1.0.0rc11
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0rc9'
-__version_tuple__ = version_tuple = (1, 0, 0, 'rc9')
+__version__ = version = '1.0.0rc11'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc11')
 
-__commit_id__ = commit_id = 'g898d1fac5'
+__commit_id__ = commit_id = 'g9f297cdf7'

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli/helpers/orchestration/agent_proxy.py

@@ -151,6 +151,16 @@ class AgentProxy:
         """
         from cecli.helpers import nested
 
+        # SECURITY: Reject paths that access private/dunder attributes
+        # (unless disable_security is active)
+        if not (self._env and self._env._orchestration_config.get("disable_security", False)):
+            for segment in path.replace("[", ".").replace("]", "").split("."):
+                segment = segment.strip()
+                if segment.startswith("_") and segment != "_":
+                    from cecli.helpers.orchestration.security import SecurityError
+
+                    raise SecurityError(f"Access to private attribute '{segment}' is forbidden")
+
         return nested.getter(result, path, default)
 
     @staticmethod

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli/helpers/orchestration/environment.py

@@ -26,12 +26,16 @@ from cecli.helpers.orchestration.safe_methods import (
     _HelpfulBuiltins,
     _safe_dir,
     _safe_gather,
+    _safe_getattr,
+    _safe_hasattr,
     _safe_sleep,
     _safe_typeof,
     _safe_vars,
     _SafeJson,
     _SafeModuleProxy,
     _SafePathlib,
+    _SafeRe,
+    _SafeTraceback,
     _strip_allowed_imports,
 )
 from cecli.helpers.orchestration.security import (
@@ -225,6 +229,8 @@ class AgentExecutionEnv:
         self.globals: dict[str, _Any] = {}
         self.locals: dict[str, _Any] = {}
 
+        _disable_sec = self._orchestration_config.get("disable_security", False)
+
         self._safe_builtins: dict[str, _Any] = {
             "print": print,
             "range": range,
@@ -242,8 +248,8 @@ class AgentExecutionEnv:
             "vars": _safe_vars,
             "dir": _make_sandbox_dir(self.globals, self.locals),
             "isinstance": isinstance,
-            "hasattr": hasattr,
-            "getattr": getattr,
+            "hasattr": _safe_hasattr,
+            "getattr": _safe_getattr,
             "repr": repr,
             "enumerate": enumerate,
             "zip": zip,
@@ -272,12 +278,12 @@ class AgentExecutionEnv:
             "StopIteration": StopIteration,
             "ArithmeticError": ArithmeticError,
             "LookupError": LookupError,
-            "re": _SafeModuleProxy(re),
-            "math": _SafeModuleProxy(math),
-            "itertools": _SafeModuleProxy(itertools),
-            "collections": _SafeModuleProxy(collections),
-            "datetime": _SafeModuleProxy(datetime),
-            "traceback": _SafeModuleProxy(traceback),
+            "re": _SafeRe,
+            "math": _SafeModuleProxy(math, disable_security=_disable_sec),
+            "itertools": _SafeModuleProxy(itertools, disable_security=_disable_sec),
+            "collections": _SafeModuleProxy(collections, disable_security=_disable_sec),
+            "datetime": _SafeModuleProxy(datetime, disable_security=_disable_sec),
+            "traceback": _SafeTraceback,
             "pathlib": _SafePathlib,
         }
 
@@ -296,6 +302,9 @@ class AgentExecutionEnv:
         if self._orchestration_config.get("disable_security", False):
             for name in self._DANGEROUS_BUILTINS:
                 self._safe_builtins[name] = __builtins__[name]
+            # Restore real getattr/hasattr when security is disabled
+            self._safe_builtins["getattr"] = getattr
+            self._safe_builtins["hasattr"] = hasattr
 
         # When allow_classes is enabled, expose __build_class__ needed by Python
         if self._orchestration_config.get("allow_classes", False):
@@ -451,6 +460,16 @@ class AgentExecutionEnv:
             code = f"Syntax Error in orchestration code: {e}"
             return {"results": code, "state_variables": self._state_snapshot()}
 
+        def _build_result(msg: str = "") -> dict:
+            print_output = "".join(captured_output)
+            parts = []
+            if print_output:
+                parts.append(print_output.rstrip("\n"))
+            if msg:
+                parts.append(msg)
+            code = "\n".join(parts) if parts else ""
+            return {"results": code, "state_variables": self._state_snapshot()}
+
         try:
             if not self._orchestration_config.get("disable_security", False):
                 tree = SecurityFilter(
@@ -481,16 +500,6 @@ class AgentExecutionEnv:
             code = f"Compilation Error: {e}"
             return {"results": code, "state_variables": self._state_snapshot()}
 
-        def _build_result(msg: str = "") -> dict:
-            print_output = "".join(captured_output)
-            parts = []
-            if print_output:
-                parts.append(print_output.rstrip("\n"))
-            if msg:
-                parts.append(msg)
-            code = "\n".join(parts) if parts else ""
-            return {"results": code, "state_variables": self._state_snapshot()}
-
         try:
             exec(compiled_code, self.globals, self.locals)
             runner_coro = self.locals["__agent_async_runner"]()

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli/helpers/orchestration/safe_methods.py

@@ -10,6 +10,8 @@ from __future__ import annotations
 import asyncio
 import json
 import pathlib
+import re as _re_mod
+import traceback as _tb_mod
 from typing import Any
 
 # ---------------------------------------------------------------------------
@@ -264,8 +266,21 @@ def _safe_typeof(obj: Any) -> type:
 
     Unlike ``type(name, bases, dict)`` which can create new classes at runtime,
     ``_safe_typeof(obj)`` only returns the type of an object for inspection.
+
+    Additionally, when *obj* is itself a type/class whose metaclass is ``type``,
+    the result would be ``<class 'type'>`` — the real ``type`` metaclass.
+    This is blocked because the metaclass can be used to dynamically create
+    arbitrary classes, bypassing the AST-level ``ClassDef`` filter.
     """
-    return type(obj)
+    result = type(obj)
+    if result is type:
+        from cecli.helpers.orchestration.security import SecurityError
+
+        raise SecurityError(
+            "Access to the 'type' metaclass is forbidden in the sandbox. "
+            "Use isinstance() for type checks instead of comparing type objects."
+        )
+    return result
 
 
 def _safe_vars(obj: Any) -> dict:
@@ -337,6 +352,39 @@ def _safe_dir(obj: Any) -> list:
     ]
 
 
+def _safe_getattr(obj: Any, name: str, *args: Any) -> Any:
+    """Safe getattr() - blocks access to private/dunder attributes.
+
+    Raises ``AttributeError`` (matching ``getattr``'s default behavior) when
+    the attribute name starts with ``_``, preventing sandboxed code from
+    bypassing the AST-level private-attribute filter.
+
+    When ``disable_security`` is enabled in orchestration config, the real
+    ``getattr`` is restored so this restriction doesn't apply.
+    """
+    if type(name) is not str:
+        raise TypeError(f"getattr() attribute name must be str, not {type(name).__name__}")
+    if name.startswith("_") and name != "_":
+        raise AttributeError(f"Cannot access private attribute {name!r} in sandbox")
+    return getattr(obj, name, *args)
+
+
+def _safe_hasattr(obj: Any, name: str) -> bool:
+    """Safe hasattr() - blocks probing of private/dunder attributes.
+
+    Returns ``False`` for any attribute name starting with ``_`` so that
+    sandboxed code cannot detect the presence of private attributes.
+
+    When ``disable_security`` is enabled in orchestration config, the real
+    ``hasattr`` is restored so this restriction doesn't apply.
+    """
+    if type(name) is not str:
+        raise TypeError(f"hasattr() attribute name must be str, not {type(name).__name__}")
+    if name.startswith("_") and name != "_":
+        return False
+    return hasattr(obj, name)
+
+
 def _find_closing_quote(code: str, quote: str, start: int) -> int:
     """Find the position of the closing *quote* in *code*, skipping
     backslash-escaped characters so that ``\"`` (escaped quote) is not
@@ -714,23 +762,265 @@ class _SafeJson:
         return json.dumps(obj, **safe_kwargs)
 
 
+class _SafeTraceback:
+    """Drop-in ``traceback`` namespace exposing only safe print and format methods.
+
+    Unlike ``_SafeModuleProxy`` which forwards all non-blocked attributes to the
+    real module, this class only exposes an explicit allowlist of print/format
+    methods.  Module-level imports like ``traceback.sys`` and ``traceback.io``
+    are not accessible through this wrapper, closing the ``sys.modules``
+    sandbox-escape vector.
+
+    Exposed methods:
+
+    **Printing** (output to stderr or a given file):
+    - ``print_exc(limit=None, file=None)`` — print current exception
+    - ``print_exception(exc, limit=None, file=None)`` — print a given exception
+    - ``print_stack(f=None, limit=None, file=None)`` — print current call stack
+    - ``print_tb(tb, limit=None, file=None)`` — print a given traceback
+    - ``print_last(limit=None, file=None)`` — print the last exception
+
+    **Formatting** (return strings for logging):
+    - ``format_exc(limit=None)`` — format current exception as string
+    - ``format_exception(exc, limit=None)`` — format a given exception to list of strings
+    - ``format_stack(f=None, limit=None)`` — format current stack to list of strings
+    - ``format_tb(tb, limit=None)`` — format a given traceback to list of strings
+    - ``format_list(extracted)`` — format extracted stack entries
+    - ``format_exception_only(exc)`` — format exception type + value only
+
+    **Utility**:
+    - ``clear_frames(tb)`` — clear local variables from traceback frames
+
+    **Classes**:
+    - ``TracebackException`` — programmatic traceback representation
+    - ``FrameSummary`` — single frame summary
+    - ``StackSummary`` — list of frame summaries
+    """
+
+    @classmethod
+    def format_exc(cls, limit=None):
+        import traceback
+
+        return traceback.format_exc(limit=limit)
+
+    @classmethod
+    def format_exception(cls, exc, limit=None):
+        import traceback
+
+        return traceback.format_exception(exc, limit=limit)
+
+    @classmethod
+    def format_stack(cls, f=None, limit=None):
+        import traceback
+
+        return traceback.format_stack(f=f, limit=limit)
+
+    @classmethod
+    def format_tb(cls, tb, limit=None):
+        import traceback
+
+        return traceback.format_tb(tb, limit=limit)
+
+    @classmethod
+    def format_list(cls, extracted):
+        import traceback
+
+        return traceback.format_list(extracted)
+
+    @classmethod
+    def format_exception_only(cls, exc):
+        import traceback
+
+        return traceback.format_exception_only(exc)
+
+    @classmethod
+    def print_exc(cls, limit=None, file=None):
+        import traceback
+
+        traceback.print_exc(limit=limit, file=file)
+
+    @classmethod
+    def print_exception(cls, exc, limit=None, file=None):
+        import traceback
+
+        traceback.print_exception(exc, limit=limit, file=file)
+
+    @classmethod
+    def print_stack(cls, f=None, limit=None, file=None):
+        import traceback
+
+        traceback.print_stack(f=f, limit=limit, file=file)
+
+    @classmethod
+    def print_tb(cls, tb, limit=None, file=None):
+        import traceback
+
+        traceback.print_tb(tb, limit=limit, file=file)
+
+    @classmethod
+    def print_last(cls, limit=None, file=None):
+        import traceback
+
+        traceback.print_last(limit=limit, file=file)
+
+    @classmethod
+    def clear_frames(cls, tb):
+        import traceback
+
+        traceback.clear_frames(tb)
+
+    # Classes from traceback — accessed via class attribute, not instance
+    TracebackException = None
+    FrameSummary = None
+    StackSummary = None
+
+
+_SafeTraceback.TracebackException = _tb_mod.TracebackException
+_SafeTraceback.FrameSummary = _tb_mod.FrameSummary
+_SafeTraceback.StackSummary = _tb_mod.StackSummary
+
+
+class _SafeRe:
+    """Drop-in ``re`` namespace exposing only safe regex operations.
+
+    Unlike ``_SafeModuleProxy`` which forwards all non-blocked attributes to the
+    real module, this class only exposes an explicit allowlist of regex
+    functions, flags, and types.  Module-level imports like ``re.enum``,
+    ``re.copyreg``, and ``re.functools`` are not accessible through this
+    wrapper, closing the ``re.enum.sys`` sandbox-escape vector.
+
+    Exposed:
+
+    **Compilation**:
+    - ``compile(pattern, flags=0)`` — compile a regex pattern
+
+    **Searching / Matching**:
+    - ``search(pattern, string, flags=0)`` — scan through string
+    - ``match(pattern, string, flags=0)`` — match at start of string
+    - ``fullmatch(pattern, string, flags=0)`` — match whole string
+    - ``findall(pattern, string, flags=0)`` — all non-overlapping matches
+    - ``finditer(pattern, string, flags=0)`` — iterator over matches
+
+    **Substitution / Splitting**:
+    - ``sub(pattern, repl, string, ...)`` — substitute
+    - ``subn(pattern, repl, string, ...)`` — substitute with count
+    - ``split(pattern, string, ...)`` — split by pattern
+
+    **Utilities**:
+    - ``escape(string)`` — escape special characters
+    - ``purge()`` — clear the regex cache
+
+    **Flags**:
+    - ``NOFLAG``, ``IGNORECASE`` / ``I``, ``MULTILINE`` / ``M``,
+      ``DOTALL`` / ``S``, ``VERBOSE`` / ``X``, ``ASCII`` / ``A``
+    - ``RegexFlag`` — the flag enum type
+
+    **Types / Exceptions**:
+    - ``Pattern`` — compiled pattern type
+    - ``Match`` — match result type
+    - ``error`` — regex exception class
+    """
+
+    # Compilation
+    compile = None
+
+    # Searching / Matching
+    search = None
+    match = None
+    fullmatch = None
+    findall = None
+    finditer = None
+
+    # Substitution / Splitting
+    sub = None
+    subn = None
+    split = None
+
+    # Utilities
+    escape = None
+    purge = None
+
+    # Flags
+    NOFLAG = None
+    IGNORECASE = None
+    I = None  # noqa: E741
+    MULTILINE = None
+    M = None
+    DOTALL = None
+    S = None
+    VERBOSE = None
+    X = None
+    ASCII = None
+    A = None
+    RegexFlag = None
+
+    # Types / Exceptions
+    Pattern = None
+    Match = None
+    error = None
+
+
+for _name in dir(_SafeRe):
+    if not _name.startswith("_"):
+        try:
+            setattr(_SafeRe, _name, getattr(_re_mod, _name))
+        except AttributeError:
+            pass
+
+
 class _SafeModuleProxy:
     """Proxy that forwards attribute reads to a real module but prevents mutation.
 
     Setting an attribute on the proxy only affects the proxy, not the real module.
     This prevents sandbox code from monkey-patching standard library modules.
+
+    The following methods are blocked and raise SecurityError:
+    - ``walk_stack()``, ``walk_tb()``, ``extract_stack()`` — frame introspection
+      that exposes unwrapped frame objects with access to parent-frame
+      ``f_locals`` / ``f_globals``.
     """
 
-    def __init__(self, module: Any) -> None:
+    _BLOCKED_METHODS: frozenset[str] = frozenset({"walk_stack", "walk_tb", "extract_stack"})
+
+    def __init__(self, module: Any, *, disable_security: bool = False) -> None:
         object.__setattr__(self, "_module", module)
+        object.__setattr__(self, "_disable_security", disable_security)
 
     def __getattr__(self, name: str) -> Any:
         if name.startswith("_"):
             raise AttributeError(
                 "Cannot access private attribute " + repr(name) + " on module proxy"
             )
+        if name in self._BLOCKED_METHODS and not object.__getattribute__(self, "_disable_security"):
+            from cecli.helpers.orchestration.security import SecurityError
+
+            raise SecurityError(
+                f"Cannot access '{name}' on module proxy. "
+                f"Frame introspection methods are blocked in the sandbox."
+            )
+        if name == "modules" and not object.__getattribute__(self, "_disable_security"):
+            from cecli.helpers.orchestration.security import SecurityError
+
+            raise SecurityError(
+                f"Cannot access '{name}' on module proxy. "
+                f"Direct module registry access is blocked in the sandbox."
+            )
         module = object.__getattribute__(self, "_module")
-        return getattr(module, name)
+        attr = getattr(module, name)
+
+        # Re-wrap sub-modules to prevent transitive sandbox escape.
+        # Without this, `re.enum.sys` would return the real `sys` module
+        # (since `re` imports `enum` and `enum` imports `sys`), giving
+        # attackers access to `sys.modules["builtins"].getattr` and from
+        # there unrestricted private-attribute access.
+        from types import ModuleType
+
+        if isinstance(attr, ModuleType):
+            return _SafeModuleProxy(
+                attr, disable_security=object.__getattribute__(self, "_disable_security")
+            )
+
+        return attr
 
     def __setattr__(self, name: str, value: Any) -> None:
         if not name.startswith("_"):
@@ -739,7 +1029,10 @@ class _SafeModuleProxy:
 
     def __dir__(self) -> list:
         module = object.__getattribute__(self, "_module")
-        return [x for x in dir(module) if not x.startswith("_")]
+        blocked = (
+            set() if object.__getattribute__(self, "_disable_security") else self._BLOCKED_METHODS
+        )
+        return [x for x in dir(module) if not x.startswith("_") and x not in blocked]
 
 
 # ---------------------------------------------------------------------------

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli/helpers/orchestration/security.py

@@ -217,6 +217,19 @@ class SecurityFilter(ast.NodeTransformer):
 
         return self.generic_visit(node)
 
+    def visit_Match(self, node: ast.Match) -> ast.Expr:
+        """Block all ``match``/``case`` statements.
+
+        Class patterns destructure objects via runtime ``getattr()``,
+        bypassing the AST-level ``visit_Attribute`` guard entirely.
+        Rather than trying to cover every pattern variant, we reject
+        the ``match`` statement wholesale.
+        """
+        return self._make_raise_stmt(
+            f"Security filter error at line {node.lineno}: "
+            "The 'match'/'case' statement is disabled in the orchestration environment."
+        )
+
 
 class LoopYieldInjector(ast.NodeTransformer):
     """

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli/tools/command.py

@@ -88,6 +88,13 @@ class Tool(BaseTool):
                         ),
                         "default": False,
                     },
+                    "timeout": {
+                        "type": "integer",
+                        "description": (
+                            "Timeout in seconds for command execution. " "Default is 30 seconds."
+                        ),
+                        "default": 30,
+                    },
                 },
                 "required": [],
             },
@@ -114,6 +121,7 @@ class Tool(BaseTool):
         stdin=None,
         pty=False,
         user_input_required=False,
+        timeout=0,
         **kwargs,
     ):
         """
@@ -125,7 +133,7 @@ class Tool(BaseTool):
         or navigate terminal interfaces.
         For background interactions: provide 'background_key' + 'action' (stdin/stop).
 
-        Commands run with timeout based on agent_config['command_timeout'] (default: 30 seconds).
+        Commands run with timeout from agent_config['command_timeout'] (default: 30 seconds),
         """
         response = ToolResponse(
             "command",
@@ -181,10 +189,15 @@ class Tool(BaseTool):
 
         command = coder.format_command_with_prefix(command)
 
-        # Determine timeout from agent_config (default: 30 seconds)
-        timeout = 0
+        # Determine timeout from agent_config (default: 30 seconds) as fallback
+        config_timeout = 0
         if hasattr(coder, "agent_config"):
-            timeout = coder.agent_config.get("command_timeout", 30)
+            config_timeout = coder.agent_config.get("command_timeout", 30)
+        # Use LLM-specified timeout if provided, otherwise fallback to config
+        if timeout == 0:
+            timeout = config_timeout
+        # Clamp LLM timeout between config_timeout (minimum) and max(300, config_timeout) (maximum)
+        timeout = max(config_timeout, min(timeout, max(300, config_timeout)))
 
         if user_input_required:
             return await cls._execute_interactive(coder, command)
@@ -390,7 +403,7 @@ class Tool(BaseTool):
                 # Format output
                 output_content = output or ""
                 # Tokens are roughly 3-4 characters
-                output_limit = coder.large_file_token_threshold * 3.5
+                output_limit = int(coder.large_file_token_threshold * 3.5)
 
                 if coder.context_management_enabled and len(output_content) > output_limit * 1.25:
                     # Save full output to paginated files instead of truncating
@@ -641,6 +654,7 @@ class Tool(BaseTool):
         action = params.get("action")
         stdin = params.get("stdin")
         pty = params.get("pty", False)
+        timeout = params.get("timeout", 30)
         user_input_required = params.get("user_input_required", False)
 
         coder.io.tool_output("")
@@ -655,6 +669,8 @@ class Tool(BaseTool):
             extras.append(f"action={action}")
         if pty:
             extras.append("pty=True")
+        if timeout != 30:
+            extras.append(f"timeout={timeout}s")
         if user_input_required:
             extras.append("user_input_required=True")
 

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.0rc9
+Version: 1.0.0rc11
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

cecli_dev-1.0.0rc11/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.0rc11",
+  "distance": 0,
+  "node": "g9f297cdf776e8d04e590cb7648f69ab638ff489a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-22"
+}

{cecli_dev-1.0.0rc9 → cecli_dev-1.0.0rc11}/tests/mcp/test_keepalive_integration.py

@@ -68,10 +68,18 @@ class TestKeepaliveWithMockServer:
         running_mock_server.set_status(500)
 
         # Wait for failed ping
-        await asyncio.sleep(1.2)
+        # Wait for failed ping with polling for cross-platform reliability
+        for _ in range(30):  # 30 * 0.2s = 6s timeout
+            if inspector.get_state(server) == ConnectionState.UNHEALTHY:
+                break
+            await asyncio.sleep(0.2)
+        else:
+            pytest.fail(
+                f"Server did not become UNHEALTHY after failures, state was "
+                f"{inspector.get_state(server).name}"
+            )
 
         # Should transition to UNHEALTHY
-        assert inspector.get_state(server) == ConnectionState.UNHEALTHY
         assert inspector.get_failed_pings(server) == 1
 
         await server.disconnect()
@@ -115,14 +123,33 @@ class TestKeepaliveWithMockServer:
 
         # Cause a failure
         running_mock_server.set_status(500)
-        await asyncio.sleep(1.2)
+        for _ in range(30):  # 30 * 0.2s = 6s timeout
+            if inspector.get_state(server) == ConnectionState.UNHEALTHY:
+                break
+            await asyncio.sleep(0.2)
+        else:
+            pytest.fail(
+                f"Server did not become UNHEALTHY after failures, state was "
+                f"{inspector.get_state(server).name}"
+            )
         assert inspector.get_state(server) == ConnectionState.UNHEALTHY
 
         # Restore success
         running_mock_server.set_status(200)
-        await asyncio.sleep(1.2)
+        for _ in range(30):  # 30 * 0.2s = 6s timeout
+            if inspector.get_state(server) == ConnectionState.CONNECTED:
+                break
+            await asyncio.sleep(0.2)
+        else:
+            pytest.fail(
+                f"Server did not become CONNECTED after success, state was "
+                f"{inspector.get_state(server).name}"
+            )
 
         # Should be back to CONNECTED
+
+        # Brief cooldown after state transition
+        await asyncio.sleep(0.2)
         assert inspector.get_state(server) == ConnectionState.CONNECTED
         assert inspector.get_failed_pings(server) == 0
 

cecli_dev-1.0.0rc9/cecli_dev.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.0.0rc9",
-  "distance": 0,
-  "node": "g898d1fac51b39c298f49969fc613017e5544712f",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-07-21"
-}