cecli-dev 0.100.8rc2__tar.gz → 0.100.9__tar.gz

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

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

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

cecli_dev-0.100.9/cecli/coders/__init__.py

@@ -0,0 +1,57 @@
+"""Coder module with lazy imports to reduce startup memory."""
+
+__all__ = [
+    "HelpCoder",
+    "AskCoder",
+    "Coder",
+    "EditBlockCoder",
+    "EditBlockFencedCoder",
+    "WholeFileCoder",
+    "PatchCoder",
+    "UnifiedDiffCoder",
+    "UnifiedDiffSimpleCoder",
+    "ArchitectCoder",
+    "EditorEditBlockCoder",
+    "EditorWholeFileCoder",
+    "EditorDiffFencedCoder",
+    "ContextCoder",
+    "AgentCoder",
+    "CopyPasteCoder",
+    "HashLineCoder",
+    "SubAgentCoder",
+]
+
+# Module name mapping (snake_case to class name)
+_MODULE_MAP = {
+    "HelpCoder": ".help_coder",
+    "AskCoder": ".ask_coder",
+    "Coder": ".base_coder",
+    "EditBlockCoder": ".editblock_coder",
+    "EditBlockFencedCoder": ".editblock_fenced_coder",
+    "WholeFileCoder": ".wholefile_coder",
+    "PatchCoder": ".patch_coder",
+    "UnifiedDiffCoder": ".udiff_coder",
+    "UnifiedDiffSimpleCoder": ".udiff_simple",
+    "ArchitectCoder": ".architect_coder",
+    "EditorEditBlockCoder": ".editor_editblock_coder",
+    "EditorWholeFileCoder": ".editor_whole_coder",
+    "EditorDiffFencedCoder": ".editor_diff_fenced_coder",
+    "ContextCoder": ".context_coder",
+    "AgentCoder": ".agent_coder",
+    "CopyPasteCoder": ".copypaste_coder",
+    "HashLineCoder": ".hashline_coder",
+    "SubAgentCoder": ".sub_agent_coder",
+}
+
+
+def __getattr__(name):
+    if name in _MODULE_MAP:
+        import importlib
+
+        mod = importlib.import_module(_MODULE_MAP[name], __package__)
+        return getattr(mod, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return __all__

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

@@ -194,6 +194,7 @@ class AgentCoder(Coder):
                     "todo_list",
                     "sub_agents",
                     "skills",
+                    "servers",
                 },
             )
         )
@@ -357,6 +358,7 @@ class AgentCoder(Coder):
                 "git_status",
                 "symbol_outline",
                 "skills",
+                "servers",
                 "sub_agents",
                 "loaded_skills",
             ]
@@ -391,6 +393,8 @@ class AgentCoder(Coder):
             content = self.get_todo_list()
         elif block_name == "skills":
             content = self.get_skills_context()
+        elif block_name == "servers":
+            content = self.get_servers_context()
         elif block_name == "loaded_skills":
             content = self.get_skills_content()
         elif block_name == "sub_agents" and (
@@ -624,8 +628,8 @@ class AgentCoder(Coder):
                 result += f" ({percentage:.1f}% of limit)"
                 if percentage > 80:
                     result += "\n\n⚠ **Context is getting full!**\n"
-                    result += "- Remove non-essential files via the `ContextManager` tool.\n"
-                    result += "- Keep only essential files in context for best performance"
+                    result += "- Remove non-essential files, skills and tool servers via the `ResourceManager` tool.\n"
+                    result += "- Keep only essential files, skills, and MCP servers in context for best performance"
             result += "\n</context>"
             if not hasattr(self, "context_blocks_cache"):
                 self.context_blocks_cache = {}
@@ -659,7 +663,9 @@ class AgentCoder(Coder):
                     result += f"- Git repository: {rel_repo_dir} with {num_files:,} files\n"
                 except Exception:
                     result += "- Git repository: active but details unavailable\n"
-            else:
+                if self.mcp_manager and self.mcp_manager.connected_servers:
+                    num_mcp_servers = len(self.mcp_manager.connected_servers)
+                    result += f"- Connected MCP servers: {num_mcp_servers}\n"
                 result += "- Git repository: none\n"
             result += "</context>"
             return result
@@ -806,9 +812,7 @@ class AgentCoder(Coder):
         if self.auto_lint and used_write_tool:
             edited = list(self.files_edited_by_tools)
             lint_coro = self.lint_edited(edited, show_output=False)
-            lint_errors, interrupted = await self.coroutines.interruptible(
-                lint_coro, self.interrupt_event
-            )
+            lint_errors, interrupted = await interruptible(lint_coro, self.interrupt_event)
             if interrupted:
                 raise KeyboardInterrupt("Interrupted during linting")
 
@@ -928,9 +932,7 @@ class AgentCoder(Coder):
             )
             self.io.tool_output(waiting_msg)
             sleep_coro = asyncio.sleep(command_timeout / 2)
-            _res, interrupted = await self.coroutines.interruptible(
-                sleep_coro, self.interrupt_event
-            )
+            _res, interrupted = await interruptible(sleep_coro, self.interrupt_event)
             if interrupted:
                 raise KeyboardInterrupt("Interrupted while waiting for background commands")
             return True
@@ -1329,7 +1331,7 @@ class AgentCoder(Coder):
 
         Override parent's method to disable implicit file mention handling in agent mode.
         Files should only be added via explicit tool commands
-        (`ContextManager`).
+        (`ResourceManager`).
         """
         pass
 
@@ -1483,6 +1485,81 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
             self.io.tool_error(f"Error generating skills content context: {str(e)}")
             return None
 
+    def get_servers_context(self):
+        """
+        Generate a context block for available MCP servers.
+
+        Categorizes servers as:
+        - Active: Connected and passing includelist/excludelist filters
+        - Inactive: Connected but filtered out by includelist/excludelist
+        - Available (Disconnected): Managed but not currently connected
+
+        Returns:
+            Formatted context block string or None if no servers available
+        """
+        if not self.use_enhanced_context:
+            return None
+        try:
+            if not self.mcp_manager:
+                return None
+
+            all_servers = self.mcp_manager.servers
+            connected_servers = self.mcp_manager.connected_servers
+            connected_server_names = {s.name for s in connected_servers}
+
+            if not all_servers:
+                return None
+
+            # Apply registered_servers filtering to determine active vs inactive
+            incl = self.registered_servers.get("included", set())
+            excl = self.registered_servers.get("excluded", set())
+
+            active_servers = []
+            inactive_servers = []
+            for server in connected_servers:
+                name = server.name
+                if incl and name not in incl:
+                    inactive_servers.append(name)
+                elif name in excl:
+                    inactive_servers.append(name)
+                else:
+                    active_servers.append(name)
+
+            # Servers managed but not currently connected
+            disconnected_servers = [
+                server.name for server in all_servers if server.name not in connected_server_names
+            ]
+
+            result = '<context name="servers" from="agent">\n'
+            result += "## Connected MCP Servers\n\n"
+
+            if active_servers:
+                result += f"Active ({len(active_servers)}):\n"
+                for name in sorted(active_servers):
+                    result += f"- {name}\n"
+                result += "\n"
+
+            if inactive_servers:
+                result += f"Inactive (Filtered) ({len(inactive_servers)}):\n"
+                for name in sorted(inactive_servers):
+                    result += f"- {name}\n"
+                result += "\n"
+
+            if disconnected_servers:
+                result += f"Available (Disconnected) ({len(disconnected_servers)}):\n"
+                for name in sorted(disconnected_servers):
+                    result += f"- {name}\n"
+                result += "\n"
+
+            if not active_servers and not inactive_servers and not disconnected_servers:
+                result += "No MCP servers currently available.\n\n"
+
+            result += "</context>"
+            return result
+        except Exception as e:
+            self.io.tool_error(f"Error generating servers context: {str(e)}")
+            return None
+
     def get_sub_agents_context(self):
         """
         Generate a context block for registered sub-agents.

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/coders/architect_coder.py

@@ -45,7 +45,6 @@ class ArchitectCoder(AskCoder):
         kwargs["args"] = self.args
         kwargs["suggest_shell_commands"] = False
         kwargs["map_tokens"] = 0
-        kwargs["total_cost"] = self.total_cost
         kwargs["cache_prompts"] = False
         kwargs["num_cache_warming_pings"] = 0
         kwargs["summarize_from_coder"] = False

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

@@ -31,12 +31,6 @@ from typing import List
 from urllib.parse import urlparse
 from uuid import uuid4 as generate_unique_id
 
-import httpx
-from litellm import experimental_mcp_client
-from litellm.types.utils import ModelResponse
-from prompt_toolkit.patch_stdout import patch_stdout
-from rich.console import Console
-
 import cecli.prompts.utils.system as prompts
 from cecli import __version__, models, urls, utils
 from cecli.commands import Commands, SwitchCoderSignal
@@ -111,6 +105,28 @@ all_fences = [
     wrap_fence("sourcecode"),
 ]
 
+# Map of edit_format values to coder class names.
+# Used by Coder.create() to find the right coder class by edit_format
+# without importing all coder modules.
+EDIT_FORMAT_MAP = {
+    "help": "HelpCoder",
+    "ask": "AskCoder",
+    "diff": "EditBlockCoder",
+    "diff-fenced": "EditBlockFencedCoder",
+    "whole": "WholeFileCoder",
+    "patch": "PatchCoder",
+    "udiff": "UnifiedDiffCoder",
+    "udiff-simple": "UnifiedDiffSimpleCoder",
+    "architect": "ArchitectCoder",
+    "editor-diff": "EditorEditBlockCoder",
+    "editor-whole": "EditorWholeFileCoder",
+    "editor-diff-fenced": "EditorDiffFencedCoder",
+    "context": "ContextCoder",
+    "agent": "AgentCoder",
+    "hashline": "HashLineCoder",
+    "subagent": "SubAgentCoder",
+}
+
 
 class UsageMeta(type):
     """Metaclass that provides shared accumulator properties across all Coder subclasses.
@@ -335,9 +351,10 @@ class Coder(metaclass=UsageMeta):
             res = coders.CopyPasteCoder(main_model, io, args=args, **kwargs)
 
         if not res:
-            for coder in coders.__all__:
-                if hasattr(coder, "edit_format") and coder.edit_format == edit_format:
-                    res = coder(main_model, io, args=args, **kwargs)
+            coder_name = EDIT_FORMAT_MAP.get(edit_format)
+            if coder_name:
+                coder_cls = getattr(coders, coder_name)
+                res = coder_cls(main_model, io, args=args, **kwargs)
 
         if res is not None:
             if from_coder:
@@ -359,11 +376,7 @@ class Coder(metaclass=UsageMeta):
             res.original_kwargs = dict(kwargs)
             return res
 
-        valid_formats = [
-            str(c.edit_format)
-            for c in coders.__all__
-            if hasattr(c, "edit_format") and c.edit_format is not None
-        ]
+        valid_formats = list(EDIT_FORMAT_MAP.keys())
         raise UnknownEditFormat(edit_format, valid_formats)
 
     async def clone(self, **kwargs):
@@ -1470,6 +1483,8 @@ class Coder(metaclass=UsageMeta):
             return await self._run_linear(with_message, preproc)
 
         if self.io.prompt_session:
+            from prompt_toolkit.patch_stdout import patch_stdout
+
             with patch_stdout(raw=True):
                 return await self._run_parallel(with_message, preproc)
         else:
@@ -1954,7 +1969,10 @@ class Coder(metaclass=UsageMeta):
 
     def keyboard_interrupt(self):
         # Ensure cursor is visible on exit
-        Console().show_cursor(True)
+        if not self.tui:
+            from rich.console import Console
+
+            Console().show_cursor(True)
 
         self.io.tool_warning("^C KeyboardInterrupt")
         self.interrupt_event.set()
@@ -1973,13 +1991,25 @@ class Coder(metaclass=UsageMeta):
         done_messages = manager.get_messages_dict(MessageTag.DONE)
         cur_messages = manager.get_messages_dict(MessageTag.CUR)
         diff_messages = manager.get_messages_dict(MessageTag.DIFFS)
+        all_messages = manager.get_messages_dict()
 
         # Exclude first cur_message since that's the user's initial input
         done_tokens = self.summarizer.count_tokens(done_messages)
         cur_tokens = self.summarizer.count_tokens(cur_messages[1:] if len(cur_messages) > 1 else [])
         diff_tokens = self.summarizer.count_tokens(diff_messages)
+        all_tokens = self.summarizer.count_tokens(all_messages)
+
         combined_tokens = done_tokens + cur_tokens + diff_tokens
 
+        if force or (
+            all_tokens >= self.context_compaction_max_tokens * 0.9
+            and ConversationService.get_chunks(self).last_clear_count > 10
+        ):
+            manager.clear_tag(MessageTag.DIFFS)
+            manager.clear_tag(MessageTag.FILE_CONTEXTS)
+            ConversationService.get_files(self).clear_file_cache()
+            ConversationService.get_chunks(self).flush_removals()
+
         if not force and combined_tokens < self.context_compaction_max_tokens:
             return
 
@@ -2881,6 +2911,8 @@ class Coder(metaclass=UsageMeta):
 
     async def _execute_mcp_tools(self, server, tool_calls):
         """Execute MCP tools via LiteLLM."""
+        import httpx
+
         tool_responses = []
         try:
             # Connect to the server once
@@ -2928,6 +2960,8 @@ class Coder(metaclass=UsageMeta):
                             continue
 
                         async def do_tool_call():
+                            from litellm import experimental_mcp_client
+
                             return await experimental_mcp_client.call_openai_tool(
                                 session=session,
                                 openai_tool=new_tool_call,
@@ -3366,6 +3400,8 @@ class Coder(metaclass=UsageMeta):
             return prompts.added_files.format(fnames=", ".join(added_fnames))
 
     async def send(self, messages, model=None, functions=None, tools=None):
+        from litellm.types.utils import ModelResponse
+
         self.interrupt_event.clear()
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
@@ -3452,6 +3488,8 @@ class Coder(metaclass=UsageMeta):
                     self.io.ai_output(json.dumps(args, indent=4))
 
     async def show_send_output(self, completion):
+        from litellm.types.utils import ModelResponse
+
         if self.verbose:
             print(completion)
 

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/coders/copypaste_coder.py

@@ -78,14 +78,13 @@ class CopyPasteCoder(Coder):
             coders = None
 
         target_coder_class = None
-        if coders is not None:
-            for coder_cls in getattr(coders, "__all__", []):
-                if (
-                    hasattr(coder_cls, "edit_format")
-                    and coder_cls.edit_format == selected_edit_format
-                ):
-                    target_coder_class = coder_cls
-                    break
+        if coders is not None and selected_edit_format:
+            # Use EDIT_FORMAT_MAP from base_coder to find the right coder class by edit_format
+            from cecli.coders.base_coder import EDIT_FORMAT_MAP
+
+            coder_name = EDIT_FORMAT_MAP.get(selected_edit_format)
+            if coder_name:
+                target_coder_class = getattr(coders, coder_name, None)
 
         # Mirror prompt pack + edit_format where available.
         if target_coder_class is not None:

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

@@ -35,6 +35,7 @@ from .hooks import HooksCommand
 from .hot_reload import HotReloadCommand
 from .include_skill import IncludeSkillCommand
 from .lint import LintCommand
+from .list_mcp import ListMcpCommand
 from .list_sessions import ListSessionsCommand
 from .list_skills import ListSkillsCommand
 from .load import LoadCommand
@@ -123,6 +124,7 @@ CommandRegistry.register(SpawnAgentCommand)
 CommandRegistry.register(SwitchAgentCommand)
 CommandRegistry.register(IncludeSkillCommand)
 CommandRegistry.register(LintCommand)
+CommandRegistry.register(ListMcpCommand)
 CommandRegistry.register(ListSessionsCommand)
 CommandRegistry.register(ListSkillsCommand)
 CommandRegistry.register(LoadCommand)
@@ -210,6 +212,7 @@ __all__ = [
     "LoadCommand",
     "LoadHookCommand",
     "LoadMcpCommand",
+    "ListMcpCommand",
     "LoadSessionCommand",
     "LoadSkillCommand",
     "LsCommand",

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/commands/agent_model.py

@@ -47,7 +47,6 @@ class AgentModelCommand(BaseCommand):
             kwargs["main_model"] = model
             kwargs["edit_format"] = coder.edit_format  # Keep the same edit format
             kwargs["suggest_shell_commands"] = False
-            kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
             kwargs["done_messages"] = []

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/commands/editor_model.py

@@ -46,7 +46,6 @@ class EditorModelCommand(BaseCommand):
             kwargs["main_model"] = model
             kwargs["edit_format"] = coder.edit_format  # Keep the same edit format
             kwargs["suggest_shell_commands"] = False
-            kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
             kwargs["done_messages"] = []

cecli_dev-0.100.9/cecli/commands/list_mcp.py

@@ -0,0 +1,71 @@
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class ListMcpCommand(BaseCommand):
+    NORM_NAME = "list-mcp"
+    DESCRIPTION = "List all loaded and configured MCP servers."
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the list-mcp command."""
+        if not coder.mcp_manager:
+            return format_command_result(io, cls.NORM_NAME, "MCP manager is not configured.")
+
+        all_servers = coder.mcp_manager.servers
+        connected_servers = coder.mcp_manager.connected_servers
+
+        connected_server_names = {s.name for s in connected_servers}
+
+        # Apply per-coder registered_servers filtering to determine active status
+        incl = coder.registered_servers["included"]
+        excl = coder.registered_servers["excluded"]
+
+        active_servers = []
+        inactive_servers = []
+
+        for server in connected_servers:
+            name = server.name
+            # Same filtering logic used in base_coder.get_tool_list()
+            if incl and name not in incl:
+                inactive_servers.append(name)
+            elif name in excl:
+                inactive_servers.append(name)
+            else:
+                active_servers.append(name)
+
+        configured_servers = [
+            server for server in all_servers if server.name not in connected_server_names
+        ]
+
+        result = []
+        if active_servers:
+            result.append("Active MCP Servers:")
+            for name in sorted(active_servers):
+                result.append(f"- {name}")
+        else:
+            result.append("No MCP servers are active for this coder.")
+
+        if inactive_servers:
+            result.append("")
+            result.append("Inactive (Filtered) MCP Servers:")
+            for name in sorted(inactive_servers):
+                result.append(f"- {name}")
+
+        result.append("")
+        if configured_servers:
+            result.append("Configured MCP Servers:")
+            for server in sorted(configured_servers, key=lambda s: s.name):
+                result.append(f"- {server.name}")
+        else:
+            result.append("No other MCP servers are configured.")
+
+        return format_command_result(io, cls.NORM_NAME, "\n".join(result))
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the list-mcp command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /list-mcp  # Lists MCP servers with coder-sensitive active/inactive/configured status\n"
+        return help_text

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/commands/model.py

@@ -50,7 +50,6 @@ class ModelCommand(BaseCommand):
             kwargs["main_model"] = model
             kwargs["edit_format"] = new_edit_format
             kwargs["suggest_shell_commands"] = False
-            kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
             kwargs["done_messages"] = []

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

@@ -10,7 +10,7 @@ from cecli.commands.utils.helpers import (
 
 class RemoveMcpCommand(BaseCommand):
     NORM_NAME = "remove-mcp"
-    DESCRIPTION = "Remove a MCP server by name, or use '*' to remove all"
+    DESCRIPTION = "Remove (unload) a MCP server by name, or use '*' to remove all"
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/commands/weak_model.py

@@ -46,7 +46,6 @@ class WeakModelCommand(BaseCommand):
             kwargs["main_model"] = model
             kwargs["edit_format"] = coder.edit_format  # Keep the same edit format
             kwargs["suggest_shell_commands"] = False
-            kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
             kwargs["done_messages"] = []

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/helpers/conversation/integration.py

@@ -18,7 +18,7 @@ class ConversationChunks:
     def __init__(self, coder):
         self.coder = weakref.ref(coder)
         self.uuid = coder.uuid
-        self._last_clear_count = 0
+        self.last_clear_count = 0
         self._deferred_removals = set()
 
     @classmethod
@@ -282,14 +282,14 @@ class ConversationChunks:
         if diff_count > 0 and other_count > 0 and diff_count / other_count > 20:
             should_clear = True
 
-        self._last_clear_count += 1
+        self.last_clear_count += 1
 
         if (
             should_clear
-            and self._last_clear_count >= 20
+            and self.last_clear_count >= 20
             and diff_tokens + other_tokens > coder.context_compaction_max_tokens * 0.5
         ):
-            self._last_clear_count = 0
+            self.last_clear_count = 0
 
             # Clear all diff messages
             ConversationService.get_manager(coder).clear_tag(MessageTag.DIFFS)
@@ -890,7 +890,7 @@ class ConversationChunks:
         """
         Add static context blocks to conversation (priority 50).
 
-        Static blocks include: environment_info, directory_structure, skills
+        Static blocks include: environment_info, directory_structure, skills, servers, sub_agents
         """
         coder = self.get_coder()
         if not coder:
@@ -922,6 +922,10 @@ class ConversationChunks:
                 block = coder._generate_context_block("skills")
                 if block:
                     message_blocks["skills"] = block
+            if "servers" in coder.allowed_context_blocks:
+                block = coder._generate_context_block("servers")
+                if block:
+                    message_blocks["servers"] = block
 
         # Add static blocks to conversation manager with stable hash keys
         for block_type, block_content in message_blocks.items():

{cecli_dev-0.100.8rc2 → cecli_dev-0.100.9}/cecli/helpers/file_system/service.py

@@ -71,16 +71,19 @@ class FileSystemService:
         cls._instance = None
 
     @classmethod
-    def get_instance(cls, root: str = ".", repo=None) -> "FileSystemService":
+    def get_instance(cls, root: str | None = None, repo=None) -> "FileSystemService":
         """
         Return the global singleton.
 
         On first call, creates and builds the instance using root/repo.
-        Subsequent calls return the existing instance (root/repo
-        parameters are ignored). This ensures all agents share one
-        file index regardless of when they're spawned.
+        Subsequent calls return the existing instance. If a non-None root
+        is explicitly provided and differs from the current root, the
+        singleton is rebuilt (e.g. when a new coder is created in a
+        different working directory).
         """
         if cls._instance is None:
+            cls._instance = cls._create(root=root or ".", repo=repo)
+        elif root is not None and root != cls._instance.root:
             cls._instance = cls._create(root=root, repo=repo)
         return cls._instance