V1.0.0

cecli/coders/agent_coder.py

@@ -62,7 +62,6 @@ def __init__(self, *args, **kwargs):
         self.max_tool_vector_history = 20
         self.read_tools = {
             "command",
-            "commandinteractive",
             "explorecode",
             "ls",
             "readfile",
@@ -72,7 +71,6 @@ def __init__(self, *args, **kwargs):
         }
         self.write_tools = {
             "command",
-            "commandinteractive",
             "editfile",
             "undochange",
         }
@@ -83,6 +81,7 @@ def __init__(self, *args, **kwargs):
         self.change_tracker = ChangeTracker()
         self.args = kwargs.get("args")
         self.files_added_in_exploration = set()
+        self.file_read_cache = set()
         self.tool_call_count = 0
         self.turn_count = 0
         self.max_reflections = 15
@@ -98,7 +97,7 @@ def __init__(self, *args, **kwargs):
         self.skip_cli_confirmations = False
         self.agent_finished = False
         self.agent_config = self._get_agent_config()
-        self.max_sub_agents = self.agent_config.get("max_sub_agents", 3)
+        self.max_sub_agents = self.agent_config.get("max_sub_agents", 30)
         self.sub_agent_paths = self.agent_config.get("subagent_paths", [])
         self._setup_agent()
 
@@ -167,6 +166,11 @@ def _get_agent_config(self):
         config["hot_reload"] = nested.getter(config, "hot_reload", False)
         config["diff_colors"] = nested.getter(config, "diff_colors", True)
         config["allow_nested_delegation"] = nested.getter(config, "allow_nested_delegation", False)
+        config["allow_orchestration"] = nested.getter(config, "allow_orchestration", True)
+        config["max_sub_agents"] = nested.getter(config, "max_sub_agents", 30)
+
+        if config["max_sub_agents"] == -1:
+            config["max_sub_agents"] = 2 ^ 31 - 1
 
         config["tools_paths"] = nested.getter(config, ["tools_paths", "tool_paths"], [])
         config["tools_includelist"] = nested.getter(
@@ -184,6 +188,7 @@ def _get_agent_config(self):
         config["servers_excludelist"] = nested.getter(
             config, ["servers_excludelist", "servers_blacklist"], []
         )
+
         config["include_context_blocks"] = set(
             nested.getter(
                 config,
@@ -203,6 +208,10 @@ def _get_agent_config(self):
         )
         config["exclude_context_blocks"] = set(nested.getter(config, "exclude_context_blocks", []))
 
+        if config["allow_orchestration"]:
+            config["include_context_blocks"].add("orchestration")
+            config["exclude_context_blocks"].discard("orchestration")
+
         self.large_file_token_threshold = config["large_file_token_threshold"]
         self.skip_cli_confirmations = config["skip_cli_confirmations"]
         self.hot_reload_enabled = config["hot_reload"]
@@ -292,6 +301,7 @@ async def initialize_mcp_tools(self):
 
     async def _execute_mcp_tool(self, server, tool_name, params):
         """Helper to execute a single MCP tool call, created from legacy format."""
+        from cecli.tools.utils.responses import ToolResponse
 
         async def _exec_async():
             function_dict = {"name": tool_name, "arguments": json.dumps(params)}
@@ -350,9 +360,14 @@ async def _exec_async():
 
         result, interrupted = await interruptible(_exec_async(), self.interrupt_event)
 
+        response = ToolResponse(tool_name)
         if interrupted:
-            return "Tool execution interrupted by user."
-        return result
+            response.append_error("Tool execution interrupted by user.")
+        elif isinstance(result, str) and result.startswith("Error executing tool call"):
+            response.append_error(result)
+        else:
+            response.append_result(result)
+        return response
 
     def _calculate_context_block_tokens(self, force=False):
         """
@@ -383,6 +398,7 @@ def _calculate_context_block_tokens(self, force=False):
                 "servers",
                 "sub_agents",
                 "loaded_skills",
+                "orchestration",
             ]
             for block_type in block_types:
                 if block_type in self.allowed_context_blocks:
@@ -419,6 +435,8 @@ def _generate_context_block(self, block_name):
             content = self.get_servers_context()
         elif block_name == "loaded_skills":
             content = self.get_skills_content()
+        elif block_name == "orchestration":
+            content = self.get_orchestration_context()
         elif block_name == "sub_agents" and (
             not self.parent_uuid or self.agent_config.get("allow_nested_delegation", False)
         ):
@@ -897,7 +915,7 @@ async def _execute_mcp_tools(self, server, tool_calls):
                 {
                     "role": "tool",
                     "tool_call_id": tool_call.id,
-                    "content": result,
+                    "content": str(result),
                 }
             )
         return tool_responses
@@ -1601,6 +1619,23 @@ def get_servers_context(self):
             self.io.tool_error(f"Error generating servers context: {str(e)}")
             return None
 
+    def get_orchestration_context(self):
+        """
+        Generate a context block for the Orchestrate tool if allowed.
+
+        Only returns content if ``allow_orchestration`` is enabled in the agent config.
+        """
+        if not self.use_enhanced_context:
+            return None
+
+        try:
+            from cecli.helpers.orchestration import build_orchestration_context_block
+
+            return build_orchestration_context_block(self.agent_config)
+        except Exception as e:
+            self.io.tool_error(f"Error generating orchestration context: {str(e)}")
+            return None
+
     def get_sub_agents_context(self):
         """
         Generate a context block for registered sub-agents.

cecli/coders/base_coder.py

@@ -55,7 +55,7 @@
     remove_reasoning_content,
     replace_reasoning_tags,
 )
-from cecli.repo import ANY_GIT_ERROR, GitRepo
+from cecli.repo import ANY_GIT_ERROR, GitRepo, GitRepoProxy
 from cecli.repomap import RepoMap
 from cecli.report import update_error_prefix
 from cecli.run_cmd import run_cmd_async
@@ -571,11 +571,13 @@ def __init__(
         self.repo = repo
         if use_git and self.repo is None:
             try:
-                self.repo = GitRepo(
-                    self.io,
-                    fnames,
-                    None,
-                    models=main_model.commit_message_models(),
+                self.repo = GitRepoProxy(
+                    GitRepo(
+                        self.io,
+                        fnames,
+                        None,
+                        models=main_model.commit_message_models(),
+                    )
                 )
             except FileNotFoundError:
                 pass
@@ -4266,9 +4268,12 @@ def check_added_files(self):
         if tokens < warn_number_of_tokens:
             return
 
-        self.io.tool_warning("Warning: it's best to only add files that need changes to the chat.")
-        self.io.tool_warning(urls.edit_errors)
-        self.warning_given = True
+        if self.context_compaction_current_ratio > 0.5:
+            self.io.tool_warning(
+                "Warning: it's best to only add files that need changes to the chat."
+            )
+            self.io.tool_warning(urls.edit_errors)
+            self.warning_given = True
 
     async def prepare_to_edit(self, edits):
         res = []

cecli/commands/__init__.py

@@ -5,6 +5,8 @@
 BaseCommand pattern for modular, testable command execution.
 """
 
+from cecli.signals import ReloadProgramSignal, SwitchCoderSignal
+
 from .add import AddCommand
 from .agent import AgentCommand
 from .agent_model import AgentModelCommand
@@ -21,7 +23,7 @@
 from .context_management import ContextManagementCommand
 from .copy import CopyCommand
 from .copy_context import CopyContextCommand
-from .core import Commands, ReloadProgramSignal, SwitchCoderSignal
+from .core import Commands
 from .diff import DiffCommand
 from .drop import DropCommand
 from .editor import EditCommand, EditorCommand

cecli/commands/core.py

@@ -8,49 +8,7 @@
 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
-
-
-class SwitchCoderSignal(BaseException):
-    """
-     Signal to switch the current Coder instance to a new configuration.
-
-     This is NOT an error - it's a control flow signal used to propagate
-     coder switching requests up through the async call stack. It carries
-     the kwargs needed to create a new Coder instance.
-
-     Note: Inherits from BaseException (like KeyboardInterrupt and SystemExit)
-    to avoid being caught by generic `except Exception` handlers, making the
-     non-error nature of this signal explicit.
-
-     Attributes:
-         kwargs: Configuration dict passed to Coder.create() for the new instance
-         placeholder: Optional placeholder text for the input prompt
-    """
-
-    def __init__(self, placeholder=None, **kwargs):
-        self.kwargs = kwargs
-        self.placeholder = placeholder
-        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)
+from cecli.signals import SwitchCoderSignal
 
 
 class Commands:
@@ -215,6 +173,8 @@ def get_commands(self):
         return sorted(commands)
 
     async def execute(self, cmd_name, args, coder=None, **kwargs):
+        from cecli.repo import ANY_GIT_ERROR
+
         active_coder = coder or self.coder
         command_class = CommandRegistry.get_command(cmd_name)
 

cecli/commands/hot_reload.py

@@ -1,7 +1,7 @@
 from typing import List
 
-from cecli.commands.core import ReloadProgramSignal
 from cecli.commands.utils.base_command import BaseCommand
+from cecli.signals import ReloadProgramSignal
 
 
 class HotReloadCommand(BaseCommand):

cecli/commands/undo.py

@@ -53,8 +53,12 @@ async def _raw_cmd_undo(cls, io, coder, args):
             )
             return format_command_result(io, "undo", "Commit has multiple parents")
 
-        prev_commit = last_commit.parents[0]
-        changed_files_last_commit = [item.a_path for item in last_commit.diff(prev_commit)]
+        prev_sha = last_commit.parents[0]
+        # Get list of files changed between parent and current commit
+        diff_output = coder.repo.repo.git.diff("--name-only", prev_sha, last_commit.hexsha)
+        changed_files_last_commit = (
+            [f for f in diff_output.splitlines() if f] if diff_output else []
+        )
 
         for fname in changed_files_last_commit:
             if coder.repo.repo.is_dirty(path=fname):
@@ -64,9 +68,12 @@ async def _raw_cmd_undo(cls, io, coder, args):
                 return format_command_result(io, "undo", f"File {fname} has uncommitted changes")
 
             # Check if the file was in the repo in the previous commit
+            # git ls-tree returns empty string if the file does not exist in that commit
             try:
-                prev_commit.tree[fname]
-            except KeyError:
+                tree_output = coder.repo.repo.git.ls_tree(prev_sha, "--", fname)
+                if not tree_output:
+                    raise KeyError
+            except (KeyError, ANY_GIT_ERROR):
                 io.tool_error(
                     f"The file {fname} was not in the repository in the previous commit. Cannot"
                     " undo safely."

cecli/helpers/agents/service.py

@@ -228,7 +228,7 @@ def __init__(self, coder) -> None:
     @property
     def max_sub_agents(self) -> int:
         """Return the max number of sub-agents allowed for this coder."""
-        return getattr(self.coder, "max_sub_agents", 3)
+        return getattr(self.coder, "max_sub_agents", 30)
 
     # ------------------------------------------------------------------ #
     # Internal helpers
@@ -495,7 +495,7 @@ async def _create_sub_agent_coder(
             )
 
         new_coder = await Coder.create(**kwargs)
-        new_coder.max_sub_agents = getattr(self.coder, "max_sub_agents", 3)
+        new_coder.max_sub_agents = getattr(self.coder, "max_sub_agents", 30)
         # IOProxy wrapping is handled by base_coder.py's Coder.__init__
 
         # Re-acquire the lock to register — we must re-check max agents since
@@ -575,7 +575,7 @@ def start_generate_task(self, info: SubAgentInfo, user_message: str) -> asyncio.
 
         Args:
 
-        .. note::
+        .. note:
 
             **Ordering dependency with mark_sub_agent_finished()**
 

cecli/helpers/background_commands.py

@@ -767,14 +767,16 @@ def save_paginated_output(
         Returns:
             Tuple of (folder path, rel file paths list, alias paths list), or None if output fits in one page.
         """
+        import math
+
         if not output or len(output) <= page_size:
             return None
 
         folder_path = local_agent_folder_func(command_key)
         abs_folder = abs_root_path_func(folder_path)
         os.makedirs(abs_folder, exist_ok=True)
 
-        num_pages = (len(output) + page_size - 1) // page_size
+        num_pages = math.ceil((len(output) + page_size - 1) // page_size)
 
         for i in range(num_pages):
             page_num = i + 1