feat: implement prompt queue management (CLI-33)

CHANGELOG.md

@@ -30,3 +30,17 @@
 * [Benchmark Results By Language](https://github.com/dwash96/aider-ce/pull/27)
 * [Allow Benchmarks to Use Repo Map For Better Accuracy](https://github.com/dwash96/aider-ce/pull/25)
 * [Read File Globbing](https://github.com/Aider-AI/aider/pull/3395)
+
+### Prompt Queueing (CLI-33)
+- Added `/queue <prompt>` to add prompts to a FIFO queue.
+- Added `/list-queue` to view queued prompts.
+- Added `/remove-queue [index|*]` to remove specific prompts or clear the queue.
+- Queued prompts process automatically after the current command completes.
+- Queue state persists across command executions within a session.
+- Management commands do not trigger queue processing.
+- Queue data structure implemented in `Commands` class with thread-safe operations using `asyncio.Lock`.
+- Max queue size limit of 100 items.
+* [Prompt Queueing](https://github.com/cecli-dev/cecli/issues/33)
+    * Added `/queue`, `/list-queue`, and `/remove-queue` commands for deferred prompt processing.
+    * Queued prompts process automatically in FIFO order when the system is idle.
+    * Queue state is in-memory and session-specific.

README.md

@@ -24,7 +24,7 @@ Use curl to download the script and execute it with sh:
 curl -LsSf https://cecli.dev/install.sh | sh
 ```
 
-If your system doesn't have curl, you can use wget:
+If your system does not have curl, you can use wget:
 
 ```bash
 wget -qO- https://cecli.dev/install.sh | sh
@@ -53,7 +53,7 @@ pip install cecli-dev
 uv tool install --native-tls --python python3.12 cecli-dev
 ```
 
-Use the tool installation so cecli doesn't interfere with your development environment
+Use the tool installation so cecli doesn't interfere with your development environment.
 
 ## Features and Documentation:
 

cecli/coders/base_coder.py

@@ -338,6 +338,15 @@ async def create(
             kwargs = use_kwargs
             from_coder.ok_to_warm_cache = False
 
+            # Preserve the prompt queue across a model switch (same coder
+            # identity) but NOT when spawning a distinct sub-agent (which is
+            # assigned a fresh uuid in its kwargs). Model switches keep
+            # from_coder.uuid; sub-agents override it with a new uuid.
+            is_model_switch = from_coder.uuid == kwargs.get("uuid", "")
+            if is_model_switch:
+                kwargs.setdefault("prompt_queue", from_coder.prompt_queue)
+                kwargs.setdefault("_queue_counter", from_coder._queue_counter)
+
         res = None
         if (
             getattr(main_model, "copy_paste_mode", False)
@@ -357,6 +366,17 @@ async def create(
                 if from_coder.tui:
                     res.tui = from_coder.tui
 
+                # Preserve prompt queue state across model switches (CLI-33).
+                # The queue lives on the coder (see command_queue.py) so the
+                # new coder instance must inherit the list and counter, while
+                # the lock and processing flag are intentionally fresh.
+                # Only model switches inherit the queue; sub-agents get their
+                # own isolated queue (each agent has its own context/queue).
+                if is_model_switch:
+                    res.prompt_queue = from_coder.prompt_queue
+                    res._queue_counter = from_coder._queue_counter
+                res.tui = from_coder.tui
+
                 # Sub-agents get a dedicated, independent MCP manager so they
                 # can rebuild a custom tool list (their own LocalServer tools /
                 # filters) and be disconnected independently from the parent.
@@ -457,6 +477,8 @@ def __init__(
         root=None,
         primary_root=None,
         init_metadata={},
+        prompt_queue=None,
+        _queue_counter=None,
     ):
         from cecli.helpers.agents.service import AgentService
 
@@ -611,12 +633,12 @@ def __init__(
         self.commands = commands or Commands(self.io, self, args=args)
         self.commands.coder = self
 
-        # Prompt queue for CLI-33: in-memory FIFO queue for deferred prompt
-        # processing. The queue lives on the coder so primary agents and
-        # sub-agents each have their own independent queue, managed by
-        # cecli.helpers.command_queue.
-        self.prompt_queue = []
-        self._queue_counter = 0
+        # Prompt queue for CLI-33: in-memory FIFO queue managed by
+        # cecli.helpers.command_queue. The queue lives on the Coder so it
+        # survives model switches (Coder.create preserves identity) while each
+        # sub-agent gets its own isolated queue.
+        self.prompt_queue = list(prompt_queue) if prompt_queue else []
+        self._queue_counter = _queue_counter if _queue_counter else 0
         self._queue_lock = threading.Lock()
         self._processing_queue = False
 
@@ -1962,97 +1984,138 @@ async def run_one(self, user_message, preproc):
         else:
             message = user_message
 
-        if self.commands.is_command(user_message) and not self.commands.is_test_command(
-            user_message
-        ):
-            return
+        # /list-queue and /remove-queue must not trigger auto-processing of the
+        # queue (CLI-33). Every other message/command — including /queue, so a
+        # prompt queued while idle processes immediately — drains the queue once
+        # it has fully completed, so queued prompts are sent to the LLM after
+        # the current prompt finishes.
+        is_management_command = self._is_queue_management_command(user_message)
 
-        if not self.commands.is_command(user_message):
-            ConversationService.get_chunks(self).flush_removals()
-            self.last_user_message = user_message
-            self.error_code = None
-            self.num_tool_calls = 0
-            # Trim memory in the background so it doesn't delay the response
-            coroutines.fire_and_forget(asyncio.to_thread(trim_memory))
-            # Fire memorizer after each user request
-            # if self.auto_memory and self.edit_format not in ["subagent"]:
-            #    from cecli.helpers.memory.utils import invoke_memorizer
-            #
-            #    context = "If the user has stated any preferences, please remember them"
-            #    asyncio.create_task(invoke_memorizer(self, additional_context=context))
+        try:
+            if self.commands.is_command(user_message) and not self.commands.is_test_command(
+                user_message
+            ):
+                return
 
-        while True:
-            self.reflected_message = None
-            self.empty_response = False
-            self.tool_reflection = False
+            if not self.commands.is_command(user_message):
+                ConversationService.get_chunks(self).flush_removals()
+                self.last_user_message = user_message
+                self.error_code = None
+                self.num_tool_calls = 0
+                # Trim memory in the background so it doesn't delay the response
+                coroutines.fire_and_forget(asyncio.to_thread(trim_memory))
+                # Fire memorizer after each user request
+                # if self.auto_memory and self.edit_format not in ["subagent"]:
+                #    from cecli.helpers.memory.utils import invoke_memorizer
+                #
+                #    context = "If the user has stated any preferences, please remember them"
+                #    asyncio.create_task(invoke_memorizer(self, additional_context=context))
 
-            if float(self.total_cost) > self.cost_multiplier * (
-                nested.getter(self.args, "cost_limit", float("inf")) or float("inf")
-            ):
-                if await self.io.confirm_ask(
-                    "You have reached your configured cost limit. Continue?",
-                    group_response="Cost Limit",
-                    explicit_yes_required=True,
+            while True:
+                self.reflected_message = None
+                self.empty_response = False
+                self.tool_reflection = False
+
+                if float(self.total_cost) > self.cost_multiplier * (
+                    nested.getter(self.args, "cost_limit", float("inf")) or float("inf")
                 ):
-                    Coder.cost_multiplier += 1
-                else:
-                    return
+                    if await self.io.confirm_ask(
+                        "You have reached your configured cost limit. Continue?",
+                        group_response="Cost Limit",
+                        explicit_yes_required=True,
+                    ):
+                        Coder.cost_multiplier += 1
+                    else:
+                        return
 
-            async for _ in self.send_message(message):
-                pass
+                async for _ in self.send_message(message):
+                    pass
 
-            await self.hot_reload()
+                await self.hot_reload()
 
-            if not self.empty_response:
-                if not self.reflected_message:
-                    await self.auto_save_session(force=True)
-                    break
+                if not self.empty_response:
+                    if not self.reflected_message:
+                        await self.auto_save_session(force=True)
+                        break
 
-                if self.num_reflections >= self.max_reflections:
-                    self.io.tool_warning(
-                        f"Only {self.max_reflections} reflections allowed, stopping."
-                    )
-                    break
+                    if self.num_reflections >= self.max_reflections:
+                        self.io.tool_warning(
+                            f"Only {self.max_reflections} reflections allowed, stopping."
+                        )
+                        break
 
-                self.num_reflections += 1
+                    self.num_reflections += 1
 
-                if self.tool_reflection:
-                    self.num_reflections -= 1
+                    if self.tool_reflection:
+                        self.num_reflections -= 1
 
-                if self.reflected_message is True:
-                    message = None
-                else:
-                    message = self.reflected_message
-            elif self.stop_on_empty:
-                await self.auto_save_session(force=True)
-                break
+                    if self.reflected_message is True:
+                        message = None
+                    else:
+                        message = self.reflected_message
+                elif self.stop_on_empty:
+                    await self.auto_save_session(force=True)
+                    break
 
-            if self.enable_context_compaction:
-                await self.compact_context_if_needed()
+                if self.enable_context_compaction:
+                    await self.compact_context_if_needed()
+
+                if nested.getter(self, "agent_finished", False):
+                    await self.auto_save_session(force=True)
+                    break
 
-            if nested.getter(self, "agent_finished", False):
                 await self.auto_save_session(force=True)
-                break
+        finally:
+            # Drain the queue once the current message/command has fully
+            # completed, so queued prompts are sent to the LLM (CLI-33).
+            if not is_management_command:
+                await self._drain_prompt_queue(preproc)
 
-            await self.auto_save_session(force=True)
+        if not await HookIntegration.call_end_hooks(self):
+            self.io.tool_warning("Execution stopped by end hook")
+            return
 
-        # 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
-        # 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
+    def _is_queue_management_command(self, user_message):
+        """Return True if user_message is a read-only queue-management command.
+
+        Only /list-queue and /remove-queue are excluded from auto-processing:
+        they inspect or mutate the queue without the user asking queued prompts
+        to run. /queue is deliberately NOT management here, so a prompt queued
+        while the coder is idle drains (and processes) immediately afterward.
+        """
+        if not self.commands or not self.commands.is_command(user_message):
+            return False
+        words = user_message.strip().split()
+        if not words:
+            return False
+        cmd_name = words[0][1:]
+        return cmd_name in ("list-queue", "remove-queue")
 
-            if item is not None:
-                self.io.tool_output(f"Processing queued prompt (id: {item['id']})...")
-                await self.run_one(item["text"], preproc)
+    async def _drain_prompt_queue(self, preproc):
+        """Process all queued prompts (FIFO) once the current message completes.
 
-        if not await HookIntegration.call_end_hooks(self):
-            self.io.tool_warning("Execution stopped by end hook")
+        Runs each queued prompt through ``run_one`` so it is sent to the LLM
+        exactly like a user-typed prompt. A single failing queued prompt is
+        logged and does not stop the remaining ones (``SwitchCoderSignal`` and
+        ``ReloadProgramSignal`` are BaseExceptions and propagate unchanged).
+        """
+        if self._processing_queue:
             return
+        self._processing_queue = True
+        try:
+            while True:
+                item = command_queue.dequeue_prompt(self)
+                if item is None:
+                    break
+                text = item["text"]
+                preview = text if len(text) <= 80 else text[:80] + "..."
+                self.io.tool_output(f"Processing queued prompt: {preview}")
+                try:
+                    await self.run_one(text, preproc)
+                except Exception as e:
+                    self.io.tool_error(f"Error processing queued prompt: {e}")
+        finally:
+            self._processing_queue = False
 
     def _is_url_allowed(self, url):
         allowed_domains = self.security_config.get("allowed-domains")

cecli/commands/__init__.py

@@ -38,6 +38,7 @@
 from .hooks import HooksCommand
 from .hot_reload import HotReloadCommand
 from .include_skill import IncludeSkillCommand
+from .insert_queue import InsertQueueCommand
 from .lint import LintCommand
 from .list_mcp import ListMcpCommand
 from .list_queue import ListQueueCommand
@@ -134,9 +135,11 @@
 CommandRegistry.register(SpawnAgentCommand)
 CommandRegistry.register(SwitchAgentCommand)
 CommandRegistry.register(IncludeSkillCommand)
+CommandRegistry.register(InsertQueueCommand)
 CommandRegistry.register(LintCommand)
 CommandRegistry.register(ListMcpCommand)
 CommandRegistry.register(ListQueueCommand)
+CommandRegistry.register(RemoveQueueCommand)
 CommandRegistry.register(ListSessionsCommand)
 CommandRegistry.register(ListSkillsCommand)
 CommandRegistry.register(LoadCommand)
@@ -221,11 +224,13 @@
     "HooksCommand",
     "HotReloadCommand",
     "IncludeSkillCommand",
+    "InsertQueueCommand",
     "ReapAgentCommand",
     "SpawnAgentCommand",
     "SwitchAgentCommand",
     "LintCommand",
     "ListSessionsCommand",
+    "ListQueueCommand",
     "ListSkillsCommand",
     "LoadCommand",
     "LoadHookCommand",
@@ -244,6 +249,7 @@
     "PasteCommand",
     "quote_filename",
     "QueueCommand",
+    "RemoveQueueCommand",
     "QuitCommand",
     "ReadOnlyCommand",
     "ReadOnlyStubCommand",