claudechic 0.2.2__py3-none-any.whl → 0.3.1__py3-none-any.whl

claudechic/app.py

@@ -30,7 +30,6 @@ from claude_agent_sdk import (
     ResultMessage,
 )
 from claudechic.messages import (
-    StreamChunk,
     ResponseComplete,
     SystemNotification,
     ToolUseMessage,
@@ -48,6 +47,8 @@ from claudechic.features.worktree.commands import on_response_complete_finish
 from claudechic.permissions import PermissionRequest, PermissionResponse
 from claudechic.agent import Agent, ImageAttachment, ToolUse
 from claudechic.agent_manager import AgentManager
+from claudechic.analytics import capture
+from claudechic.config import get_theme, set_theme, is_new_install
 from claudechic.enums import AgentStatus, PermissionChoice, ToolName
 from claudechic.mcp import set_app, create_chic_server
 from claudechic.file_index import FileIndex
@@ -61,21 +62,23 @@ from claudechic.widgets import (
     AgentToolWidget,
     TodoWidget,
     TodoPanel,
+    ProcessPanel,
     SelectionPrompt,
     QuestionPrompt,
     SessionItem,
     TextAreaAutoComplete,
     HistorySearch,
-    AgentSidebar,
+    AgentSection,
     AgentItem,
     WorktreeItem,
     ChatView,
-    PlanButton,
+    PlanItem,
+    PlanSection,
     HamburgerButton,
     EditPlanRequested,
 )
-from claudechic.widgets.footer import AutoEditLabel, ModelLabel, StatusFooter
-from claudechic.widgets.model_prompt import ModelPrompt
+from claudechic.widgets.layout.footer import AutoEditLabel, ModelLabel, StatusFooter
+from claudechic.widgets.prompts import ModelPrompt
 from claudechic.errors import setup_logging  # noqa: F401 - used at startup
 from claudechic.profiling import profile
 from claudechic.sampling import start_sampler
@@ -125,7 +128,6 @@ class ChatApp(App):
             "shift+tab", "cycle_permission_mode", "Auto-edit", priority=True, show=False
         ),
         Binding("escape", "escape", "Cancel", show=False),
-        Binding("ctrl+n", "new_agent", "New Agent", priority=True, show=False),
         Binding("ctrl+r", "history_search", "History", priority=True, show=False),
         # Agent switching: ctrl+1 through ctrl+9
         *[
@@ -148,23 +150,32 @@ class ChatApp(App):
     CENTERED_SIDEBAR_WIDTH = 140  # Above this, center chat while showing sidebar
 
     def __init__(
-        self, resume_session_id: str | None = None, initial_prompt: str | None = None
+        self,
+        resume_session_id: str | None = None,
+        initial_prompt: str | None = None,
+        remote_port: int = 0,
     ) -> None:
         super().__init__()
+        self.scroll_sensitivity_y = 1.0  # Smoother scrolling (default is 2.0)
         # AgentManager is the single source of truth for agents
         self.agent_mgr: AgentManager | None = None
 
         self._resume_on_start = resume_session_id
         self._initial_prompt = initial_prompt
+        self._remote_port = remote_port
         self._session_picker_active = False
         # Event queues for testing
         self.interactions: asyncio.Queue[PermissionRequest] = asyncio.Queue()
         self.completions: asyncio.Queue[ResponseComplete] = asyncio.Queue()
+        # Permission UI serialization - only show one prompt at a time
+        self._permission_lock = asyncio.Lock()
         # File index for fuzzy file search
         self.file_index: FileIndex | None = None
         # Cached widget references (initialized lazily)
-        self._agent_sidebar: AgentSidebar | None = None
+        self._agent_section: AgentSection | None = None
+        self._plan_section: PlanSection | None = None
         self._todo_panel: TodoPanel | None = None
+        self._process_panel: ProcessPanel | None = None
         self._context_bar: ContextBar | None = None
         self._right_sidebar: Vertical | None = None
         self._input_container: Vertical | None = None
@@ -174,14 +185,15 @@ class ChatApp(App):
         self._shell_process: asyncio.subprocess.Process | None = None
         # Agent-to-UI mappings (Agent has no UI references)
         self._chat_views: dict[str, ChatView] = {}  # agent_id -> ChatView
+        self._agent_metadata: dict[
+            str, dict
+        ] = {}  # agent_id -> {created_at, same_directory}
         self._active_prompts: dict[
             str, Any
         ] = {}  # agent_id -> SelectionPrompt/QuestionPrompt
         # Sidebar overlay state (for narrow screens)
         self._sidebar_overlay_open = False
         self._hamburger_btn: HamburgerButton | None = None
-        # Selected model (None = SDK default)
-        self.selected_model: str | None = None
         # Available models from SDK (populated in _update_slash_commands)
         self._available_models: list[dict] = []
 
@@ -255,10 +267,16 @@ class ChatApp(App):
 
     # Cached widget accessors (lazy init on first access)
     @property
-    def agent_sidebar(self) -> AgentSidebar:
-        if self._agent_sidebar is None:
-            self._agent_sidebar = self.query_one("#agent-sidebar", AgentSidebar)
-        return self._agent_sidebar
+    def agent_section(self) -> AgentSection:
+        if self._agent_section is None:
+            self._agent_section = self.query_one("#agent-section", AgentSection)
+        return self._agent_section
+
+    @property
+    def plan_section(self) -> PlanSection:
+        if self._plan_section is None:
+            self._plan_section = self.query_one("#plan-section", PlanSection)
+        return self._plan_section
 
     @property
     def todo_panel(self) -> TodoPanel:
@@ -266,6 +284,12 @@ class ChatApp(App):
             self._todo_panel = self.query_one("#todo-panel", TodoPanel)
         return self._todo_panel
 
+    @property
+    def process_panel(self) -> ProcessPanel:
+        if self._process_panel is None:
+            self._process_panel = self.query_one("#process-panel", ProcessPanel)
+        return self._process_panel
+
     @property
     def context_bar(self) -> ContextBar:
         if self._context_bar is None:
@@ -311,7 +335,7 @@ class ChatApp(App):
             return
         agent.status = status
         try:
-            self.agent_sidebar.update_status(agent.id, status)
+            self.agent_section.update_status(agent.id, status)
         except Exception:
             pass  # Sidebar not mounted yet
 
@@ -434,7 +458,9 @@ class ChatApp(App):
         "/compactish",
         "/usage",
         "/model",
+        "/processes",
         "/welcome",
+        "/help",
     ]
 
     def compose(self) -> ComposeResult:
@@ -443,8 +469,10 @@ class ChatApp(App):
             yield ListView(id="session-picker", classes="hidden")
             yield ChatView(id="chat-view")
             with Vertical(id="right-sidebar", classes="hidden"):
-                yield AgentSidebar(id="agent-sidebar")
+                yield AgentSection(id="agent-section")
+                yield PlanSection(id="plan-section", classes="hidden")
                 yield TodoPanel(id="todo-panel")
+                yield ProcessPanel(id="process-panel", classes="hidden")
         with Horizontal(id="input-wrapper"):
             with Vertical(id="input-container"):
                 yield ImageAttachments(id="image-attachments", classes="hidden")
@@ -468,6 +496,7 @@ class ChatApp(App):
         cwd: Path | None = None,
         resume: str | None = None,
         agent_name: str | None = None,
+        model: str | None = None,
     ) -> ClaudeAgentOptions:
         """Create SDK options with common settings.
 
@@ -480,22 +509,37 @@ class ChatApp(App):
             setting_sources=["user", "project", "local"],
             cwd=cwd,
             resume=resume,
-            model=self.selected_model,
+            model=model,
             mcp_servers={"chic": create_chic_server(caller_name=agent_name)},
             include_partial_messages=True,
             stderr=self._handle_sdk_stderr,
         )
 
     async def on_mount(self) -> None:
+        # Track app start (and install if new user)
+        self._app_start_time = time.time()
+        if is_new_install():
+            self.run_worker(capture("app_installed"))
+        self.run_worker(capture("app_started", resumed=bool(self._resume_on_start)))
+
         # Start CPU sampling profiler
         start_sampler()
 
+        # Start background process polling
+        self.set_interval(2.0, self._poll_background_processes)
+
         # Register app for MCP tools
         set_app(self)
 
-        # Register and activate custom theme
+        # Start remote control server if requested
+        if self._remote_port:
+            from claudechic.remote import start_server
+
+            await start_server(self, self._remote_port)
+
+        # Register and activate custom theme (use saved preference or default to chic)
         self.register_theme(CHIC_THEME)
-        self.theme = "chic"
+        self.theme = get_theme() or "chic"
 
         # Initialize AgentManager (new architecture)
         self.agent_mgr = AgentManager(self._make_options)
@@ -518,6 +562,10 @@ class ChatApp(App):
         # Connect SDK in background - UI renders while this happens
         self._connect_initial_client()
 
+    def watch_theme(self, theme: str) -> None:
+        """Save theme preference when changed."""
+        set_theme(theme)
+
     @work(exclusive=True, group="connect")
     async def _connect_initial_client(self) -> None:
         """Connect SDK for the initial agent."""
@@ -537,7 +585,7 @@ class ChatApp(App):
 
         # Connect the agent to SDK
         options = self._make_options(
-            cwd=agent.cwd, resume=resume, agent_name=agent.name
+            cwd=agent.cwd, resume=resume, agent_name=agent.name, model=agent.model
         )
         try:
             await agent.connect(options, resume=resume)
@@ -575,27 +623,9 @@ class ChatApp(App):
                 models = info["models"]
                 if isinstance(models, list) and models:
                     self._available_models = models
-                    # Find active model - either user-selected or SDK default
-                    active = models[0]
-                    for m in models:
-                        # If user selected a model, find it
-                        if (
-                            self.selected_model
-                            and m.get("value") == self.selected_model
-                        ):
-                            active = m
-                            break
-                        # Otherwise use the one marked 'default' by SDK
-                        if m.get("value") == "default":
-                            active = m
-                    # Extract short name from description like "Opus 4.5 · ..."
-                    desc = active.get("description", "")
-                    model_name = (
-                        desc.split("·")[0].strip()
-                        if "·" in desc
-                        else active.get("displayName", "")
-                    )
-                    self.status_footer.model = model_name
+                    # Update footer with current agent's model
+                    agent = self._agent
+                    self._update_footer_model(agent.model if agent else None)
         except Exception as e:
             log.warning(f"Failed to fetch SDK commands: {e}")
         self.refresh_context()
@@ -606,6 +636,15 @@ class ChatApp(App):
         if self.file_index:
             await self.file_index.refresh()
 
+    def _poll_background_processes(self) -> None:
+        """Poll for background processes and update the panel and footer."""
+        agent = self._agent
+        if not agent:
+            return
+        processes = agent.get_background_processes()
+        self.process_panel.update_processes(processes)
+        self.status_footer.update_processes(processes)
+
     async def _load_and_display_history(
         self, session_id: str, cwd: Path | None = None
     ) -> None:
@@ -619,7 +658,7 @@ class ChatApp(App):
 
         # Set session_id and load history
         agent.session_id = session_id
-        await agent.load_history(limit=50, cwd=cwd)
+        await agent.load_history(cwd=cwd)
 
         # Re-render ChatView from Agent.messages
         chat_view = self._chat_views.get(agent.id)
@@ -726,14 +765,6 @@ class ChatApp(App):
         except Exception:
             pass  # OK to fail during shutdown
 
-    @profile
-    def on_stream_chunk(self, event: StreamChunk) -> None:
-        chat_view = self._get_chat_view(event.agent_id)
-        if not chat_view:
-            return
-
-        chat_view.append_text(event.text, event.new_message, event.parent_tool_use_id)
-
     @profile
     def on_tool_use_message(self, event: ToolUseMessage) -> None:
         agent = self._get_agent(event.agent_id)
@@ -741,21 +772,6 @@ class ChatApp(App):
         if not agent or not chat_view:
             return
 
-        # TodoWrite gets special handling - update sidebar panel and/or inline widget
-        if event.block.name == "TodoWrite":
-            todos = event.block.input.get("todos", [])
-            agent.todos = todos  # Store on agent for switching
-            self.todo_panel.update_todos(todos)
-            self._position_right_sidebar()
-            # Also update inline widget if exists, or create if narrow
-            existing = self.query(TodoWidget)
-            if existing:
-                existing[0].update_todos(todos)
-            elif self.size.width < self.SIDEBAR_MIN_WIDTH:
-                chat_view.mount(TodoWidget(todos))
-            self._show_thinking(event.agent_id)
-            return
-
         # Create ToolUse data object for ChatView
         tool = ToolUse(
             id=event.block.id, name=event.block.name, input=event.block.input
@@ -850,7 +866,7 @@ class ChatApp(App):
         # Show sidebar when wide enough and we have multiple agents, worktrees, or todos
         agent_count = len(self.agent_mgr) if self.agent_mgr else 0
         has_content = (
-            agent_count > 1 or self.agent_sidebar._worktrees or self.todo_panel.todos
+            agent_count > 1 or self.agent_section._worktrees or self.todo_panel.todos
         )
         width = self.size.width
         main = self.query_one("#main", Horizontal)
@@ -949,7 +965,7 @@ class ChatApp(App):
 
         # Use custom widget for context reports
         if "## Context Usage" in event.content:
-            from claudechic.widgets.context_report import ContextReport
+            from claudechic.widgets.reports.context import ContextReport
 
             widget = ContextReport(event.content)
         else:
@@ -1080,15 +1096,19 @@ class ChatApp(App):
 
     async def _cleanup_and_exit(self) -> None:
         """Disconnect all agents and exit."""
+        # Track app close with session duration
+        duration = time.time() - getattr(self, "_app_start_time", time.time())
+        await capture("app_closed", duration_seconds=int(duration))
+
         for agent in self.agents.values():
             if agent.client:
                 try:
-                    await agent.client.interrupt()
+                    # disconnect() terminates the subprocess and waits for it to finish,
+                    # allowing it to flush session files before we exit
+                    await agent.client.disconnect()
                 except Exception:
                     pass  # Best-effort cleanup during shutdown
                 agent.client = None
-        # Brief delay to let SDK hooks complete before stream closes
-        await asyncio.sleep(0.1)
         # Suppress SDK stderr noise during exit (stream closed errors)
         sys.stderr = open(os.devnull, "w")
         self.exit()
@@ -1099,7 +1119,7 @@ class ChatApp(App):
         """Run a shell command async with PTY for color support."""
         from claudechic.shell_runner import run_in_pty
         from claudechic.widgets import ShellOutputWidget
-        from claudechic.widgets.chat import Spinner
+        from claudechic.widgets.content.message import Spinner
 
         chat_view = self._chat_view
         if not chat_view:
@@ -1166,8 +1186,8 @@ class ChatApp(App):
         picker = self.query_one("#session-picker", ListView)
         picker.clear()
         sessions = await get_recent_sessions(search=search)
-        for session_id, preview, _, msg_count in sessions:
-            picker.append(SessionItem(session_id, preview, msg_count))
+        for session_id, title, mtime, msg_count in sessions:
+            picker.append(SessionItem(session_id, title, mtime, msg_count))
         # Select first item and focus for keyboard nav
         if sessions:
             self.call_after_refresh(
@@ -1195,7 +1215,12 @@ class ChatApp(App):
             resume_id = sessions[0][0] if sessions else None
 
             await self._replace_client(
-                self._make_options(cwd=new_cwd, resume=resume_id, agent_name=agent.name)
+                self._make_options(
+                    cwd=new_cwd,
+                    resume=resume_id,
+                    agent_name=agent.name,
+                    model=agent.model,
+                )
             )
 
             # Clear ChatView state
@@ -1222,7 +1247,7 @@ class ChatApp(App):
         agent.plan_path = plan_path
         # Update sidebar if this is still the active agent
         if self._agent and self._agent.id == agent.id:
-            self.agent_sidebar.set_plan(plan_path)
+            self.plan_section.set_plan(plan_path)
 
     def action_escape(self) -> None:
         """Handle Escape: cancel picker, dismiss prompts, close overlay, or interrupt agent."""
@@ -1288,22 +1313,26 @@ class ChatApp(App):
             event.branch, event.path, worktree=event.branch, auto_resume=True
         )
 
-    def on_plan_button_clicked(self, event: PlanButton.Clicked) -> None:
-        """Handle plan button click - open plan file in editor."""
+    def on_plan_item_plan_requested(self, event: PlanItem.PlanRequested) -> None:
+        """Handle plan item click - open plan file in editor."""
         editor = os.environ.get("EDITOR", "vi")
         handle_command(self, f"/shell -i {editor} {event.plan_path}")
 
-    def on_hamburger_button_clicked(self, event: HamburgerButton.Clicked) -> None:
-        """Handle hamburger button click - toggle sidebar overlay."""
+    def on_hamburger_button_sidebar_toggled(
+        self, event: HamburgerButton.SidebarToggled
+    ) -> None:
+        """Handle hamburger button press - toggle sidebar overlay."""
         self._sidebar_overlay_open = not self._sidebar_overlay_open
         self._position_right_sidebar()
 
     def on_auto_edit_label_toggled(self, event: AutoEditLabel.Toggled) -> None:
-        """Handle auto-edit label click - toggle auto-edit mode."""
+        """Handle auto-edit label press - toggle auto-edit mode."""
         self.action_cycle_permission_mode()
 
-    def on_model_label_clicked(self, event: ModelLabel.Clicked) -> None:
-        """Handle model label click - open model selector."""
+    def on_model_label_model_change_requested(
+        self, event: ModelLabel.ModelChangeRequested
+    ) -> None:
+        """Handle model label press - open model selector."""
         self._handle_model_prompt()
 
     def _close_sidebar_overlay(self) -> None:
@@ -1343,7 +1372,7 @@ class ChatApp(App):
                 continue  # Skip main worktree
             if wt.branch in agent_names:
                 continue  # Already have an agent
-            self.agent_sidebar.add_worktree(wt.branch, wt.path)
+            self.agent_section.add_worktree(wt.branch, wt.path)
 
     def on_agent_item_close_requested(self, event: AgentItem.CloseRequested) -> None:
         """Handle close button click on agent item."""
@@ -1357,52 +1386,58 @@ class ChatApp(App):
         if agent_id not in self.agents:
             return
         old_agent = self._agent
-        # Save current input and hide old agent's UI
-        if old_agent:
-            old_agent.pending_input = self.chat_input.text
-            old_chat_view = self._chat_views.get(old_agent.id)
-            if old_chat_view:
-                old_chat_view.add_class("hidden")
-            old_prompt = self._active_prompts.get(old_agent.id)
-            if old_prompt:
-                old_prompt.add_class("hidden")
-        # Switch active agent (setter syncs to AgentManager)
-        self.active_agent_id = agent_id
-        agent = self._agent
-        chat_view = self._chat_views.get(agent_id)
-        if chat_view:
-            chat_view.remove_class("hidden")
-        # Restore new agent's input
-        if agent:
-            self.chat_input.text = agent.pending_input
-        # Show new agent's prompt if it has one, otherwise show input
-        active_prompt = self._active_prompts.get(agent_id)
-        if active_prompt:
-            active_prompt.remove_class("hidden")
-            self.input_container.add_class("hidden")
-        else:
-            self.input_container.remove_class("hidden")
-        # Update sidebar selection
-        self.agent_sidebar.set_active(agent_id)
-        # Update footer branch for new agent's cwd (async, non-blocking)
+
+        # Batch all class changes to trigger single CSS recalculation
+        with self.batch_update():
+            # Save current input and hide old agent's UI
+            if old_agent:
+                old_agent.pending_input = self.chat_input.text
+                old_chat_view = self._chat_views.get(old_agent.id)
+                if old_chat_view:
+                    old_chat_view.add_class("hidden")
+                old_prompt = self._active_prompts.get(old_agent.id)
+                if old_prompt:
+                    old_prompt.add_class("hidden")
+            # Switch active agent (setter syncs to AgentManager)
+            self.active_agent_id = agent_id
+            agent = self._agent
+            chat_view = self._chat_views.get(agent_id)
+            if chat_view:
+                chat_view.remove_class("hidden")
+            # Restore new agent's input
+            if agent:
+                self.chat_input.text = agent.pending_input
+            # Show new agent's prompt if it has one, otherwise show input
+            active_prompt = self._active_prompts.get(agent_id)
+            if active_prompt:
+                active_prompt.remove_class("hidden")
+                self.input_container.add_class("hidden")
+            else:
+                self.input_container.remove_class("hidden")
+            # Update sidebar selection
+            self.agent_section.set_active(agent_id)
+            # Update footer
+            self.status_footer.auto_edit = agent.auto_approve_edits if agent else False
+            self._update_footer_model(agent.model if agent else None)
+            # Update todo panel for new agent
+            self.todo_panel.update_todos(agent.todos if agent else [])
+            # Update context bar for new agent
+            self.refresh_context()
+            # Update plan button for new agent (use cached plan_path)
+            self.plan_section.set_plan(agent.plan_path if agent else None)
+            self._position_right_sidebar()
+
+        # These happen outside batch (async/focus)
         asyncio.create_task(
             self.status_footer.refresh_branch(str(agent.cwd) if agent else None)
         )
-        self.status_footer.auto_edit = agent.auto_approve_edits if agent else False
-        # Update todo panel for new agent
-        self.todo_panel.update_todos(agent.todos if agent else [])
-        # Update context bar for new agent
-        self.refresh_context()
-        # Update plan button for new agent (use cached plan_path)
-        self.agent_sidebar.set_plan(agent.plan_path if agent else None)
-        self._position_right_sidebar()
         self.chat_input.focus()
 
     async def _reconnect_agent(self, agent: "Agent", session_id: str) -> None:
         """Disconnect and reconnect an agent to reload its session."""
         await agent.disconnect()
         options = self._make_options(
-            cwd=agent.cwd, resume=session_id, agent_name=agent.name
+            cwd=agent.cwd, resume=session_id, agent_name=agent.name, model=agent.model
         )
         await agent.connect(options, resume=session_id)
 
@@ -1416,7 +1451,9 @@ class ChatApp(App):
         if chat_view:
             chat_view.clear()
         await agent.disconnect()
-        options = self._make_options(cwd=agent.cwd, agent_name=agent.name)
+        options = self._make_options(
+            cwd=agent.cwd, agent_name=agent.name, model=agent.model
+        )
         await agent.connect(options)
         self.refresh_context()
         self.notify("New session started")
@@ -1425,7 +1462,7 @@ class ChatApp(App):
     async def _handle_usage_command(self) -> None:
         """Handle /usage command - show API usage limits."""
         from claudechic.usage import fetch_usage
-        from claudechic.widgets.usage import UsageReport
+        from claudechic.widgets.reports.usage import UsageReport
 
         chat_view = self._chat_view
         if not chat_view:
@@ -1436,16 +1473,40 @@ class ChatApp(App):
         chat_view.mount(widget)
         chat_view.scroll_if_tailing()
 
+    @work(group="model_switch", exclusive=True, exit_on_error=False)
+    async def _set_agent_model(self, model: str) -> None:
+        """Set model for active agent and reconnect."""
+        agent = self._agent
+        if not agent:
+            self.notify("No active agent", severity="warning")
+            return
+        if model == agent.model:
+            return
+        agent.model = model
+        self._update_footer_model(model)
+        if agent.client:
+            self.notify(f"Switching to {model}...")
+            await agent.disconnect()
+            options = self._make_options(
+                cwd=agent.cwd, agent_name=agent.name, model=model
+            )
+            await agent.connect(options)
+
     @work(group="model_prompt", exclusive=True, exit_on_error=False)
     async def _handle_model_prompt(self) -> None:
-        """Show model selection prompt and handle result."""
+        """Show model selection prompt and handle result for active agent."""
         from textual.containers import Center
 
+        agent = self._agent
+        if not agent:
+            self.notify("No active agent", severity="warning")
+            return
+
         if not self._available_models:
             self.notify("No models available", severity="warning")
             return
 
-        prompt = ModelPrompt(self._available_models, current_value=self.selected_model)
+        prompt = ModelPrompt(self._available_models, current_value=agent.model)
         container = Center(prompt, id="model-modal")
         self.mount(container)
 
@@ -1454,17 +1515,8 @@ class ChatApp(App):
         finally:
             container.remove()
 
-        if result and result != self.selected_model:
-            self.selected_model = result
-            # Reconnect active agent with new model
-            agent = self._agent
-            if agent and agent.client:
-                self.notify(f"Switching to {result}...")
-                await agent.disconnect()
-                options = self._make_options(cwd=agent.cwd, agent_name=agent.name)
-                await agent.connect(options)
-                # Refresh model display
-                await self._update_slash_commands()
+        if result and result != agent.model:
+            self._set_agent_model(result)
 
     @work(group="new_agent", exclusive=True, exit_on_error=False)
     async def _create_new_agent(
@@ -1474,6 +1526,7 @@ class ChatApp(App):
         worktree: str | None = None,
         auto_resume: bool = False,
         switch_to: bool = True,
+        model: str | None = None,
     ) -> None:
         """Create a new agent via AgentManager.
 
@@ -1483,6 +1536,7 @@ class ChatApp(App):
             worktree: Git worktree branch name if applicable
             auto_resume: Try to resume session with most messages in cwd
             switch_to: Whether to switch to the new agent (default True)
+            model: Model override (None = SDK default)
         """
         if self.agent_mgr is None:
             self.notify("Agent manager not initialized", severity="error")
@@ -1505,6 +1559,7 @@ class ChatApp(App):
                 worktree=worktree,
                 resume=resume_id,
                 switch_to=switch_to,
+                model=model,
             )
         except Exception as e:
             self.show_error(f"Failed to create agent '{name}'", e)
@@ -1636,6 +1691,14 @@ class ChatApp(App):
         """Handle new agent creation from AgentManager."""
         log.info(f"New agent created: {agent.name} (id={agent.id})")
 
+        # Track analytics (same_directory = agent cwd matches app starting cwd)
+        same_directory = agent.cwd == Path.cwd()
+        self._agent_metadata[agent.id] = {
+            "created_at": time.time(),
+            "same_directory": same_directory,
+        }
+        self.run_worker(capture("agent_created", same_directory=same_directory))
+
         try:
             # Create chat view for the agent
             is_first_agent = len(self.agent_mgr.agents) == 1 if self.agent_mgr else True
@@ -1648,7 +1711,8 @@ class ChatApp(App):
             else:
                 # Additional agents get new chat views
                 chat_view = ChatView(
-                    id=f"chat-view-{agent.id}", classes="chat-view hidden"
+                    id=f"chat-view-{agent.id.replace('/', '-')}",
+                    classes="chat-view hidden",
                 )
                 main = self.query_one("#main", Horizontal)
                 main.mount(chat_view, after=self.query_one("#session-picker"))
@@ -1659,7 +1723,7 @@ class ChatApp(App):
 
             # Add to sidebar
             try:
-                self.agent_sidebar.add_agent(agent.id, agent.name)
+                self.agent_section.add_agent(agent.id, agent.name)
             except Exception:
                 log.debug(f"Sidebar not mounted for agent {agent.id}")
 
@@ -1685,24 +1749,39 @@ class ChatApp(App):
 
         # Update sidebar
         try:
-            self.agent_sidebar.set_active(new_agent.id)
+            self.agent_section.set_active(new_agent.id)
         except Exception:
             pass
 
         # Update footer
         self._update_footer_auto_edit()
         self._update_footer_cwd(new_agent.cwd)
+        self._update_footer_model(new_agent.model)
 
         # Update todo panel
         self.todo_panel.update_todos(new_agent.todos)
         self.refresh_context()
         self._position_right_sidebar()
 
-    def on_agent_closed(self, agent_id: str) -> None:
+    def on_agent_closed(self, agent_id: str, message_count: int = 0) -> None:
         """Handle agent closure from AgentManager."""
         log.info(f"Agent closed: {agent_id}")
+
+        # Track analytics
+        metadata = self._agent_metadata.pop(agent_id, {})
+        duration = time.time() - metadata.get("created_at", time.time())
+        same_directory = metadata.get("same_directory", True)
+        self.run_worker(
+            capture(
+                "agent_closed",
+                duration_seconds=int(duration),
+                same_directory=same_directory,
+                message_count=message_count,
+            )
+        )
+
         try:
-            self.agent_sidebar.remove_agent(agent_id)
+            self.agent_section.remove_agent(agent_id)
         except Exception:
             pass
         self._position_right_sidebar()
@@ -1710,7 +1789,7 @@ class ChatApp(App):
     def on_status_changed(self, agent: Agent) -> None:
         """Handle agent status change."""
         try:
-            self.agent_sidebar.update_status(agent.id, agent.status)
+            self.agent_section.update_status(agent.id, agent.status)
             # Update hamburger color if any agent needs attention
             self._update_hamburger_attention()
         except Exception:
@@ -1764,23 +1843,21 @@ class ChatApp(App):
     def on_todos_updated(self, agent: Agent) -> None:
         """Handle agent todos update."""
         if self.agent_mgr and agent.id == self.agent_mgr.active_id:
-            try:
-                self.todo_panel.update_todos(agent.todos)
-            except Exception:
-                pass
+            self.todo_panel.update_todos(agent.todos)
+            self._position_right_sidebar()
+            # Add inline widget to chat stream
+            chat_view = self._get_chat_view(agent.id)
+            if chat_view:
+                chat_view.mount(TodoWidget(agent.todos))
+                chat_view.scroll_if_tailing()
 
     def on_text_chunk(
         self, agent: Agent, text: str, new_message: bool, parent_tool_use_id: str | None
     ) -> None:
-        """Handle text chunk from agent - post Textual Message for UI."""
-        self.post_message(
-            StreamChunk(
-                text,
-                new_message=new_message,
-                parent_tool_use_id=parent_tool_use_id,
-                agent_id=agent.id,
-            )
-        )
+        """Handle text chunk from agent - update UI directly (bypasses message queue)."""
+        chat_view = self._chat_views.get(agent.id)
+        if chat_view:
+            chat_view.append_text(text, new_message, parent_tool_use_id)
 
     def on_tool_use(self, agent: Agent, tool: ToolUse) -> None:
         """Handle tool use from agent - post Textual Message for UI."""
@@ -1833,15 +1910,25 @@ class ChatApp(App):
 
         This is called by Agent when it needs user input for a permission.
         Returns a PermissionResponse with choice and optional alternative message.
+
+        Uses a lock to serialize permission prompts - only one shown at a time.
         """
         # Put in interactions queue for testing
         await self.interactions.put(request)
 
-        # Wait until this agent is active before showing prompt (multi-agent only)
-        if len(self.agents) > 1:
-            while agent.id != self.active_agent_id:
-                await asyncio.sleep(0.1)
+        # Serialize permission prompts - acquire lock before showing UI
+        async with self._permission_lock:
+            # Wait until this agent is active before showing prompt (multi-agent only)
+            if len(self.agents) > 1:
+                while agent.id != self.active_agent_id:
+                    await asyncio.sleep(0.1)
 
+            return await self._show_permission_prompt(agent, request)
+
+    async def _show_permission_prompt(
+        self, agent: Agent, request: PermissionRequest
+    ) -> PermissionResponse:
+        """Show the permission prompt UI (called under _permission_lock)."""
         if request.tool_name == ToolName.ASK_USER_QUESTION:
             # Handle question prompts
             questions = request.tool_input.get("questions", [])
@@ -1910,3 +1997,25 @@ class ChatApp(App):
             asyncio.create_task(self.status_footer.refresh_branch(str(cwd)))
         except Exception:
             pass
+
+    def _update_footer_model(self, model: str | None) -> None:
+        """Update footer to show agent's model."""
+        if not self._available_models:
+            # No model info yet - show raw value or empty
+            self.status_footer.model = model.capitalize() if model else ""
+            return
+        # Find matching model, or default if model is None
+        active = self._available_models[0]
+        for m in self._available_models:
+            if model and m.get("value") == model:
+                active = m
+                break
+            if not model and m.get("value") == "default":
+                active = m
+                break
+        # Extract short name from description like "Opus 4.5 · ..."
+        desc = active.get("description", "")
+        model_name = (
+            desc.split("·")[0].strip() if "·" in desc else active.get("displayName", "")
+        )
+        self.status_footer.model = model_name