cecli-dev 0.100.7rc2__tar.gz → 0.100.8rc2__tar.gz

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.100.6.dev"
+__version__ = "0.100.8.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.7rc2'
-__version_tuple__ = version_tuple = (0, 100, 7, 'rc2')
+__version__ = version = '0.100.8rc2'
+__version_tuple__ = version_tuple = (0, 100, 8, 'rc2')
 
-__commit_id__ = commit_id = 'g845b666e7'
+__commit_id__ = commit_id = 'gac62b709a'

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/coders/agent_coder.py

@@ -51,6 +51,7 @@ class AgentCoder(Coder):
         if kwargs.get("uuid", None):
             self.uuid = kwargs.get("uuid")
 
+        self.start_up_errors = []
         self.recently_removed = {}
         self.tool_usage_history = []
         self.loaded_custom_tools = []
@@ -109,19 +110,26 @@ class AgentCoder(Coder):
 
     def post_init(self):
         super().post_init()
-        # Populate per-instance tool and server filters from config
-        self.registered_tools["included"] = set(
-            map(str.lower, self.agent_config.get("tools_includelist", []))
-        )
-        self.registered_tools["excluded"] = set(
-            map(str.lower, self.agent_config.get("tools_excludelist", []))
-        )
-        self.registered_servers["included"] = set(
-            map(str.lower, self.agent_config.get("servers_includelist", []))
-        )
-        self.registered_servers["excluded"] = set(
-            map(str.lower, self.agent_config.get("servers_excludelist", []))
-        )
+
+        if not self._inherited_tools:
+            # Populate per-instance tool and server filters from config
+            self.registered_tools["included"] = set(
+                map(str.lower, self.agent_config.get("tools_includelist", []))
+            )
+            self.registered_tools["excluded"] = set(
+                map(str.lower, self.agent_config.get("tools_excludelist", []))
+            )
+            self.registered_servers["included"] = set(
+                map(str.lower, self.agent_config.get("servers_includelist", []))
+            )
+            self.registered_servers["excluded"] = set(
+                map(str.lower, self.agent_config.get("servers_excludelist", []))
+            )
+
+        for err in self.start_up_errors:
+            self.io.tool_warning(err)
+
+        self.start_up_errors = []
 
     def _setup_agent(self):
         os.makedirs(".cecli/temp", exist_ok=True)
@@ -143,7 +151,7 @@ class AgentCoder(Coder):
             try:
                 config = json.loads(self.args.agent_config)
             except (json.JSONDecodeError, TypeError) as e:
-                self.io.tool_warning(f"Failed to parse agent-config JSON: {e}")
+                self.start_up_errors.append(f"Failed to parse agent-config JSON: {e}")
                 return {}
 
         config["large_file_token_threshold"] = nested.getter(
@@ -1531,15 +1539,20 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
         try:
             service = AgentService.get_instance(self)
             children = service.get_children(self)
-
             if not children:
                 return None
 
+            # Filter to non-independent children only
+            dependent_children = [info for info in children if not info.independent]
+
+            if not dependent_children:
+                return None
+
             result = '<context name="sub_agent_states" from="agent">\n'
             result += "## Active Sub-Agent States\n\n"
-            result += f"Found {len(children)} active child sub-agent(s):\n\n"
+            result += f"Found {len(dependent_children)} active child sub-agent(s):\n\n"
 
-            for info in children:
+            for info in dependent_children:
                 result += f"**{info.name}**:\n"
                 result += f"  - UUID: `{info.coder.uuid}`\n"
                 result += f"  - Status: {info.status.value}\n"

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/coders/base_coder.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import base64
+import copy
 import hashlib
 import json
 import locale
@@ -314,6 +315,8 @@ class Coder(metaclass=UsageMeta):
                 ignore_mentions=from_coder.ignore_mentions,
                 file_watcher=from_coder.file_watcher,
                 mcp_manager=from_coder.mcp_manager,
+                registered_tools=copy.deepcopy(from_coder.registered_tools),
+                registered_servers=copy.deepcopy(from_coder.registered_servers),
                 uuid=from_coder.uuid,
                 parent_uuid=from_coder.parent_uuid,
                 repo=from_coder.repo,
@@ -416,15 +419,26 @@ class Coder(metaclass=UsageMeta):
         repomap_in_memory=False,
         linear_output=False,
         security_config=None,
+        registered_tools=None,
+        registered_servers=None,
         uuid: str = "",
         parent_uuid: str = "",
     ):
+        from cecli.helpers.agents.service import AgentService
+
         # initialize from args.map_cache_dir
         self.coroutines = coroutines
         # Per-instance tool and server filtering dictionaries
         # 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._inherited_tools = False
+
+        if registered_tools is not None or registered_servers is not None:
+            self.registered_tools = registered_tools
+            self.registered_servers = registered_servers
+            self._inherited_tools = True
+
         self.interrupt_event = ThreadSafeEvent()
         self.uuid = str(generate_unique_id())
         self.reflected_message = None
@@ -544,8 +558,10 @@ class Coder(metaclass=UsageMeta):
 
         self.show_diffs = show_diffs
 
-        # Initialize conversation system if enabled
+        # Initialize all registry sub systems
+        AgentService.get_instance(self)
         ConversationService.get_chunks(self).initialize_conversation_system()
+        ObservationService.get_instance(self)
 
         self.commands = commands or Commands(self.io, self, args=args)
         self.commands.coder = self
@@ -3675,10 +3691,11 @@ class Coder(metaclass=UsageMeta):
         func_err = None
         content_err = None
 
-        last_chunk = self.partial_response_chunks[len(self.partial_response_chunks) - 1]
-        if last_chunk:
-            if getattr(last_chunk, "usage", None):
-                response.usage = last_chunk.usage
+        if len(self.partial_response_chunks):
+            last_chunk = self.partial_response_chunks[len(self.partial_response_chunks) - 1]
+            if last_chunk:
+                if getattr(last_chunk, "usage", None):
+                    response.usage = last_chunk.usage
 
         # Collect provider-specific fields from chunks to preserve them
         # We need to track both by ID (primary) and index (fallback) since
@@ -4487,7 +4504,7 @@ class Coder(metaclass=UsageMeta):
             if output:
                 accumulated_output += f"Output from {command}\n{output}\n"
 
-        print(accumulated_output)
+        self.io.tool_output(accumulated_output)
 
         if accumulated_output.strip() and await self.io.confirm_ask(
             "Add command output to the chat?", allow_never=True

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/__init__.py

@@ -20,7 +20,7 @@ from .context_blocks import ContextBlocksCommand
 from .context_management import ContextManagementCommand
 from .copy import CopyCommand
 from .copy_context import CopyContextCommand
-from .core import Commands, SwitchCoderSignal
+from .core import Commands, ReloadProgramSignal, SwitchCoderSignal
 from .diff import DiffCommand
 from .drop import DropCommand
 from .editor import EditCommand, EditorCommand
@@ -32,6 +32,7 @@ from .hashline import HashlineCommand
 from .help import HelpCommand
 from .history_search import HistorySearchCommand
 from .hooks import HooksCommand
+from .hot_reload import HotReloadCommand
 from .include_skill import IncludeSkillCommand
 from .lint import LintCommand
 from .list_sessions import ListSessionsCommand
@@ -116,6 +117,7 @@ CommandRegistry.register(HashlineCommand)
 CommandRegistry.register(HelpCommand)
 CommandRegistry.register(HistorySearchCommand)
 CommandRegistry.register(HooksCommand)
+CommandRegistry.register(HotReloadCommand)
 CommandRegistry.register(ReapAgentCommand)
 CommandRegistry.register(SpawnAgentCommand)
 CommandRegistry.register(SwitchAgentCommand)
@@ -197,6 +199,7 @@ __all__ = [
     "HelpCommand",
     "HistorySearchCommand",
     "HooksCommand",
+    "HotReloadCommand",
     "IncludeSkillCommand",
     "ReapAgentCommand",
     "SpawnAgentCommand",
@@ -223,6 +226,7 @@ __all__ = [
     "ReadOnlyCommand",
     "ReadOnlyStubCommand",
     "ReasoningEffortCommand",
+    "ReloadProgramSignal",
     "RemoveHookCommand",
     "RemoveMcpCommand",
     "RemoveSkillCommand",

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/core.py

@@ -33,6 +33,25 @@ class SwitchCoderSignal(BaseException):
         super().__init__()
 
 
+class ReloadProgramSignal(BaseException):
+    """
+    Signal to reload the entire program configuration.
+
+    This is NOT an error - it's a control flow signal used to trigger
+    a full program reload, re-parsing config files and re-initializing
+    all components. Useful for hot-reloading when configuration files
+    change.
+
+    Note: Inherits from BaseException (like KeyboardInterrupt and SystemExit)
+    to avoid being caught by generic `except Exception` handlers.
+    """
+
+    def __init__(self, message="Reloading program configuration...", **kwargs):
+        self.kwargs = kwargs
+        self.message = message
+        super().__init__(self.message)
+
+
 class Commands:
     scraper = None
 

cecli_dev-0.100.8rc2/cecli/commands/hot_reload.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from cecli.commands.core import ReloadProgramSignal
+from cecli.commands.utils.base_command import BaseCommand
+
+
+class HotReloadCommand(BaseCommand):
+    NORM_NAME = "hot-reload"
+    DESCRIPTION = "Hot-reload all configuration and restart the program"
+    show_completion_notification = False
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Raise ReloadProgramSignal to trigger a full program hot-reload.
+
+        Passes the current coder as from_coder so the new coder
+        preserves its UUID, edit_format, and other state across
+        the reload cycle.
+        """
+        io.tool_output("Hot-reloading program configuration...")
+        raise ReloadProgramSignal(
+            "User requested configuration reload",
+            from_coder=coder,
+        )
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for hot-reload command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the hot-reload command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /hot-reload  # Hot-reload all configuration files and restart\n"
+        help_text += "\nThis will re-read config files, reinitialize the connection,"
+        help_text += " and restart the chat session with the updated configuration."
+        return help_text

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/load_mcp.py

@@ -1,7 +1,11 @@
 from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
-from cecli.commands.utils.helpers import format_command_result
+from cecli.commands.utils.helpers import (
+    format_command_result,
+    iter_all_coders,
+    update_server_registration,
+)
 
 
 class LoadMcpCommand(BaseCommand):
@@ -51,6 +55,20 @@ class LoadMcpCommand(BaseCommand):
         if not servers_to_load and results:
             return format_command_result(io, cls.NORM_NAME, "", "\n".join(results))
 
+        # Before connecting any new server, convert coders with empty included sets
+        # to explicit include lists of all currently connected MCP servers.
+        # This moves them from "implicitly include all" to explicit state-machine
+        # management, preventing the new server from being implicitly available
+        # to all coders.
+        connected_names = {s.name for s in coder.mcp_manager.connected_servers}
+        if connected_names:
+            for c in iter_all_coders(coder):
+                if not c.registered_servers["included"]:
+                    included = set(connected_names) - c.registered_servers["excluded"]
+                    if c.edit_format in ("agent", "subagent"):
+                        included.add("Local")  # "local" is always available
+                    c.registered_servers["included"] = included
+
         # Process connections with interrupt support
         for server in servers_to_load:
             server_name = server.name
@@ -67,6 +85,14 @@ class LoadMcpCommand(BaseCommand):
                 continue
 
             if did_connect:
+                # Force-include on the primary (active) coder
+                update_server_registration(coder, server_name, "include", force=True)
+
+                # Safe-exclude on all other coders (respects existing inclusions)
+                for other_coder in iter_all_coders(coder):
+                    if other_coder is coder:
+                        continue
+                    update_server_registration(other_coder, server_name, "exclude", force=False)
                 results.append(f"Loaded server: {server_name}")
             else:
                 results.append(f"Unable to load server: {server_name}")

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/remove_mcp.py

@@ -1,7 +1,11 @@
 from typing import List
 
 from cecli.commands.utils.base_command import BaseCommand
-from cecli.commands.utils.helpers import format_command_result
+from cecli.commands.utils.helpers import (
+    format_command_result,
+    is_server_globally_excluded,
+    update_server_registration,
+)
 
 
 class RemoveMcpCommand(BaseCommand):
@@ -44,22 +48,37 @@ class RemoveMcpCommand(BaseCommand):
         for item in servers_to_disconnect:
             server_name = item.name if hasattr(item, "name") else item
 
-            coder.interrupt_event.clear()
-
-            was_disconnected, interrupted = await coder.coroutines.interruptible(
-                coder.mcp_manager.disconnect_server(server_name),
-                coder.interrupt_event,
-            )
-
-            if interrupted:
-                io.tool_warning(f"MCP disconnection interrupted: {server_name}")
-                results.append(f"Interrupted: {server_name}")
+            # Never remove the "local" server
+            if server_name == "Local":
+                results.append("Cannot remove 'Local' server")
                 continue
 
-            if was_disconnected:
-                results.append(f"Removed server: {server_name}")
+            # Force-exclude on the primary (active) coder
+            update_server_registration(coder, server_name, "exclude", force=True)
+            # Check if all coders in the hierarchy have this server excluded
+            all_excluded = is_server_globally_excluded(coder, server_name)
+
+            if all_excluded:
+                was_disconnected, interrupted = await coder.coroutines.interruptible(
+                    coder.mcp_manager.disconnect_server(server_name),
+                    coder.interrupt_event,
+                )
+
+                if interrupted:
+                    io.tool_warning(f"MCP disconnection interrupted: {server_name}")
+                    results.append(f"Interrupted: {server_name}")
+                    continue
+
+                if was_disconnected:
+                    results.append(f"Removed server: {server_name}")
+                else:
+                    results.append(f"Unable to remove server: {server_name}")
             else:
-                results.append(f"Unable to remove server: {server_name}")
+                io.tool_output(
+                    f"Server '{server_name}' still in use by other coders, "
+                    f"keeping connection active."
+                )
+                results.append(f"Removed from active coder, still active for others: {server_name}")
 
         io.tool_output("\n".join(results))
 

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/run.py

@@ -37,7 +37,7 @@ class RunCommand(BaseCommand):
         )
 
         if coder.args.tui:
-            print(combined_output)
+            coder.io.tool_warning(combined_output)
         else:
             # This print statement, for whatever reason,
             # allows the thread to properly yield control of the terminal

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/spawn_agent.py

@@ -27,7 +27,9 @@ class SpawnAgentCommand(BaseCommand):
 
         try:
             agent_service = AgentService.get_instance(coder)
-            new_coder, info = await agent_service.spawn(name, prompt, parent=coder, auto_reap=False)
+            new_coder, info = await agent_service.spawn(
+                name, prompt, parent=coder, auto_reap=False, independent=True
+            )
 
             # Set the newly spawned agent as the foreground agent
             agent_service.foreground_uuid = info.coder.uuid

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/commands/utils/helpers.py

@@ -304,6 +304,92 @@ def expand_subdir(file_path: Path) -> List[Path]:
         for file in file_path.rglob("*"):
             if file.is_file():
                 files.append(file)
-        return files
 
     return []
+
+
+def iter_all_coders(root_coder):
+    """
+    Recursively iterate over all coders in the agent/sub-agent hierarchy.
+
+    Yields the root coder first, then all sub-agents (and their sub-agents)
+    at every nesting level.
+
+    Args:
+        root_coder: The top-level coder instance to start from.
+
+    Yields:
+        Coder instances from the entire hierarchy.
+    """
+
+    try:
+        from cecli.helpers.agents.service import AgentService
+
+        for coder in AgentService.get_all_agents():
+            yield coder
+    except Exception:
+        pass
+
+
+def update_server_registration(coder, server_name, operation, force=False):
+    """
+    Unify include/exclude server registration with optional force.
+
+    When *force* is True, the operation always succeeds and the
+    opposing set is cleaned up to be non-conflicting.  When *force*
+    is False (safe mode), the operation is a no-op if the server
+    is already present in the opposing set.
+
+    Args:
+        coder: A coder instance with ``registered_servers`` attribute.
+        server_name: Name of the server to register.
+        operation: ``"include"`` or ``"exclude"``.
+        force: When True, always perform the operation.
+               When False, respect the opposing set (excluded wins
+               for include, included wins for exclude).
+    """
+    name = server_name
+    included = coder.registered_servers["included"]
+    excluded = coder.registered_servers["excluded"]
+
+    if operation == "include":
+        if force or name not in excluded:
+            included.add(name)
+            excluded.discard(name)
+    elif operation == "exclude":
+        if force or name not in included:
+            excluded.add(name)
+            included.discard(name)
+
+
+def is_server_globally_excluded(coder, server_name):
+    """
+    Check whether *server_name* is excluded from *all* coders in the hierarchy.
+
+    A server is considered "globally excluded" when every coder in the tree
+    either:
+      - has it in ``registered_servers["excluded"]``, or
+      - does **not** have it in ``registered_servers["included"]``
+        (empty included means "include all", so the server would be available).
+
+    Args:
+        coder: Any coder in the hierarchy (used to discover the full tree).
+        server_name: Name of the MCP server to check.
+
+    Returns:
+        True if the server is excluded from every coder.
+    """
+    name = server_name
+    for other in iter_all_coders(coder):
+        incl = other.registered_servers["included"]
+        excl = other.registered_servers["excluded"]
+
+        # Empty included => implicitly includes all servers
+        if not incl:
+            if name not in excl:
+                return False
+        else:
+            if name in incl:
+                return False
+            # Non-empty included means it's an allowlist: not in included => excluded
+    return True

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/helpers/agents/service.py

@@ -48,6 +48,7 @@ class SubAgentInfo:
         None  # Track the generate() task for cancellation/monitoring
     )
     auto_reap: bool = True  # If True, agent may be automatically reaped when FINISHED
+    independent: bool = False
 
 
 class AgentService:
@@ -126,6 +127,19 @@ class AgentService:
         """Return the global sub-agent registry (name -> config)."""
         return cls._global_registry
 
+    @classmethod
+    def get_all_agents(cls) -> List[Any]:
+        """Return all live coder instances tracked in the global uuid map.
+
+        Dereferences weakrefs, skipping any that have been garbage-collected.
+        """
+        agents = []
+        for ref in cls._uuid_coder_map.values():
+            coder = ref()
+            if coder is not None:
+                agents.append(coder)
+        return agents
+
     @classmethod
     def register_subagent(cls, name: str, config: Any) -> None:
         """Register a sub-agent config by name."""
@@ -405,7 +419,11 @@ class AgentService:
             )
 
     async def _create_sub_agent_coder(
-        self, name: str, parent: Any = None, auto_reap: Optional[bool] = None
+        self,
+        name: str,
+        parent: Any = None,
+        auto_reap: Optional[bool] = None,
+        independent: bool = False,
     ) -> Tuple[Any, SubAgentInfo]:
         """Create a sub-agent coder, register it, and set up its container and prompt.
 
@@ -489,6 +507,7 @@ class AgentService:
                 parent_uuid=parent_coder.uuid,
                 status=SubAgentStatus.CREATED,
                 auto_reap=auto_reap,
+                independent=independent,
             )
             self.sub_agents[new_coder.uuid] = info
             self._sub_agent_order.append(new_coder.uuid)
@@ -571,22 +590,24 @@ class AgentService:
         Returns:
             The ``asyncio.Task`` wrapping ``generate()``.
         """
+        from cecli.commands import SwitchCoderSignal
 
         async def _run_generate():
             info.status = SubAgentStatus.RUNNING
             try:
                 await info.coder.generate(user_message=user_message, preproc=True)
+                await self._inject_sub_agent_result(info)
                 if info.status == SubAgentStatus.RUNNING:
                     info.status = SubAgentStatus.FINISHED
                     info.summary = info.summary or DEFAULT_SUMMARY_COMPLETED
-                await self._inject_sub_agent_result(info)
             except asyncio.CancelledError:
+                await self._inject_sub_agent_result(info)
                 info.status = SubAgentStatus.FINISHED
                 info.summary = info.summary or DEFAULT_SUMMARY_INTERRUPTED
                 logger.debug("Sub-agent %s generate cancelled (interrupted)", info.name)
-                await self._inject_sub_agent_result(info)
                 raise
             except Exception as exc:
+                await self._inject_sub_agent_result(info)
                 info.status = SubAgentStatus.ERROR
                 info.error = str(exc)
                 logger.error(
@@ -595,7 +616,8 @@ class AgentService:
                     exc,
                     exc_info=True,
                 )
-                await self._inject_sub_agent_result(info)
+                raise
+            except SwitchCoderSignal:
                 raise
 
         # Cancel any previous generate task to prevent duplicate concurrent generates
@@ -604,8 +626,15 @@ class AgentService:
 
         task = asyncio.create_task(_run_generate())
         info.generate_task = task
+
+        def _raise_if_signal(exc):
+            if isinstance(exc, SwitchCoderSignal):
+                raise exc
+
         # Suppress "Task exception was never retrieved" for fire-and-forget tasks
-        task.add_done_callback(lambda t: t.exception() if not t.cancelled() else None)
+        task.add_done_callback(
+            lambda t: _raise_if_signal(t.exception()) if not t.cancelled() else None
+        )
         return task
 
     async def _inject_sub_agent_result(self, info: SubAgentInfo) -> None:
@@ -712,6 +741,7 @@ class AgentService:
         prompt: Optional[str] = None,
         parent: Any = None,
         auto_reap: Optional[bool] = None,
+        independent: bool = False,
     ) -> Tuple[Any, SubAgentInfo]:
         """Spawn a sub-agent (non-blocking) that waits for user input.
 
@@ -727,7 +757,7 @@ class AgentService:
             with the sub-agent (e.g. call ``start_generate_task`` later).
         """
         new_coder, info = await self._create_sub_agent_coder(
-            name, auto_reap=auto_reap, parent=parent
+            name, auto_reap=auto_reap, parent=parent, independent=independent
         )
         if prompt:
             self.start_generate_task(info, prompt)

{cecli_dev-0.100.7rc2 → cecli_dev-0.100.8rc2}/cecli/helpers/conversation/files.py

@@ -107,7 +107,7 @@ class ConversationFiles:
                 # Use coder.io.read_text() - coder should always be available
                 coder = self.get_coder()
                 try:
-                    content = coder.io.read_text(abs_fname)
+                    content = coder.io.read_text(abs_fname, silent=True)
                     if coder.hashlines:
                         content = hashline(content)
                 except Exception:
@@ -224,7 +224,7 @@ class ConversationFiles:
         coder = self.get_coder()
         rel_fname = coder.get_rel_fname(fname)
         try:
-            current_content = coder.io.read_text(abs_fname)
+            current_content = coder.io.read_text(abs_fname, silent=True)
             if coder.hashlines:
                 current_content = hashline(current_content)
         except Exception:
@@ -525,7 +525,7 @@ class ConversationFiles:
 
         # Read file content
         try:
-            content = coder.io.read_text(abs_fname)
+            content = coder.io.read_text(abs_fname, silent=True)
             if not content:
                 return ""
         except Exception: