cecli-dev 1.8.1rc3__tar.gz → 1.10.0__tar.gz

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.1rc3
+Version: 1.10.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -37,6 +37,8 @@ Requires-Dist: xxhash>=3.6.0
 Requires-Dist: beautifulsoup4>=4.13.4
 Requires-Dist: pypandoc>=1.15
 Requires-Dist: chromadb>=1.5.9
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: onnxruntime>=1.14.1
 Requires-Dist: diskcache>=5.6.3
 Requires-Dist: json-repair>=0.60.1
 Requires-Dist: jsonschema>=4.25.0

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/__init__.py

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

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.8.1rc3'
-__version_tuple__ = version_tuple = (1, 8, 1, 'rc3')
+__version__ = version = '1.10.0'
+__version_tuple__ = version_tuple = (1, 10, 0)
 
-__commit_id__ = commit_id = 'gb07a9f6ad'
+__commit_id__ = commit_id = 'g790a8ad04'

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/args.py

@@ -31,6 +31,7 @@ DEEP_MERGE_LIST_FIELDS: frozenset[str] = frozenset(
         "file",
         "read",
         "mcp_servers_files",
+        "acp_models",
         "set_env",
         "api_key",
         "alias",
@@ -252,7 +253,7 @@ def get_parser(default_config_files, git_root):
         metavar="EDIT_FORMAT",
         choices=edit_format_choices,
         default=None,
-        help="Specify what edit format the LLM should use (default depends on model)",
+        help="Specify what edit format the LLM should use (default: agent)",
     )
     group.add_argument(
         "--ask",
@@ -362,7 +363,9 @@ def get_parser(default_config_files, git_root):
         metavar="RETRIES_JSON",
         help=(
             'Specify LLM retry configuration as a JSON/YAML string (e.g., \'{"retry_on_empty": '
-            'true, "retry-on-unauthorized": false}\')'
+            'true, "retry-on-unauthorized": false, "fallbacks": {"models": {"model": '
+            '["backup-model"]}, "keys": {"openai": ["OPENAI_API_KEY", '
+            '"OPENAI_API_KEY_2"]}}}\')'
         ),
         default=None,
     )
@@ -1313,6 +1316,24 @@ def get_parser(default_config_files, git_root):
         help="Specify server configuration (WebSocket and headless) as a JSON/YAML string",
         default=None,
     )
+    group.add_argument(
+        "--acp",
+        action="store_true",
+        default=False,
+        help=(
+            "Run as an Agent Client Protocol (ACP) agent over stdio, for editors such as Zed"
+            " (stdout carries the protocol)"
+        ),
+    )
+    group.add_argument(
+        "--acp-models",
+        action="append",
+        metavar="PATTERN",
+        help=(
+            "Limit the ACP model picker's provider lists to models matching this pattern,"
+            " matched like /models (can be used multiple times)"
+        ),
+    )
 
     ##########
     group = parser.add_argument_group("Deprecated model settings")

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/coders/agent_coder.py

@@ -1,7 +1,6 @@
 import asyncio
 import base64
 import json
-import locale
 import logging
 import os
 import platform
@@ -65,10 +64,8 @@ class AgentCoder(Coder):
         self.read_tools = {
             "command",
             "explorecode",
-            "ls",
             "readfile",
             "grep",
-            "thinking",
             "updatetodolist",
             "searchfacts",
         }
@@ -236,6 +233,7 @@ class AgentCoder(Coder):
             config,
             ["tools_excludelist", "tools_blacklist"],
             [
+                "create",
                 "gitbranch",
                 "gitdiff",
                 "gitlog",
@@ -243,6 +241,7 @@ class AgentCoder(Coder):
                 "gitshow",
                 "gitstatus",
                 "searchfacts",
+                "searchdocs",
                 "replacefacts",
             ],
         )
@@ -295,6 +294,12 @@ class AgentCoder(Coder):
             except KeyError:
                 pass
 
+        if config.get("creator_mode") or config.get("allow_external_paths"):
+            if "searchdocs" in config["tools_excludelist"]:
+                config["tools_excludelist"].remove("searchdocs")
+            if "creator_requirements" not in config["exclude_context_blocks"]:
+                config["include_context_blocks"].add("creator_requirements")
+
         if "skills" in self.allowed_context_blocks:
             config["skills_paths"] = nested.getter(config, "skills_paths", [])
             config["skills_includelist"] = nested.getter(
@@ -348,6 +353,10 @@ class AgentCoder(Coder):
             verbose = getattr(self.args, "verbose", False) if self.args else False
             self.mcp_manager = McpServerManager([], self.io, verbose)
 
+        await self._initialize_local_server()
+        await self._connect_configured_servers()
+
+    async def _initialize_local_server(self):
         server_name = "Local"
         server = self.mcp_manager.get_server(server_name)
 
@@ -369,6 +378,35 @@ class AgentCoder(Coder):
         else:
             await self.mcp_manager.connect_server(server_name)
 
+    async def _connect_configured_servers(self):
+        """Open connections for servers named in this agent's ``servers`` allowlist.
+
+        ``McpServerManager.spawn_child`` only mirrors servers the parent already
+        had connected, so a workflow's declarative ``servers:`` list would never
+        open a connection for servers that are disabled by default (or whose
+        parent connection failed).
+        """
+        included = getattr(self, "registered_servers", {}).get("included") or set()
+
+        for name in sorted(included):
+            if name == "local":
+                continue
+
+            server = self.mcp_manager.get_server(name)
+            if server is None:
+                self.io.tool_warning(
+                    f"MCP server '{name}' is required by this agent but is not configured"
+                )
+                continue
+
+            if server.is_connected:
+                continue
+
+            if not await self.mcp_manager.connect_server(server.name):
+                self.io.tool_warning(
+                    f"Failed to connect MCP server '{server.name}' required by this agent"
+                )
+
     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
@@ -464,6 +502,7 @@ class AgentCoder(Coder):
                 "servers",
                 "sub_agents",
                 "orchestration",
+                "creator_requirements",
             ]
             for block_type in block_types:
                 if block_type in self.allowed_context_blocks:
@@ -492,6 +531,8 @@ class AgentCoder(Coder):
             content = self.get_context_symbol_outline()
         elif block_name == "context_summary":
             content = self.get_context_summary()
+        elif block_name == "creator_requirements":
+            content = self.get_creator_requirements_context()
         elif block_name == "todo_list":
             content = self.get_todo_list()
         elif block_name == "skills":
@@ -763,7 +804,7 @@ class AgentCoder(Coder):
         try:
             current_date = datetime.now().strftime("%Y-%m-%d")
             platform_info = platform.platform()
-            language = self.chat_language or locale.getlocale()[0] or "en-US"
+            language = self.get_user_language() or "English"
             result = '<context name="environment_info" from="agent">\n'
             result += "## Environment Information\n\n"
             result += f"- Working directory: {self.root}\n"
@@ -842,6 +883,7 @@ class AgentCoder(Coder):
         for tool_call in tool_calls_list:
             tool_name = tool_call.function.name
             result_message = ""
+            self.io.tool_call_event(tool_call.id, "in_progress")
             try:
                 if responses.unprefix_tool_name(tool_name)[1].lower() in self.write_tools:
                     used_write_tool = True
@@ -1598,6 +1640,41 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
             self.io.tool_error(f"Error generating todo list context: {str(e)}")
             return None
 
+    def get_creator_requirements_context(self):
+        """List importable packages for creator-written tools and commands.
+
+        Only emitted for creator-mode agents. Lists top-level modules from the
+        Python environment that is actually running cecli, regardless of the
+        project's requirements files.
+        """
+        from cecli.helpers.creator import requirements
+
+        if not self.use_enhanced_context:
+            return None
+
+        config = getattr(self, "agent_config", {}) or {}
+        if not (config.get("creator_mode") or config.get("allow_external_paths")):
+            return None
+
+        discovery = requirements.packages_context()
+        if not discovery:
+            return None
+
+        environment, packages = discovery
+
+        result = '<context name="creator_requirements" from="agent">\n'
+        result += "## Available Python Packages\n\n"
+        result += (
+            f"Top-level modules installed in the {environment} environment running cecli "
+            "are importable by custom tools and custom commands. Distribution names may "
+            "differ from import names:\n\n"
+        )
+        for start in range(0, len(packages), 8):
+            result += "- " + ", ".join(packages[start : start + 8]) + "\n"
+        result += "</context>"
+
+        return result
+
     def get_skills_context(self):
         """
         Generate a context block for available skills.

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/coders/base_coder.py

@@ -42,7 +42,11 @@ from cecli.helpers import command_parser, command_queue, coroutines, nested, res
 from cecli.helpers.conversation import ConversationService, MessageTag
 from cecli.helpers.file_system import FileSystemService
 from cecli.helpers.io_proxy import IOProxy
-from cecli.helpers.loop_detect import LoopDetectedError, LoopDetector
+from cecli.helpers.loop_detect import (
+    LoopDetectedError,
+    LoopDetector,
+    LoopThresholdTracker,
+)
 from cecli.helpers.memory_control import trim_memory
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
@@ -291,8 +295,8 @@ class Coder(metaclass=UsageMeta):
     commit_language = None
     file_watcher = None
     mcp_manager = None
-    run_one_completed = True
     compact_context_completed = True
+    _drain_queue_after_command = False
     suppress_announcements_for_next_prompt = False
     tool_reflection = False
     last_user_message = ""
@@ -684,6 +688,8 @@ class Coder(metaclass=UsageMeta):
         self._queue_counter = 0
         self._queue_lock = threading.Lock()
         self._processing_queue = False
+        self._active_queue_prompt = None
+        self._drain_queue_after_command = False
 
         self.data_cache = {
             "repo": {"last_key": "", "read_only_count": None},
@@ -880,6 +886,13 @@ class Coder(metaclass=UsageMeta):
             pass
 
         self.custom = customizations
+
+        # Owns the loop-detection settings and how much repetition is currently
+        # allowed; handed to every stream's detectors.
+        self.repetition_penalties = LoopThresholdTracker(
+            config=nested.getter(self.custom, "repetition_penalties", None)
+        )
+
         self.file_diffs = nested.getter(self.args, "file_diffs", True)
 
         if nested.getter(self.custom, "prompt_map.all", None):
@@ -996,12 +1009,12 @@ class Coder(metaclass=UsageMeta):
             settings_items.append(f"reasoning {reasoning_effort}")
 
         # Prompt cache
-        if self.add_cache_headers or main_model.caches_by_default:
-            settings_items.append("prompt cache")
+        # if self.add_cache_headers or main_model.caches_by_default:
+        #   settings_items.append("prompt cache")
 
         # Infinite output
-        if main_model.info.get("supports_assistant_prefill") and self.verbose:
-            settings_items.append("infinite output")
+        # if main_model.info.get("supports_assistant_prefill") and self.verbose:
+        #    settings_items.append("infinite output")
 
         # Copy/paste mode
         if self.copy_paste_mode:
@@ -1031,10 +1044,6 @@ class Coder(metaclass=UsageMeta):
                 refresh = self.repo_map.refresh
                 env_items.append(f"map ({map_tokens} tokens, {refresh} refresh)")
                 repo_map_tokens = map_tokens
-            else:
-                env_items.append("repo-map disabled")
-        else:
-            env_items.append("repo-map disabled")
 
         sections["Environment"] = {"items": env_items}
         # --- CAPABILITIES ---
@@ -1074,7 +1083,7 @@ class Coder(metaclass=UsageMeta):
             if mcp_servers:
                 capabilities["Servers"] = mcp_servers
 
-        if capabilities:
+        if capabilities and not getattr(self.args, "tui", False):
             # sections["Extensions"] = {"subsections": capabilities}
             sections["Environment"]["subsections"] = capabilities
 
@@ -1627,6 +1636,10 @@ class Coder(metaclass=UsageMeta):
         async for chunk in self.send_message(user_message):
             yield chunk
 
+        # Stream-driven interfaces bypass run_one(), so drain the queue here
+        # to keep queued prompts processing after the request completes.
+        await self.process_prompt_queue()
+
     def init_before_message(self):
         self.coder_edited_files = set()
         self.reflected_message = None
@@ -1946,14 +1959,12 @@ class Coder(metaclass=UsageMeta):
                     await self.compact_context_if_needed()
                     self.compact_context_completed = True
 
-            self.run_one_completed = False
             await self.run_one(user_message, preproc)
             self.show_undo_hint()
         except asyncio.CancelledError:
             # Don't show undo hint if cancelled
             raise
         finally:
-            self.run_one_completed = True
             self.compact_context_completed = True
             self.io.stop_spinner()
             # Trim memory in the background so it doesn't stall the event loop
@@ -2013,9 +2024,6 @@ class Coder(metaclass=UsageMeta):
             try:
                 return await self.commands.run(inp, coder=self, **run_kwargs)
             finally:
-                # Dispatch can return early (unknown/ambiguous command) or
-                # raise without ever running a command; the gate must still be
-                # reopened or the input/output loops park forever.
                 self.commands.cmd_running_event.set()
 
         await self.check_for_file_mentions(inp)
@@ -2026,6 +2034,67 @@ class Coder(metaclass=UsageMeta):
     def wrap_user_input(self, inp):
         return inp
 
+    async def process_prompt_queue(self, preproc=True):
+        """Drain the coder's prompt queue in FIFO order.
+
+        Re-entrant calls return immediately. Each item is activated before it
+        runs so an interrupt can put it back at the front of the queue, and
+        failures are isolated so one prompt does not abort the rest.
+        """
+        if self._processing_queue:
+            return
+
+        def warn_paused():
+            remaining = command_queue.get_queue_length(self)
+            self.io.tool_warning(
+                f"Queue processing interrupted. {remaining} prompt(s) remain"
+                " queued; use /run-queue to resume."
+            )
+
+        from cecli.helpers.agents.service import AgentService
+
+        self._processing_queue = True
+        try:
+            while True:
+                item = command_queue.dequeue_for_processing(self)
+                if item is None:
+                    break
+
+                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
+                try:
+                    await self.generate(item["text"], preproc)
+                    interrupt_event = getattr(self, "interrupt_event", None)
+                    if interrupt_event is not None and interrupt_event.is_set() is True:
+                        command_queue.requeue_active_prompt(self)
+                        warn_paused()
+                        break
+                except (asyncio.CancelledError, KeyboardInterrupt):
+                    command_queue.requeue_active_prompt(self)
+                    warn_paused()
+                    raise
+                except SwitchCoderSignal as switch:
+                    if not getattr(self, "parent_uuid", ""):
+                        raise
+
+                    service = AgentService.get_instance(self)
+                    info = service.sub_agents.get(self.uuid)
+                    if info is None:
+                        raise
+
+                    await service.switch_sub_agent_coder(info, switch, preproc)
+                    return
+                except SystemExit:
+                    raise
+                except Exception as e:
+                    command_queue.clear_active_prompt(self)
+                    self.io.tool_error(f"Error processing queued prompt (id: {item['id']}): {e}")
+                    continue
+
+                command_queue.clear_active_prompt(self)
+        finally:
+            self._drain_queue_after_command = False
+            command_queue.finish_processing(self)
+
     async def run_one(self, user_message, preproc):
         self.init_before_message()
 
@@ -2041,6 +2110,9 @@ class Coder(metaclass=UsageMeta):
         if self.commands.is_command(user_message) and not self.commands.is_test_command(
             user_message
         ):
+            if self._processing_queue or self._drain_queue_after_command:
+                self._drain_queue_after_command = False
+                await self.process_prompt_queue(preproc)
             return
 
         if not self.commands.is_command(user_message):
@@ -2112,19 +2184,10 @@ class Coder(metaclass=UsageMeta):
 
             await self.auto_save_session(force=True)
 
-        # Move to the next queued prompt (CLI-33) only after the current message
-        # has fully completed, so the queue drains within run_one() instead of
+        # Drain any queued prompts (CLI-33) only after the current message has
+        # fully completed, so the queue is processed within run_one() instead of
         # being watched by the generation loops.
-        if self.prompt_queue and not self._processing_queue:
-            self._processing_queue = True
-            try:
-                item = command_queue.dequeue_prompt(self)
-            finally:
-                self._processing_queue = False
-
-            if item is not None:
-                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
-                await self.run_one(item["text"], preproc)
+        await self.process_prompt_queue(preproc)
 
         if not await HookIntegration.call_end_hooks(self):
             self.io.tool_warning("Execution stopped by end hook")
@@ -2593,7 +2656,7 @@ class Coder(metaclass=UsageMeta):
             language = user_lang
         else:
             # Default if no specific lang detected
-            language = "the same language they are using"
+            language = "the user's most recently used language"
 
         if self.fence[0] == "`" * 4:
             quad_backtick_reminder = (
@@ -2717,7 +2780,7 @@ class Coder(metaclass=UsageMeta):
     async def check_tokens(self, messages):
         """Check if the messages will fit within the model's token limits."""
         input_tokens = self.get_active_model().token_count(messages)
-        max_input_tokens = self.get_active_model().info.get("max_input_tokens") or 128000
+        max_input_tokens = self.get_active_model().info.get("max_input_tokens") or 256000
 
         if max_input_tokens and input_tokens >= max_input_tokens:
             if (
@@ -3284,6 +3347,7 @@ class Coder(metaclass=UsageMeta):
                     continue
 
                 tool_id_set.add(tool_call.id)
+                self.io.tool_call_event(tool_call.id, "in_progress")
 
                 try:
                     # Arguments can be a stream of JSON objects.
@@ -3490,6 +3554,11 @@ class Coder(metaclass=UsageMeta):
         for server, server_responses in tool_responses_by_server.items():
             for tool_response in server_responses:
                 tool_responses.append(tool_response)
+                self.io.tool_call_event(
+                    tool_response["tool_call_id"],
+                    "completed",
+                    result=tool_response.get("content"),
+                )
 
                 ConversationService.get_manager(self).add_message(
                     message_dict=tool_response,
@@ -3507,6 +3576,12 @@ class Coder(metaclass=UsageMeta):
 
         for server, tool_calls in server_tool_calls.items():
             for tool_call in tool_calls:
+                self.io.tool_call_event(
+                    tool_call.id,
+                    "pending",
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                )
                 try:
                     if ToolRegistry.get_tool(tool_call.function.name.lower()):
                         ToolRegistry.get_tool(tool_call.function.name.lower()).format_output(
@@ -4050,8 +4125,8 @@ class Coder(metaclass=UsageMeta):
     async def show_send_output_stream(self, completion):
         received_content = False
         chunk_index = 0
-        content_detector = LoopDetector()
-        tool_detector = LoopDetector()
+        content_detector = LoopDetector(self.repetition_penalties)
+        tool_detector = LoopDetector(self.repetition_penalties)
         loop_detected = False
 
         stream = coroutines.interruptible_async_generator(completion, self.interrupt_event)
@@ -4190,6 +4265,7 @@ class Coder(metaclass=UsageMeta):
         except LoopDetectedError as e:
             self._output_loop_detected = True
             self._output_loop_message = str(e)
+            self.repetition_penalties.record_loop(e.level)
             loop_detected = True
 
         if loop_detected:
@@ -4221,6 +4297,10 @@ class Coder(metaclass=UsageMeta):
             content_to_show = self.live_incremental_response(False)
             self.stream_wrapper(content_to_show, final=False)
 
+        # The stream ran to completion without tripping the detector, so bleed the
+        # relaxations back toward the configured limits.
+        self.repetition_penalties.record_clean_turn()
+
         # The Part Doing the Heavy Lifting Now
         self.consolidate_chunks()
 
@@ -4366,7 +4446,7 @@ class Coder(metaclass=UsageMeta):
         if self._output_loop_detected:
             # A repeating output loop was caught while streaming; turn it into an
             # assistant message so the model can adjust and drop any tool calls.
-            marker = "\n\n[SYSTEM CANCEL: OUTPUT LOOP DETECTED]\n"
+            marker = f"\n\n{LoopDetector.INTERJECTION}\n"
             self.partial_response_content += marker
             self.partial_response_tool_calls = []
             self.partial_response_function_call = dict()
@@ -4828,7 +4908,7 @@ class Coder(metaclass=UsageMeta):
         if self.tui and self.tui():
             self.tui().update_cost(self.usage_report.replace("\n", " "))
         else:
-            self.io.tool_output(self.usage_report)
+            self.io.tool_output(self.usage_report, type="usage-report")
             self.io.rule()
 
         self.message_cost = 0.0

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/commands/__init__.py

@@ -25,6 +25,7 @@ from .context_management import ContextManagementCommand
 from .copy import CopyCommand
 from .copy_context import CopyContextCommand
 from .core import Commands
+from .creator import CreatorCommand
 from .diff import DiffCommand
 from .drop import DropCommand
 from .editor import EditCommand, EditorCommand
@@ -73,6 +74,7 @@ from .report import ReportCommand
 from .reset import ResetCommand
 from .rules import RulesCommand
 from .run import RunCommand
+from .run_queue import RunQueueCommand
 from .save import SaveCommand
 from .save_session import SaveSessionCommand
 from .search_memory import SearchMemoryCommand
@@ -120,6 +122,7 @@ CommandRegistry.register(ContextCommand)
 CommandRegistry.register(ContextManagementCommand)
 CommandRegistry.register(CopyCommand)
 CommandRegistry.register(CopyContextCommand)
+CommandRegistry.register(CreatorCommand)
 CommandRegistry.register(DiffCommand)
 CommandRegistry.register(DropCommand)
 CommandRegistry.register(EditCommand)
@@ -169,6 +172,7 @@ CommandRegistry.register(ReportCommand)
 CommandRegistry.register(ResetCommand)
 CommandRegistry.register(RulesCommand)
 CommandRegistry.register(RunCommand)
+CommandRegistry.register(RunQueueCommand)
 CommandRegistry.register(SaveCommand)
 CommandRegistry.register(SaveSessionCommand)
 CommandRegistry.register(SearchMemoryCommand)
@@ -209,6 +213,7 @@ __all__ = [
     "ContextManagementCommand",
     "CopyCommand",
     "CopyContextCommand",
+    "CreatorCommand",
     "DiffCommand",
     "DropCommand",
     "EditCommand",
@@ -265,6 +270,7 @@ __all__ = [
     "ResetCommand",
     "RulesCommand",
     "RunCommand",
+    "RunQueueCommand",
     "SaveCommand",
     "SaveSessionCommand",
     "SearchMemoryCommand",

{cecli_dev-1.8.1rc3 → cecli_dev-1.10.0}/cecli/commands/core.py

@@ -14,6 +14,9 @@ from cecli.signals import SwitchCoderSignal
 class Commands:
     scraper = None
 
+    # Commands that receive their full argument text for nested completion.
+    FULL_ARGS_COMPLETION_COMMANDS = ("/queue", "/insert-queue")
+
     def _get_coder(self):
         """Return coder via weak reference, or None if collected."""
         if self._coder_ref is not None:
@@ -90,7 +93,7 @@ class Commands:
         self.last_command_show_notification = True
 
         # Commands that should NOT trigger auto-processing of the queue
-        self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue"}
+        self._MANAGEMENT_COMMANDS = {"queue", "list-queue", "remove-queue", "run-queue"}
 
     def _load_custom_commands(self, custom_commands):
         """

cecli_dev-1.10.0/cecli/commands/creator.py

@@ -0,0 +1,44 @@
+"""Creator command - spawns the creator sub-agent with a prompt."""
+
+from .utils.base_command import BaseCommand
+
+
+class CreatorCommand(BaseCommand):
+    NORM_NAME = "creator"
+    DESCRIPTION = "Spawn the creator sub-agent to build or configure extensions"
+    show_completion_notification = True
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Spawn the creator sub-agent with the supplied prompt."""
+        from cecli.helpers.agents.service import AgentService
+
+        prompt = args.strip() or None
+
+        try:
+            agent_service = AgentService.get_instance(coder)
+            new_coder, info = await agent_service.spawn(
+                "creator", prompt, parent=coder, auto_reap=False, independent=True
+            )
+
+            agent_service.foreground_uuid = info.coder.uuid
+
+            if coder.tui and coder.tui():
+                tui = coder.tui()
+                switch_key = tui.get_keys_for("next_agent")
+                io.tool_output(f"Creator agent spawned and active. Switch with {switch_key}")
+
+                try:
+                    tui.call_from_thread(tui._switch_to_container, info.coder.uuid)
+                except Exception:
+                    pass
+        except ValueError as e:
+            io.tool_error(f"Error: {e}")
+        except RuntimeError as e:
+            io.tool_error(f"Error: {e}")
+        except Exception as e:
+            io.tool_error(f"Error spawning creator sub-agent: {e}")
+
+    @classmethod
+    def get_help(cls) -> str:
+        return "Spawn the creator sub-agent, optionally with a prompt (/creator [prompt])"