cecli-dev 1.10.0rc1__tar.gz → 1.10.0rc2__tar.gz

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.10.0rc1'
-__version_tuple__ = version_tuple = (1, 10, 0, 'rc1')
+__version__ = version = '1.10.0rc2'
+__version_tuple__ = version_tuple = (1, 10, 0, 'rc2')
 
-__commit_id__ = commit_id = 'gd9504b4c3'
+__commit_id__ = commit_id = 'g9073df907'

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/cecli/coders/agent_coder.py

@@ -348,6 +348,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 +373,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

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/cecli/helpers/agents/service.py

@@ -664,6 +664,15 @@ class AgentService:
                 inherited.setdefault("allow_nested_delegation", True)
             agent_config = inherited
 
+        # Workflow agents always keep the Local server available: its tools are
+        # the file/exec primitives a worker needs, and an explicit ``servers:``
+        # allowlist must not filter them out.
+        if name.startswith("wf:") and agent_config.get("servers_includelist"):
+            servers = [str(server).lower() for server in agent_config["servers_includelist"]]
+            if "local" not in servers:
+                servers.append("local")
+            agent_config["servers_includelist"] = servers
+
         kwargs = dict(
             io=parent_coder.io,
             from_coder=parent_coder,
@@ -909,6 +918,17 @@ class AgentService:
                 info.summary = info.summary or DEFAULT_SUMMARY_INTERRUPTED
                 logger.debug("Sub-agent %s generate cancelled (interrupted)", info.name)
                 raise
+            except SwitchCoderSignal as switch:
+                # A command run mid-turn (e.g. /load-mcp) asks for this
+                # sub-agent's coder to be rebuilt. Absorb the signal here:
+                # letting it escape would recreate the *primary* coder from a
+                # sub-agent. The switch also drains any prompts staged behind
+                # the command, mirroring run_one()'s post-command drain.
+                await self.switch_sub_agent_coder(info, switch, preproc=True)
+                await self._inject_sub_agent_result(info)
+                if info.status == SubAgentStatus.RUNNING:
+                    info.status = SubAgentStatus.FINISHED
+                    info.summary = info.summary or DEFAULT_SUMMARY_COMPLETED
             except Exception as exc:
                 stop_reason, error = "error", str(exc) or exc.__class__.__name__
                 await self._inject_sub_agent_result(info)
@@ -921,8 +941,6 @@ class AgentService:
                     exc_info=True,
                 )
                 raise
-            except SwitchCoderSignal:
-                raise
             finally:
                 _subagent_event(
                     info.coder, info.coder.uuid, "idle", stop_reason=stop_reason, error=error

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/cecli/tui/widgets/floating_panels.py

@@ -1,12 +1,10 @@
 """Extensions box showing sub-agents, skills, and MCP servers."""
 
-from textual.containers import Horizontal, HorizontalScroll, Vertical
+from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.message import Message
 from textual.reactive import reactive
 from textual.widgets import Static
 
-from .thin_scrollbar import ThinScrollBarRenderer
-
 
 class StatusItemClicked(Message):
     """Posted when a status item is clicked."""
@@ -38,8 +36,8 @@ class StatusItem(Static):
         event.stop()
 
 
-class StatusRow(Horizontal):
-    """A reactive horizontal row of clickable status items."""
+class StatusColumn(Vertical):
+    """A reactive vertical column of clickable status items."""
 
     items = reactive([], recompose=True)
 
@@ -60,61 +58,56 @@ class FloatingPanels(Vertical):
     """Single box showing sub-agents, skills, and MCP servers.
 
     Every item is clickable: sub-agents spawn, skills load/unload, and MCP
-    servers load/unload. Labels stay fixed while the three rows scroll
-    horizontally together.
+    servers load/unload. The three categories sit in equal-width columns
+    beneath labels embedded in the top border, and share one scroll area.
     """
 
-    MAX_NAME_WIDTH = 20
+    MAX_NAME_WIDTH = 10
 
     DEFAULT_CSS = """
     FloatingPanels {
         height: auto;
         width: 42;
         border: round $accent 50%;
-        border-title-align: right;
+        border-title-align: center;
+        border-title-color: $accent 50%;
+        border-title-style: bold;
         padding: 0 1;
         background: $surface;
     }
 
     FloatingPanels > .status-body {
-        height: auto;
+        height: 100%;
         width: 100%;
     }
 
-    FloatingPanels .status-labels {
-        width: 11;
-        height: auto;
-    }
-
-    FloatingPanels .status-label {
-        height: 1;
-        color: $accent;
-        text-style: bold;
-    }
-
     FloatingPanels .status-scroll {
-        width: 1fr;
-        height: auto;
-        overflow-x: auto;
-        overflow-y: hidden;
+        width: 100%;
+        height: 1fr;
+        overflow-x: hidden;
+        overflow-y: auto;
         scrollbar-size: 0 0;
         scrollbar-visibility: hidden;
     }
 
     FloatingPanels .status-items {
-        width: auto;
+        width: 100%;
         height: auto;
     }
 
-    FloatingPanels .status-row {
-        width: auto;
+    FloatingPanels .status-column {
+        width: 1fr;
+        height: auto;
+    }
+
+    FloatingPanels .status-spacer {
+        width: 1;
         height: 1;
     }
 
     FloatingPanels .status-item {
-        width: auto;
+        width: 100%;
         height: 1;
-        margin: 0 1 0 0;
         color: $accent;
     }
 
@@ -132,27 +125,23 @@ class FloatingPanels(Vertical):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.border_title = "extensions"
+        self.border_title = "agents ───── skills ───── servers"
         self._synced_height = None
         self._synced_column_height = None
         self._command_running = False
 
     def compose(self):
-        with Horizontal(classes="status-body"):
-            with Vertical(classes="status-labels"):
-                yield Static("Subagents:", classes="status-label")
-                yield Static("Skills:", classes="status-label")
-                yield Static("Servers:", classes="status-label")
-            with HorizontalScroll(classes="status-scroll"):
-                with Vertical(classes="status-items"):
-                    yield StatusRow("subagents", id="subagents-row", classes="status-row")
-                    yield StatusRow("skills", id="skills-row", classes="status-row")
-                    yield StatusRow("servers", id="servers-row", classes="status-row")
+        with Vertical(classes="status-body"):
+            with VerticalScroll(classes="status-scroll", id="status-scroll"):
+                with Horizontal(classes="status-items"):
+                    yield StatusColumn("subagents", id="subagents-column", classes="status-column")
+                    yield Static("", classes="status-spacer")
+                    yield StatusColumn("skills", id="skills-column", classes="status-column")
+                    yield Static("", classes="status-spacer")
+                    yield StatusColumn("servers", id="servers-column", classes="status-column")
 
     def on_mount(self):
-        """Start periodic refreshes and use the thin scrollbar renderer."""
-        scroll = self.query_one(".status-scroll", HorizontalScroll)
-        scroll.horizontal_scrollbar.renderer = ThinScrollBarRenderer
+        """Start periodic height sync and data refreshes."""
         self.call_after_refresh(self._sync_height)
         self.set_interval(0.25, self._sync_height)
         self.set_interval(1.0, self.refresh_data)
@@ -161,6 +150,8 @@ class FloatingPanels(Vertical):
     def on_status_item_clicked(self, event: StatusItemClicked):
         """Route an item click to the matching coder command."""
         self._run_coder_command(event.category, event.name, event.active)
+        self._scroll_to_top()
+        self.app.call_after_refresh(self._focus_input)
 
     def _sync_height(self):
         """Match the box height to the input container's current height."""
@@ -201,33 +192,47 @@ class FloatingPanels(Vertical):
             self.refresh_data()
 
     def refresh_data(self):
-        """Refresh the extensions rows from the active coder's state."""
+        """Refresh the extensions columns from the active coder's state."""
         coder = self._get_active_coder()
         if coder is None:
-            self._set_row("#subagents-row", [])
-            self._set_row("#skills-row", [])
-            self._set_row("#servers-row", [])
+            self._set_column("#subagents-column", [])
+            self._set_column("#skills-column", [])
+            self._set_column("#servers-column", [])
             return
 
-        self._set_row("#subagents-row", self._collect_agents())
-        self._set_row("#skills-row", self._collect_skills(coder))
-        self._set_row("#servers-row", self._collect_mcp(coder))
+        self._set_column("#subagents-column", self._collect_agents())
+        self._set_column("#skills-column", self._collect_skills(coder))
+        self._set_column("#servers-column", self._collect_mcp(coder))
+
+    def _focus_input(self):
+        """Return keyboard focus to the prompt input."""
+        try:
+            self.app.query_one("#input").focus()
+        except Exception:
+            pass
+
+    def _scroll_to_top(self):
+        """Return the shared list to the top after an item click."""
+        try:
+            self.query_one("#status-scroll", VerticalScroll).scroll_to(y=0, animate=False)
+        except Exception:
+            pass
 
-    def _set_row(self, selector, entries):
-        """Replace one row's clickable items, skipping unchanged data."""
+    def _set_column(self, selector, entries):
+        """Replace one column's clickable items, skipping unchanged data."""
         try:
-            row = self.query_one(selector, StatusRow)
+            column = self.query_one(selector, StatusColumn)
         except Exception:
             return
 
         ordered = sorted(entries, key=lambda item: (not item[1], item[0].lower()))
         items = [(self._format_name(name), name, active) for name, active in ordered]
         signature = tuple(items)
-        if signature == getattr(row, "_last_signature", None):
+        if signature == getattr(column, "_last_signature", None):
             return
 
-        row._last_signature = signature
-        row.items = items
+        column._last_signature = signature
+        column.items = items
 
     def _run_coder_command(self, category, name, active):
         """Schedule the click's coder command on the worker loop."""

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.10.0rc1
+Version: 1.10.0rc2
 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-1.10.0rc2/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.10.0rc2",
+  "distance": 0,
+  "node": "g9073df907b89aabe4ca56ed6b69ae7125dc32e1c",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-20"
+}

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/tests/subagents/test_service.py

@@ -1025,6 +1025,39 @@ class TestAgentInheritPrefixes:
         assert merged["skip_cli_confirmations"] is True
         assert merged["allow_nested_delegation"] is True  # defaulted
 
+    @pytest.mark.asyncio
+    async def test_wf_servers_allowlist_forces_local(self, service):
+        """A wf: servers allowlist always keeps the Local server available."""
+        service.coder.agent_config = {}
+        self._register(
+            "wf:demo",
+            {"servers_includelist": ["GitLab"], "skip_cli_confirmations": True},
+        )
+
+        merged = await self._create(service, "wf:demo")
+
+        assert merged["servers_includelist"] == ["gitlab", "local"]
+
+    @pytest.mark.asyncio
+    async def test_wf_without_allowlist_does_not_force_local(self, service):
+        """Only an explicit allowlist gets the Local server added."""
+        service.coder.agent_config = {}
+        self._register("wf:demo", {"skip_cli_confirmations": True})
+
+        merged = await self._create(service, "wf:demo")
+
+        assert "servers_includelist" not in merged
+
+    @pytest.mark.asyncio
+    async def test_ws_servers_allowlist_does_not_force_local(self, service):
+        """Local is forced for wf: agents only, not for other inherit-prefix agents."""
+        service.coder.agent_config = {}
+        self._register("ws:app", {"servers_includelist": ["github"]})
+
+        merged = await self._create(service, "ws:app")
+
+        assert merged["servers_includelist"] == ["github"]
+
     @pytest.mark.asyncio
     async def test_wf_respects_explicit_optout(self, service):
         """wf: uses setdefault, so an explicit False in the config survives."""
@@ -1160,3 +1193,29 @@ class TestCrossLoopLocks:
         assert "c1" in order
         assert "c2" in order
         assert "holder-released" in order
+
+
+class TestStartGenerateTaskSwitch:
+    """A mid-turn command signal rebuilds the sub-agent coder in place."""
+
+    @pytest.mark.asyncio
+    async def test_switch_signal_switches_sub_agent_instead_of_escaping(self, service):
+        from cecli.signals import SwitchCoderSignal
+
+        coder = MagicMock()
+        coder.uuid = "sub-uuid"
+
+        async def raise_switch(**kwargs):
+            raise SwitchCoderSignal(edit_format="subagent")
+
+        coder.generate = AsyncMock(side_effect=raise_switch)
+        info = SubAgentInfo(name="wf:demo", coder=coder, parent_uuid="parent-uuid")
+        info.detached = True
+        service.switch_sub_agent_coder = AsyncMock()
+
+        task = service.start_generate_task(info, "/load-mcp github")
+        await task
+
+        service.switch_sub_agent_coder.assert_awaited_once()
+        assert service.switch_sub_agent_coder.call_args.args[0] is info
+        assert info.status == SubAgentStatus.FINISHED

{cecli_dev-1.10.0rc1 → cecli_dev-1.10.0rc2}/tests/tui/test_floating_panels.py

@@ -4,16 +4,15 @@ from unittest.mock import patch
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
-from textual.containers import Horizontal, HorizontalScroll, Vertical
-from textual.widgets import Static
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.widgets import Input, Static
 
 from cecli.tui.widgets.floating_panels import (
     FloatingPanels,
+    StatusColumn,
     StatusItem,
     StatusItemClicked,
-    StatusRow,
 )
-from cecli.tui.widgets.thin_scrollbar import ThinScrollBarRenderer
 
 
 class FakeSkill:
@@ -65,7 +64,8 @@ class _PanelApp(App):
     def compose(self) -> ComposeResult:
         with Horizontal(id="input-row"):
             with Vertical(id="input-column"):
-                yield Static("input", id="input-container")
+                with Vertical(id="input-container"):
+                    yield Input(id="input")
                 yield Static("hints", id="key-hints")
             with Vertical(id="extensions-column"):
                 yield FloatingPanels(id="floating-panels")
@@ -75,9 +75,9 @@ class _PanelApp(App):
         self.query_one(FloatingPanels).toggle_visible()
 
 
-def _row_text(panels: FloatingPanels, row_id: str) -> str:
-    row = panels.query_one(f"#{row_id}", StatusRow)
-    return " ".join(str(item.render()) for item in row.query(StatusItem))
+def _column_text(panels: FloatingPanels, column_id: str) -> str:
+    column = panels.query_one(f"#{column_id}", StatusColumn)
+    return " ".join(str(item.render()) for item in column.query(StatusItem))
 
 
 async def _run_panel_checks():
@@ -87,6 +87,7 @@ async def _run_panel_checks():
         input_container = app.query_one("#input-container")
         extensions_column = app.query_one("#extensions-column")
         input_column = app.query_one("#input-column")
+        input_area = app.query_one("#input", Input)
         panels.refresh_data()
         await pilot.pause()
         await asyncio.sleep(0.1)
@@ -94,28 +95,42 @@ async def _run_panel_checks():
 
         visible_input_width = input_container.region.width
 
-        assert panels.border_title == "extensions"
+        assert panels.border_title == "agents ───── skills ───── servers"
         assert panels.region.x >= input_container.region.right
         assert panels.region.bottom == input_container.region.bottom
         assert panels.region.height == input_container.region.height
 
-        labels = [str(label.render()) for label in panels.query(".status-label")]
-        assert labels == ["Subagents:", "Skills:", "Servers:"]
+        columns = list(panels.query(".status-column"))
+        assert len(columns) == 3
+        column_widths = [column.region.width for column in columns]
+        assert len(set(column_widths)) == 1
+        assert columns[0].region.x < columns[1].region.x < columns[2].region.x
+        assert columns[1].region.x - columns[0].region.right == 1
+        assert columns[2].region.x - columns[1].region.right == 1
+        assert len({column.region.y for column in columns}) == 1
 
-        assert _row_text(panels, "subagents-row") == "● worker ○ tester"
-        assert _row_text(panels, "skills-row") == "● pdf ○ docx ○ spark"
-        assert _row_text(panels, "servers-row") == "● local ○ github"
+        assert _column_text(panels, "subagents-column") == "● worker ○ tester"
+        assert _column_text(panels, "skills-column") == "● pdf ○ docx ○ spark"
+        assert _column_text(panels, "servers-column") == "● local ○ github"
+
+        long_name = "a-very-long-skill-name-that-keeps-going"
+        formatted = FloatingPanels._format_name(long_name)
+        assert len(formatted) == FloatingPanels.MAX_NAME_WIDTH
+        assert formatted.endswith("…")
 
         captured = []
         panels._run_coder_command = lambda category, name, active: captured.append(
             (category, name, active)
         )
-        skill_items = list(panels.query_one("#skills-row", StatusRow).query(StatusItem))
+        skill_items = list(panels.query_one("#skills-column", StatusColumn).query(StatusItem))
+        input_area.blur()
+        await pilot.pause()
         await pilot.click(skill_items[0])
         await pilot.pause()
         await pilot.click(skill_items[1])
         await pilot.pause()
         assert captured == [("skills", "pdf", True), ("skills", "docx", False)]
+        assert app.focused is input_area
 
         panels.on_status_item_clicked(StatusItemClicked("subagents", "worker", False))
         panels.on_status_item_clicked(StatusItemClicked("servers", "github", False))
@@ -130,22 +145,31 @@ async def _run_panel_checks():
         assert panels._command_class("servers", True).__name__ == "RemoveMcpCommand"
         assert panels._command_class("servers", False).__name__ == "LoadMcpCommand"
 
-        panels._set_row("#skills-row", [("z", True), ("a", True), ("b", False)])
+        panels._collect_skills = lambda coder: [("z", True), ("a", True), ("b", False)]
+        panels.refresh_data()
         await pilot.pause()
-        assert _row_text(panels, "skills-row") == "● a ● z ○ b"
+        assert _column_text(panels, "skills-column") == "● a ● z ○ b"
 
-        panels._set_row("#skills-row", [(f"skill-{i}", True) for i in range(20)])
+        panels._collect_skills = lambda coder: [(f"skill-{i}", True) for i in range(20)]
+        panels.refresh_data()
         await pilot.pause()
         await asyncio.sleep(0.1)
         await pilot.pause()
 
-        scroll = panels.query_one(".status-scroll", HorizontalScroll)
-        assert scroll.max_scroll_x > 0
+        scroll = panels.query_one("#status-scroll", VerticalScroll)
+        assert scroll.max_scroll_y > 0
         assert scroll.styles.scrollbar_visibility == "hidden"
-        assert scroll.horizontal_scrollbar.renderer is ThinScrollBarRenderer
-        assert "skill-19" in _row_text(panels, "skills-row")
+        assert "skill-19" in _column_text(panels, "skills-column")
         assert panels.region.height == input_container.region.height
 
+        scroll.scroll_to(y=5, animate=False)
+        await pilot.pause()
+        assert scroll.scroll_y > 0
+
+        panels.on_status_item_clicked(StatusItemClicked("skills", "skill-19", True))
+        await pilot.pause()
+        assert scroll.scroll_y == 0
+
         input_container.styles.height = 8
         await pilot.pause()
         await asyncio.sleep(0.35)

cecli_dev-1.10.0rc1/cecli_dev.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.10.0rc1",
-  "distance": 0,
-  "node": "gd9504b4c3ed862416ec8f124a6512e8f6718b5b4",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-19"
-}