cecli-dev 0.100.5__tar.gz → 0.100.6rc2__tar.gz

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.5
+Version: 0.100.6rc2
 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-0.100.5 → cecli_dev-0.100.6rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.5'
-__version_tuple__ = version_tuple = (0, 100, 5)
+__version__ = version = '0.100.6rc2'
+__version_tuple__ = version_tuple = (0, 100, 6, 'rc2')
 
-__commit_id__ = commit_id = 'g525f9aba5'
+__commit_id__ = commit_id = 'g2be4b1f66'

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/args.py

@@ -276,7 +276,10 @@ def get_parser(default_config_files, git_root):
     group.add_argument(
         "--retries",
         metavar="RETRIES_JSON",
-        help="Specify LLM retry configuration as a JSON string",
+        help=(
+            'Specify LLM retry configuration as a JSON/YAML string (e.g., \'{"retry_on_empty": '
+            "true}')"
+        ),
         default=None,
     )
 

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/args_formatter.py

@@ -132,6 +132,16 @@ class YamlHelpFormatter(argparse.HelpFormatter):
                 break
         switch = switch.lstrip("-")
 
+        if switch == "retries":
+            parts.append(f"## {action.help}")
+            parts.append("#retries:")
+            parts.append("#  retry-timeout: 60")
+            parts.append("#  retry-backoff-factor: 2.0")
+            parts.append("#  retry-on-unavailable: true")
+            parts.append("#  retry-on-empty: false")
+            parts.append("")
+            return "\n".join(parts)
+
         if isinstance(action, argparse._StoreTrueAction):
             default = False
         elif isinstance(action, argparse._StoreConstAction):

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/coders/agent_coder.py

@@ -1115,7 +1115,7 @@ class AgentCoder(Coder):
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
                 "File editing tools are currently disabled. Use `ReadRange` to determine the"
-                " current content hash prefixes needed to perform an edit and activate them when"
+                " current content ID prefixes needed to perform an edit and activate them when"
                 " you are ready to edit a file."
             )
 

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/coders/base_coder.py

@@ -46,6 +46,7 @@ from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.history import ChatSummary
 from cecli.hooks import HookIntegration
 from cecli.io import ConfirmGroup, InputOutput
@@ -91,6 +92,10 @@ class FinishReasonLength(Exception):
     pass
 
 
+class EmptyResponseError(Exception):
+    pass
+
+
 def wrap_fence(name):
     return f"<{name}>", f"</{name}>"
 
@@ -420,7 +425,7 @@ class Coder(metaclass=UsageMeta):
         # Each contains "included" and "excluded" sets that filter from the global singletons
         self.registered_tools = {"included": set(), "excluded": set()}
         self.registered_servers = {"included": set(), "excluded": set()}
-        self.interrupt_event = asyncio.Event()
+        self.interrupt_event = ThreadSafeEvent()
         self.uuid = str(generate_unique_id())
 
         if uuid:
@@ -1643,6 +1648,7 @@ class Coder(metaclass=UsageMeta):
 
     async def generate(self, user_message, preproc):
         await asyncio.sleep(0.1)
+        self.interrupt_event.clear()
 
         try:
             if self.enable_context_compaction:
@@ -2402,6 +2408,39 @@ class Coder(metaclass=UsageMeta):
                     async for chunk in self.send(messages, tools=self.get_tool_list()):
                         yield chunk
                     break
+                except EmptyResponseError:
+                    self.io.tool_warning(self.empty_llm_tool_warning())
+
+                    retry_on_empty = False
+                    retries_config = self.get_active_model().retries
+                    if isinstance(retries_config, str):
+                        try:
+                            retries_config = json.loads(retries_config)
+                        except json.JSONDecodeError:
+                            self.io.tool_warning(
+                                f"Could not parse retries config: {retries_config}"
+                            )
+                            retries_config = {}
+                    if isinstance(retries_config, dict):
+                        retry_on_empty = retries_config.get("retry_on_empty", False)
+
+                    if not retry_on_empty:
+                        break
+
+                    retry_delay *= 2
+                    if retry_delay > RETRY_TIMEOUT:
+                        self.io.tool_error("Retry timeout exceeded on empty response.")
+                        break
+
+                    self.io.tool_output(f"Retrying in {retry_delay:.1f} seconds...")
+
+                    _res, interrupted_sleep = await coroutines.interruptible(
+                        asyncio.sleep(retry_delay), self.interrupt_event
+                    )
+                    if interrupted_sleep:
+                        interrupted = True
+                        break
+                    continue
                 except litellm_ex.exceptions_tuple() as err:
                     ex_info = litellm_ex.get_ex_info(err)
 
@@ -3252,6 +3291,7 @@ class Coder(metaclass=UsageMeta):
         self.interrupt_event.clear()
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
+        self.empty_response = False
 
         self._streaming_buffer_length = 0
         self.io.reset_streaming_response()
@@ -3302,6 +3342,9 @@ class Coder(metaclass=UsageMeta):
             else:
                 await self.show_send_output(completion)
 
+            if self.empty_response:
+                raise EmptyResponseError
+
             response, func_err, content_err = self.consolidate_chunks()
 
             if response:
@@ -3382,7 +3425,8 @@ class Coder(metaclass=UsageMeta):
             and not len(self.partial_response_tool_calls)
             and not len(self.partial_response_reasoning_content)
         ):
-            self.io.tool_warning(self.empty_llm_tool_warning())
+            self.empty_response = True
+            return
 
         self.io.assistant_output(show_resp, pretty=self.show_pretty())
 
@@ -3539,7 +3583,8 @@ class Coder(metaclass=UsageMeta):
             return
 
         if not received_content and len(self.partial_response_tool_calls) == 0:
-            self.io.tool_warning(self.empty_llm_tool_warning())
+            self.empty_response = True
+            return
 
     def consolidate_chunks(self):
         if self.partial_response_consolidated:

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/commands/core.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 import re
 import sys
@@ -7,6 +6,7 @@ from pathlib import Path
 from cecli.commands.utils.registry import CommandRegistry
 from cecli.helpers import nested, plugin_manager
 from cecli.helpers.file_searcher import handle_core_files
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.repo import ANY_GIT_ERROR
 
 
@@ -94,7 +94,7 @@ class Commands:
         self.custom_commands = nested.getter(customizations, "command-paths", [])
         self._load_custom_commands(self.custom_commands)
 
-        self.cmd_running_event = asyncio.Event()
+        self.cmd_running_event = ThreadSafeEvent()
         self.cmd_running_event.set()
         self.last_command_show_notification = True
 

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/helpers/conversation/files.py

@@ -281,14 +281,17 @@ class ConversationFiles:
             diff_message = {
                 "role": "user",
                 "content": (
-                    f"{rel_fname} has been updated. Here is a git diff of the changes to"
-                    f" review:\n\n{diff}"
+                    f"{rel_fname} has been updated. Review this git diff of the changes to"
+                    f" ensure the modifications are intended:\n\n{diff}"
                 ),
             }
 
             assistant_msg = {
                 "role": "assistant",
-                "content": f"Thank you for sharing this diff of the updates to {rel_fname}.",
+                "content": (
+                    f"Thank you for sharing this diff of the updates to {rel_fname}."
+                    " I will review their contents next turn."
+                ),
             }
 
             ConversationService.get_manager(coder).add_message(

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/helpers/coroutines.py

@@ -1,5 +1,7 @@
 import asyncio
 
+from cecli.helpers.threading import ThreadSafeEvent
+
 
 async def interruptible_async_generator(async_generator, interrupt_event):
     """
@@ -57,7 +59,7 @@ async def interruptible(coroutine, interrupt_event):
         - If interrupted: (None, True)
     """
     if interrupt_event is None:
-        interrupt_event = asyncio.Event()
+        interrupt_event = ThreadSafeEvent()
 
     main_task = asyncio.create_task(coroutine)
     interrupt_task = asyncio.create_task(interrupt_event.wait())

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/helpers/hashline.py

@@ -650,6 +650,20 @@ def _apply_start_stitching(
                     # The replacement line matches the line being replaced
                     # Don't stitch to a line in lines_before_range
                     continue
+
+                # Require 2 consecutive matching lines to avoid false positives
+                # (single boilerplate lines like "import sys" or "def foo():"
+                # are too likely to be coincidental)
+                if line_idx + 1 < len(replacement_lines) and match_index + 1 < len(
+                    lines_before_range_normalized
+                ):
+                    next_repl = replacement_lines[line_idx + 1]
+                    next_repl_stripped = strip_hashline(next_repl)
+                    if not next_repl_stripped.endswith("\n"):
+                        next_repl_stripped += "\n"
+                    if next_repl_stripped != lines_before_range_normalized[match_index + 1]:
+                        continue  # Only 1 line matches — likely coincidental
+
                 # Found a line that already exists before the range!
                 # This is a non-contiguous match - we need to "stitch" the replacement
                 # at this exact content match to prevent duplicate code structures
@@ -694,9 +708,9 @@ def _apply_start_stitching(
                     start_idx = new_start_idx
                     replacement_lines = new_replacement_lines
                 else:
-                    # Can't extend backward due to overlap, but we can still truncate
-                    # the replacement text to avoid duplication
-                    replacement_lines = new_replacement_lines
+                    # Can't extend backward due to overlap with another operation
+                    # Don't truncate without extending — that would silently lose content
+                    continue  # Try next line instead
 
                 # We've found our stitching point, break out of the loop
                 break
@@ -772,6 +786,15 @@ def _apply_end_stitching(
             # Check if this line exists anywhere in lines_after_range_normalized
             try:
                 match_index = lines_after_range_normalized.index(replacement_line_stripped)
+
+                # Require 2 consecutive matching lines to reduce false positives
+                if line_idx - 1 >= 0 and match_index - 1 >= 0:
+                    prev_repl = replacement_lines[line_idx - 1]
+                    prev_repl_stripped = strip_hashline(prev_repl)
+                    if not prev_repl_stripped.endswith("\n"):
+                        prev_repl_stripped += "\n"
+                    if prev_repl_stripped != lines_after_range_normalized[match_index - 1]:
+                        continue  # Only 1 line matches — likely coincidental
                 # Found a line that already exists after the range!
                 # This is a non-contiguous match - we need to "stitch" the replacement
                 # at this exact content match to prevent duplicate code structures
@@ -900,109 +923,6 @@ def _apply_range_shifting(hashed_lines, resolved_ops):
     return resolved_ops
 
 
-# Regex configuration
-RE_CODE_NOISE = r'(#.*|//.*|/\*[\s\S]*?\*/|"(?:\\.|[^"\\])*"|\'(?:\\.|[^\'\\])*\')'
-
-
-def get_brace_balance(lines_to_check: list[str]) -> int:
-    """
-    Calculates the net curly brace debt of a list of lines.
-    Automatically strips hashlines, comments, and string literals.
-    """
-    text = "".join(lines_to_check)
-    clean_code = strip_hashline(text)
-    clean_code = re.sub(RE_CODE_NOISE, "", clean_code)
-    return clean_code.count("{") - clean_code.count("}")
-
-
-def _apply_closure_safeguard(hashed_lines, resolved_ops):
-    """
-    Enhanced closure safeguard with dynamic bidirectional search.
-    """
-    # Tune these to adjust how far the 'healing' logic searches
-    MAX_LOOK_DOWN = 5
-    # Note: We'll calculate the actual MAX_LOOK_UP per operation
-    # to ensure we don't scan past the start_idx.
-
-    for i, resolved in enumerate(resolved_ops):
-        op = resolved["op"]
-        if op["operation"] not in {"replace", "delete"}:
-            continue
-
-        replacement_text = op.get("text", "") or ""
-        replacement_lines = replacement_text.splitlines(keepends=True)
-
-        # --- PHASE 1: BIDIRECTIONAL STRUCTURAL HEALING ---
-        if get_brace_balance([replacement_text]) == 0:
-            start_idx = resolved["start_idx"]
-            orig_end_idx = resolved["end_idx"]
-
-            if get_brace_balance(hashed_lines[start_idx : orig_end_idx + 1]) != 0:
-                # Dynamic Search List Generation
-                # We limit look-up so we don't scan before the start_idx
-                actual_max_up = orig_end_idx - start_idx
-                actual_max_down = max(MAX_LOOK_DOWN, orig_end_idx - start_idx)
-                search_offsets = []
-
-                # Generate alternating offsets: [1, -1, 2, -2, ... N]
-                for dist in range(1, max(actual_max_down, actual_max_up) + 1):
-                    if dist <= actual_max_down:
-                        search_offsets.append(dist)
-                    if dist <= actual_max_up:
-                        search_offsets.append(-dist)
-
-                for offset in search_offsets:
-                    candidate_end = orig_end_idx + offset
-
-                    # Safety: check bounds and avoid overlapping other ops
-                    if candidate_end < start_idx or candidate_end >= len(hashed_lines):
-                        continue
-
-                    if any(
-                        j != i and (other["start_idx"] <= candidate_end <= other["end_idx"])
-                        for j, other in enumerate(resolved_ops)
-                    ):
-                        continue
-
-                    if get_brace_balance(hashed_lines[start_idx : candidate_end + 1]) == 0:
-                        resolved["end_idx"] = candidate_end
-                        break
-
-        # --- PHASE 2: CONTRACTION (Indentation Guard) ---
-        # Prevents replacing an outer-scope brace if the replacement text already
-        # includes its own correctly indented closer.
-        if not replacement_lines:
-            continue
-
-        last_repl_line = strip_hashline(replacement_lines[-1])
-        last_repl_stripped = last_repl_line.strip().rstrip(";,")
-
-        if last_repl_stripped and last_repl_stripped[-1] in "})]":
-            # Calculate replacement indent
-            repl_indent = len(last_repl_line) - len(last_repl_line.lstrip(" \t"))
-
-            if resolved["end_idx"] < len(hashed_lines):
-                end_line = strip_hashline(hashed_lines[resolved["end_idx"]])
-                check_end = end_line.strip().rstrip(";,")
-
-                if check_end and check_end[-1] in "})]":
-                    # Calculate indent of the existing brace in the file
-                    file_indent = len(end_line) - len(end_line.lstrip(" \t"))
-
-                    # If the file's brace is less indented, it belongs to an outer scope
-                    if file_indent < repl_indent and resolved["end_idx"] > resolved["start_idx"]:
-                        new_end_idx = resolved["end_idx"] - 1
-
-                        # Safety: don't contract into another operation's territory
-                        if not any(
-                            j != i and (other["start_idx"] <= new_end_idx <= other["end_idx"])
-                            for j, other in enumerate(resolved_ops)
-                        ):
-                            resolved["end_idx"] = new_end_idx
-
-    return resolved_ops
-
-
 def _merge_replace_operations(resolved_ops):
     """
     Merge contiguous or overlapping replace operations.
@@ -1411,9 +1331,6 @@ def apply_hashline_operations(
     resolved_ops = _merge_replace_operations(resolved_ops)
     # Apply content-aware range expansion/shifting for replace operations
     # resolved_ops = _apply_range_shifting(hashed_lines, resolved_ops)
-    # Apply closure safeguard for braces/brackets
-    resolved_ops = _apply_closure_safeguard(hashed_lines, resolved_ops)
-
     # Sort by start_idx descending to apply from bottom to top
     # When operations have same start_idx, apply in order: insert, replace, delete
     # This ensures correct behavior when multiple operations target the same line

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/helpers/hashpos/hashpos.py

@@ -52,7 +52,7 @@ class HashPos:
     def generate_public_id(self, text: str, line_idx: int) -> str:
         """
         Generates a 4-char Base64 ID combining modulo buckets and context hash.
-        Layout: [2-bit b1] [10-bit Hash A] [2-bit b2] [10-bit Hash B]
+        Layout: [2-bit b1] [2-bit b2] [10-bit Hash A] [10-bit Hash B]
         """
         b1, b2 = self._get_region_bits(line_idx)
         neighborhood_hash = self._get_neighborhood_hash(line_idx)
@@ -62,8 +62,7 @@ class HashPos:
         hash_b = neighborhood_hash & 0x3FF
 
         # Construct the mixed 24-bit integer
-        packed = (b1 << 22) | (hash_a << 12) | (b2 << 10) | hash_b
-
+        packed = (b1 << 22) | (b2 << 20) | (hash_a << 10) | hash_b
         res = ""
         for _ in range(4):
             res += self.B64[packed % 64]
@@ -79,10 +78,9 @@ class HashPos:
             packed |= self.B64.index(char) << (6 * i)
 
         b1 = (packed >> 22) & 3
-        hash_a = (packed >> 12) & 0x3FF
-        b2 = (packed >> 10) & 3
+        b2 = (packed >> 20) & 3
+        hash_a = (packed >> 10) & 0x3FF
         hash_b = packed & 0x3FF
-
         mod_val = (b1 << 2) | b2
         neighborhood_hash = (hash_a << 10) | hash_b
 

cecli_dev-0.100.6rc2/cecli/helpers/threading.py

@@ -0,0 +1,46 @@
+import asyncio
+import threading
+
+
+class ThreadSafeEvent:
+    def __init__(self):
+        self._async_event = asyncio.Event()
+        self._thread_event = threading.Event()
+
+    @staticmethod
+    def _get_loop():
+        """Dynamically resolve the running event loop (not cached)."""
+        try:
+            return asyncio.get_running_loop()
+        except RuntimeError:
+            return None
+
+    def set(self):
+        """Can be called from ANY thread or coroutine safely."""
+        # Unblock threads
+        self._thread_event.set()
+        # Unblock async loop
+        if loop := self._get_loop():
+            loop.call_soon_threadsafe(self._async_event.set)
+        else:
+            self._async_event.set()
+
+    def clear(self):
+        """Can be called from ANY thread or coroutine safely."""
+        self._thread_event.clear()
+        if loop := self._get_loop():
+            loop.call_soon_threadsafe(self._async_event.clear)
+        else:
+            self._async_event.clear()
+
+    def is_set(self):
+        """Thread-safe check."""
+        return self._thread_event.is_set()
+
+    def thread_wait(self, timeout=None):
+        """Call this from your background OS Thread."""
+        return self._thread_event.wait(timeout=timeout)
+
+    async def wait(self):
+        """Call this (with await) from your Async Coroutines."""
+        await self._async_event.wait()

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/io.py

@@ -43,6 +43,7 @@ from rich.text import Text
 
 from cecli.commands import SwitchCoderSignal
 from cecli.helpers import coroutines
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.report import update_error_prefix
 
 from .dump import dump  # noqa: F401
@@ -395,7 +396,7 @@ class InputOutput:
         self.linear = False
 
         # State tracking for confirmation input
-        self.confirmation_in_progress_event = asyncio.Event()
+        self.confirmation_in_progress_event = ThreadSafeEvent()
         self.confirmation_in_progress_event.set()  # Initially set, meaning no confirmation in progress
         self.confirmation_acknowledgement = False
         self.confirmation_input_active = False

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/linter.py

@@ -12,6 +12,7 @@ import oslex
 from cecli.dump import dump  # noqa: F401
 from cecli.helpers.grep_ast import TreeContext, filename_to_lang
 from cecli.helpers.grep_ast.tsl import get_parser  # noqa: E402
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.run_cmd import run_cmd_async, run_cmd_subprocess  # noqa: F401
 
 # tree_sitter is throwing a FutureWarning
@@ -22,7 +23,7 @@ class Linter:
     def __init__(self, encoding="utf-8", root=None, interrupt_event=None):
         self.encoding = encoding
         self.root = root
-        self.interrupt_event = interrupt_event or asyncio.Event()
+        self.interrupt_event = interrupt_event or ThreadSafeEvent()
 
         self.languages = dict(
             python=self.py_lint,

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/mcp/server.py

@@ -42,6 +42,7 @@ class McpServer:
         self.io = io
         self.verbose = verbose
         self.session = None
+        self._connection_loop: asyncio.AbstractEventLoop | None = None
         self._cleanup_lock: asyncio.Lock = asyncio.Lock()
         self.exit_stack = AsyncExitStack()
 
@@ -59,10 +60,17 @@ class McpServer:
         Returns:
             ClientSession: The active session if mcp is not disabled
         """
+        current_loop = asyncio.get_running_loop()
         if self.session is not None:
+            # Event loop affinity check: streams from stdio_client() are bound
+            # to the loop that created them.  Reconnect if the loop changed.
+            if self._connection_loop is current_loop:
+                if self.verbose and self.io:
+                    self.io.tool_output(f"Using existing session for MCP server: {self.name}")
+                return self.session
             if self.verbose and self.io:
-                self.io.tool_output(f"Using existing session for MCP server: {self.name}")
-            return self.session
+                self.io.tool_output(f"Reconnecting MCP server {self.name} (event loop changed)")
+            await self.disconnect()
 
         if self.verbose and self.io:
             self.io.tool_output(f"Establishing new connection to MCP server: {self.name}")
@@ -87,6 +95,7 @@ class McpServer:
                 session = await self.exit_stack.enter_async_context(ClientSession(read, write))
                 await session.initialize()
                 self.session = session
+                self._connection_loop = current_loop
                 return session
         except Exception as e:
             logging.error(f"Error initializing server {self.name}: {e}")
@@ -193,10 +202,15 @@ class HttpBasedMcpServer(McpServer):
         raise NotImplementedError("Subclasses must implement _create_transport")
 
     async def connect(self):
+        current_loop = asyncio.get_running_loop()
         if self.session is not None:
+            if self._connection_loop is current_loop:
+                if self.verbose and self.io:
+                    self.io.tool_output(f"Using existing session for {self.name}")
+                return self.session
             if self.verbose and self.io:
-                self.io.tool_output(f"Using existing session for {self.name}")
-            return self.session
+                self.io.tool_output(f"Reconnecting {self.name} (event loop changed)")
+            await self.disconnect()
 
         if self.verbose and self.io:
             self.io.tool_output(f"Establishing new connection to {self.name}")
@@ -224,6 +238,7 @@ class HttpBasedMcpServer(McpServer):
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
             await session.initialize()
             self.session = session
+            self._connection_loop = current_loop
 
             if oauth_provider.context.oauth_metadata:
                 token_endpoint = oauth_provider._get_token_endpoint()
@@ -270,9 +285,13 @@ class SseServer(McpServer):
     """SSE (Server-Sent Events) MCP server using mcp.client.sse_client."""
 
     async def connect(self):
+        current_loop = asyncio.get_running_loop()
         if self.session is not None:
-            logging.info(f"Using existing session for SSE MCP server: {self.name}")
-            return self.session
+            if self._connection_loop is current_loop:
+                logging.info(f"Using existing session for SSE MCP server: {self.name}")
+                return self.session
+            logging.info(f"Reconnecting SSE MCP server {self.name} (event loop changed)")
+            await self.disconnect()
 
         logging.info(f"Establishing new connection to SSE MCP server: {self.name}")
         try:
@@ -285,6 +304,7 @@ class SseServer(McpServer):
             session = await self.exit_stack.enter_async_context(ClientSession(read, write))
             await session.initialize()
             self.session = session
+            self._connection_loop = current_loop
             return session
         except Exception as e:
             logging.error(f"Error initializing SSE server {self.name}: {e}")

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/prompts/agent.yml

@@ -29,8 +29,8 @@ main_system: |
 
   <context name="file_format">
   ### 1. FILE FORMAT
-  File contents will be prefixed with identifiers. Each line starts with a case-sensitive content hash followed by `::`. These are used to target where editing tools will perform edits.
-  They are algorithmically generated, maintained, and subject to change. Do not search for these content hashes. Focus on the lines they identify.
+  File contents will be prefixed with identifiers. Each line starts with a case-sensitive content ID followed by `::`. These are used to target where editing tools will perform edits.
+  They are algorithmically generated, maintained, and subject to change. Do not search for these content IDs. Focus on the lines they identify.
 
   **Example File Format :**
   il9n::#!/usr/bin/env python3

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/prompts/hashline.yml

@@ -6,7 +6,7 @@ main_system: |
   Act as an expert software developer. Plan carefully, explain your logic briefly, and execute via LOCATE/CONTENTS blocks.
 
   ### 1. FILE FORMAT
-  Files are provided in "hashline" format. Each line starts with a case-sensitive content hash followed by `::`. 
+  Files are provided in "hashline" format. Each line starts with a case-sensitive content ID followed by `::`. 
   These hashes are used as identifiers for lines when editing.
   
   **Example File Format :**

{cecli_dev-0.100.5 → cecli_dev-0.100.6rc2}/cecli/tools/_yield.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 
+from cecli.helpers.threading import ThreadSafeEvent
 from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.helpers import ToolError
 from cecli.tools.utils.output import color_markers, tool_footer, tool_header
@@ -65,7 +66,7 @@ class Tool(BaseTool):
                     # the interrupt event, avoiding nested asyncio.wait() calls.
                     interrupt_event = coder.interrupt_event
                     if interrupt_event is None:
-                        interrupt_event = asyncio.Event()
+                        interrupt_event = ThreadSafeEvent()
 
                     interrupt_task = asyncio.create_task(interrupt_event.wait())
                     pending = set(active_tasks) | {interrupt_task}