Allow timed out commands to appear in background commands monitor pane

Author: dwash96

cecli/helpers/background_commands.py

@@ -283,6 +283,7 @@ def __init__(
         self.start_time = time.time()
         self.end_time = None
         self.persist = persist
+        self.continued_in_background = False
         self.input_buffer = input_buffer or InputBuffer()
         self.writer_thread = None
         self._stop_event = threading.Event()
@@ -671,6 +672,20 @@ def start_background_command(
         except Exception as e:
             raise RuntimeError(f"Failed to start background command: {str(e)}")
 
+    @classmethod
+    def mark_continued_in_background(cls, command_key: str) -> bool:
+        """Flag a timeout-managed command as continuing after its timeout."""
+
+        with cls._lock:
+            bg_process = cls._background_commands.get(command_key)
+
+            if not bg_process:
+                return False
+
+            bg_process.continued_in_background = True
+
+            return True
+
     @classmethod
     def is_command_running(cls, command_key: str) -> bool:
         """
@@ -826,6 +841,9 @@ def list_background_commands(cls) -> Dict[str, Dict[str, any]]:
                     "command": bg_process.command,
                     "running": bg_process.is_alive(),
                     "persist": getattr(bg_process, "persist", False),
+                    "continued_in_background": getattr(
+                        bg_process, "continued_in_background", False
+                    ),
                     "buffer_size": bg_process.buffer.size(),
                     "pages": getattr(bg_process.buffer, "page_count", 0),
                     "total_chars": getattr(

cecli/tools/shell.py

@@ -519,6 +519,7 @@ async def _execute_with_timeout(cls, coder, command_string, timeout, use_pty=Non
                     return response
 
             # Timeout elapsed, process continues in background
+            BackgroundCommandManager.mark_continued_in_background(command_key)
             coder.io.tool_output(
                 f"\u23f1\ufe0f Command exceeded {timeout}s timeout, continuing in background...",
                 type="tool-result",

cecli/tui/widgets/background_commands_panel.py

@@ -18,6 +18,9 @@ class BackgroundCommandsPanel(Vertical):
     the selected command's output is re-rendered only when its stream offset
     changes. Reading output is non-destructive so the agent keeps its own
     incremental view of the same buffer.
+
+    Commands that exceed their timeout and keep running appear here once the
+    timeout fires, so the user can watch them continue.
     """
 
     REFRESH_INTERVAL = 0.5
@@ -112,37 +115,47 @@ def _is_shown(self) -> bool:
         return self.parent is None or self.parent.display
 
     def _active_commands(self) -> Dict[str, dict]:
-        """Return only running commands started in the background."""
+        """Return running commands, including timeouts that continued in the background."""
         commands = {}
 
         for command_key, info in BackgroundCommandManager.list_background_commands().items():
             if not info.get("running"):
                 continue
 
-            if info.get("persist"):
+            # Commands started with background=True are always listed; timeout-managed
+            # commands only once their timeout elapsed and they kept running.
+            if info.get("persist") and not info.get("continued_in_background"):
                 continue
 
             commands[command_key] = info
 
         return commands
 
     def _sync_tabs(self, commands: Dict[str, dict]) -> None:
-        """Rebuild the tab bar when the set of active commands changes."""
+        """Add and remove tabs so they match the active command set.
+
+        Tabs must be updated incrementally: ``Tabs.clear`` removes its children
+        asynchronously, so clearing and immediately re-adding the same IDs
+        races with the pending removal and raises ``DuplicateIds``.
+        """
         tabs = self.query_one("#bg-command-tabs", Tabs)
+        previous_keys = list(self._keys)
         self._keys = list(commands)
 
         with self.prevent(Tabs.TabActivated):
-            tabs.clear()
+            for command_key in previous_keys:
+                if command_key not in commands:
+                    tabs.remove_tab(command_key)
 
             for command_key in commands:
-                tabs.add_tab(Tab(command_key, id=command_key, classes="bg-tab"))
+                if command_key not in previous_keys:
+                    tabs.add_tab(Tab(command_key, id=command_key, classes="bg-tab"))
 
-            if self._active_key in commands:
-                tabs.active = self._active_key
-            else:
+            if self._active_key not in commands:
                 self._active_key = next(iter(commands), None)
-                if self._active_key is not None:
-                    tabs.active = self._active_key
+
+            if self._active_key is not None:
+                tabs.active = self._active_key
 
     def _select_tab(self, command_key: str) -> None:
         """Mark a tab active without relying on a user click."""
@@ -163,6 +176,10 @@ def _set_command_line(self, info: dict) -> None:
         """Show the selected command, truncated to the panel width."""
         command = " ".join((info.get("command") or "").split())
         text = f"command: {command}" if command else "command: (none)"
+
+        if info.get("continued_in_background"):
+            text += " (timed out, still running)"
+
         width = max(20, self.size.width - 6)
 
         if len(text) > width:

tests/basic/test_background_commands.py

@@ -402,3 +402,24 @@ def test_get_background_command_output_stops_finished_commands(monkeypatch):
 
     assert "finished" in output
     assert stopped == ["bg_3_0001"]
+
+
+def test_mark_continued_in_background_flags_registered_command(monkeypatch):
+    """Timeout-managed commands are flagged so the panel can list them."""
+    process = types.SimpleNamespace(continued_in_background=False)
+    monkeypatch.setattr(BackgroundCommandManager, "_background_commands", {"bg_1_1234": process})
+
+    assert BackgroundCommandManager.mark_continued_in_background("bg_1_1234") is True
+    assert process.continued_in_background is True
+    assert BackgroundCommandManager.mark_continued_in_background("bg_9_9999") is False
+
+
+def test_mark_continued_in_background_flags_command(monkeypatch):
+    """A timeout-managed command can be flagged as continuing in the background."""
+    process = types.SimpleNamespace(continued_in_background=False)
+    monkeypatch.setattr(BackgroundCommandManager, "_background_commands", {"bg_1_1234": process})
+
+    assert BackgroundCommandManager.mark_continued_in_background("bg_1_1234") is True
+    assert process.continued_in_background is True
+
+    assert BackgroundCommandManager.mark_continued_in_background("bg_9_9999") is False

tests/tools/test_shell_timeout_paging.py

@@ -56,8 +56,10 @@ def make_buffer(page_size=4096, pages_dir=None):
     monkeypatch.setattr(manager, "_generate_command_key", Mock(return_value=target))
     start = Mock(return_value=target)
     stop = Mock()
+    mark = Mock(return_value=True)
     monkeypatch.setattr(manager, "start_background_command", start)
     monkeypatch.setattr(manager, "stop_background_command", stop)
+    monkeypatch.setattr(manager, "mark_continued_in_background", mark)
     pending_tasks = []
 
     async def pending_wait(*args, **kwargs):
@@ -85,6 +87,7 @@ async def execute(output, threshold=8, enabled=True):
         assert not coder.interrupt_event.is_set()
         popen.assert_called_once()
         start.assert_called_once()
+        mark.assert_called_once_with(target)
         assert start.call_args.kwargs["existing_process"] is process
         assert start.call_args.kwargs["existing_buffer"] is state["buffer"]
         assert start.call_args.kwargs["persist"] is True

tests/tui/test_background_commands_panel.py

@@ -32,9 +32,18 @@
         "total_chars": 10,
     },
     "bg_3_4444": {
+        "command": "timeout-tool",
+        "running": True,
+        "persist": True,
+        "continued_in_background": True,
+        "buffer_size": 10,
+        "total_chars": 10,
+    },
+    "bg_4_5555": {
         "command": "foreground-tool",
         "running": True,
         "persist": True,
+        "continued_in_background": False,
         "buffer_size": 10,
         "total_chars": 10,
     },
@@ -43,6 +52,7 @@
 OUTPUTS = {
     "bg_0_1111": "ready in 231 ms\nlistening on 5173",
     "bg_1_2222": "14 passed\n2 skipped",
+    "bg_3_4444": "still compiling",
 }
 
 
@@ -93,7 +103,7 @@ async def _run_panel_checks():
             panel.refresh_data()
             await pilot.pause()
 
-            assert _tab_ids(panel) == ["bg_0_1111", "bg_1_2222"]
+            assert _tab_ids(panel) == ["bg_0_1111", "bg_1_2222", "bg_3_4444"]
 
             tabs = panel.query_one("#bg-command-tabs", Tabs)
             log = panel.query_one("#bg-command-output", RichLog)
@@ -103,7 +113,7 @@ async def _run_panel_checks():
             command_line = panel.query_one("#bg-command-line", Static)
             assert "npm run dev" in str(command_line.render())
 
-            assert panel.border_title == "background commands (2)"
+            assert panel.border_title == "background commands (3)"
             assert panel._active_key == "bg_0_1111"
             assert "listening on 5173" in _log_text(panel)
 
@@ -126,6 +136,14 @@ async def _run_panel_checks():
             await pilot.pause()
             assert "listening on 5173" in _log_text(panel)
 
+            tabs.active = "bg_3_4444"
+            await pilot.pause()
+
+            assert panel._active_key == "bg_3_4444"
+            assert "timeout-tool" in str(command_line.render())
+            assert "timed out, still running" in str(command_line.render())
+            assert "still compiling" in _log_text(panel)
+
 
 def test_background_commands_panel_tabs_output_and_follow():
     asyncio.run(_run_panel_checks())
@@ -299,3 +317,43 @@ def test_open_command_without_tui():
     asyncio.run(OpenCommand.execute(io, coder, "commands"))
 
     assert messages == ["/open commands is only available in the TUI."]
+
+
+def test_background_commands_panel_adds_tabs_incrementally():
+    """A command appearing after the initial render must not duplicate tab IDs."""
+    app = _PanelApp()
+    commands = {"bg_0_1111": COMMANDS["bg_0_1111"]}
+
+    with (
+        patch.object(
+            BackgroundCommandManager,
+            "list_background_commands",
+            side_effect=lambda: dict(commands),
+        ),
+        patch.object(
+            BackgroundCommandManager,
+            "get_command_output",
+            side_effect=lambda key: OUTPUTS.get(key, ""),
+        ),
+        patch.object(
+            BackgroundCommandManager,
+            "get_new_command_output",
+            side_effect=AssertionError("panel must not consume agent output"),
+        ),
+    ):
+
+        async def run():
+            async with app.run_test(size=(120, 40)) as pilot:
+                panel = app.query_one("#background-commands-panel", BackgroundCommandsPanel)
+                panel.refresh_data()
+                await pilot.pause()
+
+                assert _tab_ids(panel) == ["bg_0_1111"]
+
+                commands["bg_3_4444"] = COMMANDS["bg_3_4444"]
+                panel.refresh_data()
+                await pilot.pause()
+
+                assert _tab_ids(panel) == ["bg_0_1111", "bg_3_4444"]
+
+        asyncio.run(run())