abstractassistant 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

abstractassistant/ui/qt_bubble.py

@@ -10,10 +10,19 @@ import time
 import json
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Callable, List, Dict
+from typing import Optional, Callable, List, Dict, Any
 
 # Import AbstractVoice-compatible TTS manager (required dependency)
-from ..core.tts_manager import VoiceManager
+from ..core.agent_host import AgentHost
+
+try:
+    # Optional dependency (installed via `abstractassistant[full]`).
+    from ..core.tts_manager import VoiceManager  # type: ignore
+
+    TTS_AVAILABLE = True
+except Exception:
+    VoiceManager = None  # type: ignore[assignment]
+    TTS_AVAILABLE = False
 
 # Import our new manager classes (required dependencies)
 from .provider_manager import ProviderManager
@@ -21,17 +30,17 @@ from .ui_styles import UIStyles
 from .tts_state_manager import TTSStateManager, TTSState
 from .history_dialog import iPhoneMessagesDialog
 
-# Since these are required dependencies, set availability to True
-TTS_AVAILABLE = True
+# Provider/model managers are package-local.
 MANAGERS_AVAILABLE = True
 
 try:
     from PyQt5.QtWidgets import (
         QApplication, QWidget, QVBoxLayout, QHBoxLayout,
         QTextEdit, QPushButton, QComboBox, QLabel, QFrame,
-        QFileDialog, QMessageBox
+        QFileDialog, QMessageBox, QInputDialog, QCheckBox, QDialog, QMenu,
+        QLineEdit, QScrollArea, QSizePolicy, QButtonGroup
     )
-    from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QThread, pyqtSlot, QRect, QMetaObject
+    from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QThread, pyqtSlot, QRect, QMetaObject, QEvent
     from PyQt5.QtGui import QFont, QPalette, QColor, QPainter, QPen, QBrush
     from PyQt5.QtCore import QPoint
     QT_AVAILABLE = "PyQt5"
@@ -40,9 +49,10 @@ except ImportError:
         from PySide2.QtWidgets import (
             QApplication, QWidget, QVBoxLayout, QHBoxLayout,
             QTextEdit, QPushButton, QComboBox, QLabel, QFrame,
-            QFileDialog, QMessageBox
+            QFileDialog, QMessageBox, QInputDialog, QCheckBox, QDialog, QMenu,
+            QLineEdit, QScrollArea, QSizePolicy, QButtonGroup
         )
-        from PySide2.QtCore import Qt, QTimer, Signal as pyqtSignal, QThread, Slot as pyqtSlot, QMetaObject
+        from PySide2.QtCore import Qt, QTimer, Signal as pyqtSignal, QThread, Slot as pyqtSlot, QMetaObject, QEvent
         from PySide2.QtGui import QFont, QPalette, QColor, QPainter, QPen, QBrush
         from PySide2.QtCore import QPoint
         QT_AVAILABLE = "PySide2"
@@ -51,9 +61,10 @@ except ImportError:
             from PyQt6.QtWidgets import (
                 QApplication, QWidget, QVBoxLayout, QHBoxLayout,
                 QTextEdit, QPushButton, QComboBox, QLabel, QFrame,
-                QFileDialog, QMessageBox
+                QFileDialog, QMessageBox, QInputDialog, QCheckBox, QDialog, QMenu,
+                QLineEdit, QScrollArea, QSizePolicy, QButtonGroup
             )
-            from PyQt6.QtCore import Qt, QTimer, pyqtSignal, QThread, pyqtSlot
+            from PyQt6.QtCore import Qt, QTimer, pyqtSignal, QThread, pyqtSlot, QEvent
             from PyQt6.QtGui import QFont, QPalette, QColor, QPainter, QPen, QBrush
             from PyQt6.QtCore import QPoint
             QT_AVAILABLE = "PyQt6"
@@ -125,17 +136,27 @@ class TTSToggle(QPushButton):
 
     def _update_appearance(self):
         """Update button appearance based on user's toggle state ONLY."""
+        palette = QApplication.instance().palette() if QApplication.instance() else self.palette()
+        is_dark = palette.window().color().lightness() < 128
+        accent = palette.highlight().color()
+
+        def rgba(color: QColor, alpha: float) -> str:
+            return f"rgba({color.red()}, {color.green()}, {color.blue()}, {alpha})"
+
+        overlay_bg = "rgba(255, 255, 255, 0.06)" if is_dark else "rgba(0, 0, 0, 0.06)"
+        overlay_hover = "rgba(255, 255, 255, 0.12)" if is_dark else "rgba(0, 0, 0, 0.10)"
+        overlay_pressed = "rgba(255, 255, 255, 0.06)" if is_dark else "rgba(0, 0, 0, 0.04)"
+        overlay_fg = "rgba(255, 255, 255, 0.7)" if is_dark else "rgba(0, 0, 0, 0.65)"
+
         # SIMPLE USER CONTROL - only shows enabled/disabled state
         if self._enabled:
-            # User has enabled TTS
             icon = "🔉"  # Speaker icon when enabled
-            bg_color = "rgba(0, 102, 204, 0.8)"  # Blue
+            bg_color = rgba(accent, 0.85)
             text_color = "#ffffff"
         else:
-            # User has disabled TTS
             icon = "🔇"  # Muted speaker when disabled
-            bg_color = "rgba(255, 255, 255, 0.06)"
-            text_color = "rgba(255, 255, 255, 0.7)"
+            bg_color = overlay_bg
+            text_color = overlay_fg
 
         self.setText(icon)
         self.setStyleSheet(f"""
@@ -149,10 +170,10 @@ class TTSToggle(QPushButton):
                 font-weight: 600;
             }}
             QPushButton:hover {{
-                background: rgba(0, 122, 255, 0.8);
+                background: {rgba(accent, 0.9) if self._enabled else overlay_hover};
             }}
             QPushButton:pressed {{
-                background: rgba(0, 122, 255, 0.6);
+                background: {rgba(accent, 0.75) if self._enabled else overlay_pressed};
             }}
         """)
 
@@ -192,17 +213,30 @@ class FullVoiceToggle(QPushButton):
 
     def _update_appearance(self):
         """Update button appearance based on user's toggle state ONLY."""
+        palette = QApplication.instance().palette() if QApplication.instance() else self.palette()
+        is_dark = palette.window().color().lightness() < 128
+        accent = palette.highlight().color()
+
+        def rgba(color: QColor, alpha: float) -> str:
+            return f"rgba({color.red()}, {color.green()}, {color.blue()}, {alpha})"
+
+        overlay_bg = "rgba(255, 255, 255, 0.06)" if is_dark else "rgba(0, 0, 0, 0.06)"
+        overlay_hover = "rgba(255, 255, 255, 0.12)" if is_dark else "rgba(0, 0, 0, 0.10)"
+        overlay_pressed = "rgba(255, 255, 255, 0.06)" if is_dark else "rgba(0, 0, 0, 0.04)"
+        overlay_fg = "rgba(255, 255, 255, 0.7)" if is_dark else "rgba(0, 0, 0, 0.65)"
+
         # SIMPLE USER CONTROL - only shows enabled/disabled state
         if self._enabled:
-            # User has enabled Full Voice Mode
             icon = "🎙️"  # Microphone when enabled
-            bg_color = "rgba(0, 122, 204, 0.8)"  # Blue
+            bg_color = rgba(accent, 0.85)
             text_color = "#ffffff"
         else:
-            # User has disabled Full Voice Mode
-            icon = "🎤"  # Muted microphone when disabled
-            bg_color = "rgba(255, 255, 255, 0.06)"
-            text_color = "rgba(255, 255, 255, 0.7)"
+            # Show an explicit "mic off" glyph by default (struck mic),
+            # because the app starts in non-listening mode until the user enables Full Voice Mode.
+            # Using a combining overlay is the most portable way to get a clear strike without custom painting.
+            icon = "🎙️\u20E0"  # "no" overlay (combining enclosing circle backslash)
+            bg_color = overlay_bg
+            text_color = overlay_fg
 
         self.setText(icon)
         self.setStyleSheet(f"""
@@ -216,29 +250,461 @@ class FullVoiceToggle(QPushButton):
                 font-weight: 600;
             }}
             QPushButton:hover {{
-                background: {bg_color.replace('0.8', '1.0') if '0.8' in bg_color else bg_color};
+                background: {rgba(accent, 0.9) if self._enabled else overlay_hover};
             }}
             QPushButton:pressed {{
-                background: {bg_color.replace('0.8', '0.6') if '0.8' in bg_color else bg_color};
+                background: {rgba(accent, 0.75) if self._enabled else overlay_pressed};
             }}
         """)
 
 
 
 
+class ToolSelectorDialog(QDialog):
+    """Tool allowlist editor (All tools vs Custom allowlist)."""
+
+    def __init__(
+        self,
+        *,
+        parent: Optional[QWidget] = None,
+        tools: List[Dict[str, str]],
+        enabled: set[str],
+        safe_preset: set[str],
+        require_approval: set[str],
+    ):
+        super().__init__(parent)
+        self.setWindowTitle("Tools")
+        self.setModal(True)
+
+        self._tools = [t for t in list(tools) if isinstance(t, dict)]
+        self._safe_preset = set(safe_preset)
+        self._require_approval = set(require_approval)
+
+        # Keep the tool order stable.
+        self._all_names = [
+            str(t.get("name") or "").strip()
+            for t in self._tools
+            if isinstance(t.get("name"), str) and str(t.get("name") or "").strip()
+        ]
+        self._all_names_set = set(self._all_names)
+
+        self._mode: str = "all" if set(enabled) == self._all_names_set else "custom"
+        self._custom_selected: set[str] = set(enabled)
+        if self._mode == "all":
+            self._custom_selected = set(self._all_names_set)
+
+        palette = QApplication.instance().palette() if QApplication.instance() else self.palette()
+        is_dark = palette.window().color().lightness() < 128
+        window_bg = palette.window().color().name()
+        base_bg = palette.base().color().name()
+        mid = palette.mid().color()
+        mid_hex = mid.name()
+        text = palette.text().color()
+        accent = palette.highlight().color()
+
+        def rgba(color: QColor, alpha: float) -> str:
+            return f"rgba({color.red()}, {color.green()}, {color.blue()}, {alpha})"
+
+        overlay = "rgba(255, 255, 255, 0.08)" if is_dark else "rgba(0, 0, 0, 0.06)"
+        overlay_hover = "rgba(255, 255, 255, 0.12)" if is_dark else "rgba(0, 0, 0, 0.10)"
+        overlay_pressed = "rgba(255, 255, 255, 0.06)" if is_dark else "rgba(0, 0, 0, 0.04)"
+        text_primary = rgba(text, 0.92)
+        text_secondary = rgba(text, 0.70)
+        text_muted = rgba(text, 0.55 if is_dark else 0.50)
+        accent_hex = accent.name()
+        accent_hover = accent.lighter(115).name()
+        accent_pressed = accent.darker(115).name()
+        accent_border = rgba(accent, 0.28)
+        danger = QColor(255, 59, 48)
+        danger_border = rgba(danger, 0.45)
+        tool_name_color = "#22c55e" if is_dark else "#16a34a"
+        indicator_border = rgba(text, 0.38 if is_dark else 0.30)
+
+        self._suppress_checkbox_updates: bool = False
+
+        self.setStyleSheet(
+            f"""
+            QDialog {{
+                background: {window_bg};
+                color: {text_primary};
+            }}
+            """
+        )
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(18, 18, 18, 18)
+        layout.setSpacing(12)
+
+        header = QLabel("TOOLS")
+        header.setStyleSheet(
+            f"""
+            QLabel {{
+                color: {accent_hex};
+                font-size: 11px;
+                font-weight: 700;
+            }}
+            """
+        )
+        layout.addWidget(header)
+
+        subtitle = QLabel("Default is all tools. Switch to a custom allowlist only when needed.")
+        subtitle.setWordWrap(True)
+        subtitle.setStyleSheet(f"QLabel {{ font-size: 12px; color: {text_secondary}; }}")
+        layout.addWidget(subtitle)
+
+        controls_row = QHBoxLayout()
+        controls_row.setSpacing(10)
+
+        seg_frame = QFrame()
+        seg_frame.setStyleSheet(
+            f"""
+            QFrame {{
+                background: {overlay_pressed};
+                border: 1px solid {mid_hex};
+                border-radius: 14px;
+            }}
+            """
+        )
+        seg_layout = QHBoxLayout(seg_frame)
+        seg_layout.setContentsMargins(2, 2, 2, 2)
+        seg_layout.setSpacing(2)
+
+        self.all_mode_btn = QPushButton("All tools")
+        self.custom_mode_btn = QPushButton("Custom allowlist")
+        for b in (self.all_mode_btn, self.custom_mode_btn):
+            b.setCheckable(True)
+            try:
+                b.setAutoExclusive(True)
+            except Exception:
+                pass
+            b.setFixedHeight(28)
+            b.setStyleSheet(
+                f"""
+                QPushButton {{
+                    background: transparent;
+                    border: none;
+                    border-radius: 12px;
+                    padding: 0 12px;
+                    font-size: 12px;
+                    font-weight: 600;
+                    color: {text_secondary};
+                }}
+                QPushButton:hover {{ background: {overlay_hover}; color: {text_primary}; }}
+                QPushButton:checked {{ background: {base_bg}; color: {text_primary}; }}
+                """
+            )
+        self.all_mode_btn.setChecked(self._mode == "all")
+        self.custom_mode_btn.setChecked(self._mode == "custom")
+
+        seg_layout.addWidget(self.all_mode_btn)
+        seg_layout.addWidget(self.custom_mode_btn)
+        controls_row.addWidget(seg_frame)
+
+        self.count_pill = QLabel("")
+        self.count_pill.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.count_pill.setFixedHeight(28)
+        self.count_pill.setMinimumWidth(160)
+        self.count_pill.setStyleSheet(
+            f"""
+            QLabel {{
+                background: {overlay};
+                border: 1px solid {mid_hex};
+                border-radius: 14px;
+                font-size: 11px;
+                font-weight: 600;
+                color: {text_secondary};
+                padding: 0 12px;
+            }}
+            """
+        )
+        controls_row.addWidget(self.count_pill)
+        controls_row.addStretch()
+        layout.addLayout(controls_row)
+
+        self.filter_input = QLineEdit()
+        self.filter_input.setPlaceholderText("Filter tools…")
+        self.filter_input.setClearButtonEnabled(True)
+        self.filter_input.setFixedHeight(34)
+        self.filter_input.setStyleSheet(
+            f"""
+            QLineEdit {{
+                background: {overlay_pressed};
+                border: 1px solid {mid_hex};
+                border-radius: 10px;
+                padding: 0 12px;
+                font-size: 12px;
+                color: {text_primary};
+            }}
+            QLineEdit:focus {{
+                border: 1px solid {accent_hex};
+                background: {overlay_hover};
+            }}
+            """
+        )
+        layout.addWidget(self.filter_input)
+
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        scroll.setFrameShape(QFrame.Shape.NoFrame)
+        scroll.setStyleSheet("QScrollArea { background: transparent; }")
+        layout.addWidget(scroll, 1)
+
+        list_root = QWidget()
+        list_layout = QVBoxLayout(list_root)
+        list_layout.setContentsMargins(0, 0, 0, 0)
+        list_layout.setSpacing(10)
+        scroll.setWidget(list_root)
+
+        self._rows: Dict[str, Dict[str, Any]] = {}
+
+        def _badge(text_value: str, *, fg: str, bg: str, border: str) -> QLabel:
+            lab = QLabel(text_value)
+            lab.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            lab.setFixedHeight(18)
+            lab.setStyleSheet(
+                f"""
+                QLabel {{
+                    color: {fg};
+                    background: {bg};
+                    border: 1px solid {border};
+                    border-radius: 9px;
+                    padding: 0 8px;
+                    font-size: 10px;
+                    font-weight: 700;
+                }}
+                """
+            )
+            return lab
+
+        def _current_selected() -> set[str]:
+            return {n for n, info in self._rows.items() if info["checkbox"].isChecked()}
+
+        def _on_checkbox_changed(_: str) -> None:
+            if getattr(self, "_suppress_checkbox_updates", False):
+                return
+
+            selected = _current_selected()
+
+            # In "All tools" mode, any manual uncheck means the user is starting
+            # a custom allowlist. Flip to custom and keep current selection.
+            if self._mode == "all" and selected != self._all_names_set:
+                self._custom_selected = set(selected)
+                _set_mode("custom")
+                return
+
+            if self._mode == "custom":
+                self._custom_selected = set(selected)
+
+            self._update_counts()
+
+        for info in self._tools:
+            name = str(info.get("name") or "").strip()
+            if not name:
+                continue
+            desc = str(info.get("description") or "").strip()
+
+            row = QFrame()
+            row.setObjectName("toolRow")
+            row_layout = QHBoxLayout(row)
+            row_layout.setContentsMargins(12, 10, 12, 10)
+            row_layout.setSpacing(10)
+
+            cb = QCheckBox()
+            cb.setChecked(name in self._custom_selected)
+            cb.setStyleSheet(
+                f"""
+                QCheckBox {{ color: {text_primary}; }}
+                QCheckBox::indicator {{
+                    width: 18px;
+                    height: 18px;
+                    border-radius: 4px;
+                    border: 1px solid {indicator_border};
+                    background: {overlay};
+                }}
+                QCheckBox::indicator:hover {{
+                    background: {overlay_hover};
+                    border: 1px solid {accent_hex};
+                }}
+                QCheckBox::indicator:checked {{
+                    background: {accent_hex};
+                    border: 1px solid {accent_hover};
+                }}
+                QCheckBox::indicator:checked:hover {{
+                    background: {accent_hover};
+                    border: 1px solid {accent_hover};
+                }}
+                """
+            )
+            cb.stateChanged.connect(lambda _=0, n=name: _on_checkbox_changed(n))
+            row_layout.addWidget(cb, 0, Qt.AlignmentFlag.AlignTop)
+
+            text_col = QWidget()
+            text_col_layout = QVBoxLayout(text_col)
+            text_col_layout.setContentsMargins(0, 0, 0, 0)
+            text_col_layout.setSpacing(4)
+
+            meta_row = QHBoxLayout()
+            meta_row.setContentsMargins(0, 0, 0, 0)
+            meta_row.setSpacing(8)
+
+            name_label = QLabel(name.upper())
+            name_label.setStyleSheet(
+                f"""
+                QLabel {{
+                    color: {tool_name_color};
+	                font-size: 12px;
+                    font-weight: 800;
+                    font-family: "SF Mono", "Monaco", "Menlo", "Consolas", monospace;
+                }}
+                """
+            )
+            meta_row.addWidget(name_label)
+
+            if name in self._require_approval:
+                meta_row.addWidget(
+                    _badge("APPROVAL", fg="#ffffff", bg=danger_border, border=danger_border)
+                )
+
+            meta_row.addStretch()
+            text_col_layout.addLayout(meta_row)
+
+            if desc:
+                desc_label = QLabel(desc)
+                desc_label.setWordWrap(True)
+                desc_label.setStyleSheet(f"QLabel {{ color: {text_muted}; font-size: 11px; }}")
+                text_col_layout.addWidget(desc_label)
+
+            row_layout.addWidget(text_col, 1)
+
+            border_color = danger_border if name in self._require_approval else accent_border
+            row.setStyleSheet(
+                f"""
+                QFrame#toolRow {{
+                    background: {overlay_pressed};
+                    border: 1px solid {border_color};
+                    border-radius: 12px;
+                }}
+                """
+            )
+
+            list_layout.addWidget(row)
+            self._rows[name] = {"row": row, "checkbox": cb, "desc": desc}
+
+        list_layout.addStretch(1)
+
+        footer = QHBoxLayout()
+        footer.setSpacing(10)
+        footer.addStretch()
+
+        cancel_btn = QPushButton("Cancel")
+        save_btn = QPushButton("Save")
+        for b in (cancel_btn, save_btn):
+            b.setFixedHeight(34)
+            b.setStyleSheet(
+                f"""
+                QPushButton {{
+                    background: {overlay};
+                    border: 1px solid {mid_hex};
+                    border-radius: 12px;
+                    padding: 0 16px;
+                    font-size: 12px;
+                    font-weight: 700;
+                    color: {text_primary};
+                }}
+                QPushButton:hover {{ background: {overlay_hover}; border: 1px solid {accent_hex}; }}
+                QPushButton:pressed {{ background: {overlay_pressed}; }}
+                """
+            )
+        save_btn.setStyleSheet(
+            f"""
+            QPushButton {{
+                background: {accent_hex};
+                border: 1px solid {accent_hover};
+                border-radius: 12px;
+                padding: 0 16px;
+                font-size: 12px;
+                font-weight: 800;
+                color: #ffffff;
+            }}
+            QPushButton:hover {{ background: {accent_hover}; border: 1px solid {accent_hover}; }}
+            QPushButton:pressed {{ background: {accent_pressed}; }}
+            """
+        )
+
+        cancel_btn.clicked.connect(self.reject)
+        save_btn.clicked.connect(self.accept)
+        footer.addWidget(cancel_btn)
+        footer.addWidget(save_btn)
+        layout.addLayout(footer)
+
+        def _set_mode(mode: str) -> None:
+            mode = "all" if mode == "all" else "custom"
+            self._mode = mode
+            self.all_mode_btn.setChecked(self._mode == "all")
+            self.custom_mode_btn.setChecked(self._mode == "custom")
+            self._suppress_checkbox_updates = True
+            try:
+                if self._mode == "all":
+                    self._custom_selected = set(self._all_names_set)
+                    for _, info in self._rows.items():
+                        info["checkbox"].setEnabled(True)
+                        info["checkbox"].setChecked(True)
+                else:
+                    for n, info in self._rows.items():
+                        info["checkbox"].setEnabled(True)
+                        info["checkbox"].setChecked(n in self._custom_selected)
+            finally:
+                self._suppress_checkbox_updates = False
+
+            self._update_counts()
+
+        self.all_mode_btn.clicked.connect(lambda _=False: _set_mode("all"))
+        self.custom_mode_btn.clicked.connect(lambda _=False: _set_mode("custom"))
+
+        def _apply_filter() -> None:
+            q = (self.filter_input.text() or "").strip().lower()
+            for n, info in self._rows.items():
+                if not q:
+                    info["row"].setVisible(True)
+                    continue
+                hay = f"{n}\n{info.get('desc','')}".lower()
+                info["row"].setVisible(q in hay)
+
+        self.filter_input.textChanged.connect(lambda _=None: _apply_filter())
+
+        self.resize(720, 560)
+        _set_mode(self._mode)
+        _apply_filter()
+        self._update_counts()
+
+    def _update_counts(self) -> None:
+        total = len(self._all_names)
+        if self._mode == "all":
+            selected = total
+        else:
+            selected = len({n for n, info in self._rows.items() if info["checkbox"].isChecked()})
+        self.count_pill.setText(f"✓ {selected} of {total} selected")
+
+    def selected_tools(self) -> List[str]:
+        if self._mode == "all":
+            return list(self._all_names)
+        return sorted([n for n, info in self._rows.items() if info["checkbox"].isChecked()])
+
+
 class LLMWorker(QThread):
     """Worker thread for LLM processing."""
 
     response_ready = pyqtSignal(str)
     error_occurred = pyqtSignal(str)
 
-    def __init__(self, llm_manager, message, provider, model, media=None):
+    def __init__(self, llm_manager, message, provider, model, media=None, debug: bool = False):
         super().__init__()
         self.llm_manager = llm_manager
         self.message = message
         self.provider = provider
         self.model = model
         self.media = media or []
+        self.debug = bool(debug)
 
     def run(self):
         """Run LLM processing in background."""
@@ -264,6 +730,221 @@ class LLMWorker(QThread):
             self.error_occurred.emit(str(e))
 
 
+class AgentWorker(QThread):
+    """Worker thread that drives an AgentHost turn (tick/resume loop)."""
+
+    event_emitted = pyqtSignal(object)  # dict payloads
+    error_occurred = pyqtSignal(str)
+
+    def __init__(
+        self,
+        *,
+        agent_host: AgentHost,
+        user_text: str,
+        provider: str,
+        model: str,
+        attachments: Optional[List[str]] = None,
+        system_prompt_extra: Optional[str] = None,
+        allowed_tools: Optional[List[str]] = None,
+        debug: bool = False,
+    ):
+        super().__init__()
+        self._agent_host = agent_host
+        self._user_text = str(user_text or "")
+        self._provider = str(provider or "")
+        self._model = str(model or "")
+        self._attachments = list(attachments or [])
+        self._system_prompt_extra = str(system_prompt_extra) if system_prompt_extra else None
+        self._allowed_tools = list(allowed_tools) if allowed_tools is not None else None
+        self._debug = bool(debug)
+
+        self._tool_approval_event = threading.Event()
+        self._tool_approval_decision: Optional[bool] = None
+        self._ask_user_event = threading.Event()
+        self._ask_user_response: Optional[str] = None
+
+    def provide_tool_approval(self, approved: bool) -> None:
+        self._tool_approval_decision = bool(approved)
+        self._tool_approval_event.set()
+
+    def provide_user_response(self, response: str) -> None:
+        self._ask_user_response = str(response or "")
+        self._ask_user_event.set()
+
+    def run(self) -> None:
+        try:
+            def _approve(_tool_calls):
+                return bool(self._tool_approval_decision)
+
+            def _ask_user(_wait):
+                return str(self._ask_user_response or "")
+
+            gen = self._agent_host.run_turn(
+                user_text=self._user_text,
+                attachments=self._attachments if self._attachments else None,
+                provider=self._provider,
+                model=self._model,
+                system_prompt_extra=self._system_prompt_extra,
+                allowed_tools=self._allowed_tools,
+                approve_tools=_approve,
+                ask_user=_ask_user,
+            )
+
+            while True:
+                try:
+                    ev = next(gen)
+                except StopIteration:
+                    return
+
+                self.event_emitted.emit(ev)
+
+                typ = ev.get("type") if isinstance(ev, dict) else None
+                if typ == "tool_request":
+                    tool_calls = ev.get("tool_calls")
+                    if isinstance(tool_calls, list) and not self._agent_host.tool_policy.requires_approval(tool_calls):
+                        # Safe/read-only tool batch: auto-approve (no UI prompt required).
+                        self._tool_approval_decision = True
+                        continue
+                    self._tool_approval_decision = None
+                    self._tool_approval_event.clear()
+                    self._tool_approval_event.wait()
+                    if self._tool_approval_decision is None:
+                        self._tool_approval_decision = False
+                    continue
+
+                if typ == "ask_user":
+                    self._ask_user_response = None
+                    self._ask_user_event.clear()
+                    self._ask_user_event.wait()
+                    if self._ask_user_response is None:
+                        self._ask_user_response = ""
+                    continue
+
+        except Exception as e:
+            if self._debug:
+                import traceback
+
+                traceback.print_exc()
+            self.error_occurred.emit(str(e))
+
+
+class _MessageInputRow(QWidget):
+    """
+    Two-column message input row with a strict-square (1:1) 3-button action column.
+
+    Design goals (per UX requirements):
+    - The action buttons fill the *full* vertical space of the input row (up to the card border)
+    - Buttons remain perfectly square while scaling with available height
+    - Exactly 1px vertical spacing between the 3 buttons
+    - The text input ends exactly where the action column begins (two columns)
+    """
+
+    def __init__(
+        self,
+        *,
+        parent: Optional[QWidget] = None,
+        h_spacing_px: int = 2,
+        v_spacing_px: int = 1,
+        min_button_px: int = 22,
+        min_text_width_px: int = 140,
+    ) -> None:
+        super().__init__(parent)
+        self._h_spacing_px = max(0, int(h_spacing_px))
+        self._v_spacing_px = max(0, int(v_spacing_px))
+        self._min_button_px = max(12, int(min_button_px))
+        self._min_text_width_px = max(40, int(min_text_width_px))
+
+        self.input_text = QTextEdit(self)
+        self.attach_button = QPushButton("📎", self)
+        self.tools_button = QPushButton("🛠", self)
+        self.send_button = QPushButton("→", self)
+        self._voice_mode: bool = False
+
+        # Keep focus/navigation sane.
+        for b in (self.attach_button, self.tools_button, self.send_button):
+            try:
+                b.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+            except Exception:
+                pass
+
+    def set_voice_mode(self, enabled: bool) -> None:
+        """
+        In voice mode we keep the action column, but hide the Send button because
+        end-of-sentence detection effectively acts as "send".
+        """
+        enabled = bool(enabled)
+        if self._voice_mode == enabled:
+            return
+        self._voice_mode = enabled
+        try:
+            self.send_button.setVisible(not enabled)
+            self.send_button.setEnabled(not enabled)
+        except Exception:
+            pass
+        self.updateGeometry()
+        self.update()
+
+    def _set_button_font_px(self, px: int) -> None:
+        px = max(10, int(px))
+        try:
+            for b in (self.attach_button, self.tools_button, self.send_button):
+                f = b.font() if hasattr(b, "font") else QFont()
+                try:
+                    f.setPixelSize(px)
+                except Exception:
+                    # Fallback: point size if pixel sizing isn't available.
+                    f.setPointSize(max(9, px // 2))
+                b.setFont(f)
+        except Exception:
+            pass
+
+    def resizeEvent(self, event):
+        try:
+            super().resizeEvent(event)
+        except Exception:
+            pass
+
+        w = int(self.width())
+        h = int(self.height())
+        if w <= 0 or h <= 0:
+            return
+
+        # Compute a square button size that uses as much vertical space as possible.
+        # With N buttons and (N-1) gaps:
+        #   used_h = N*btn + (N-1)*v_spacing  <= h
+        action_buttons = (self.attach_button, self.tools_button) if self._voice_mode else (self.attach_button, self.tools_button, self.send_button)
+        n = max(1, len(action_buttons))
+        btn_from_h = (h - ((n - 1) * self._v_spacing_px)) // n
+        btn = max(self._min_button_px, btn_from_h)
+
+        # Ensure the column also fits horizontally (keep a minimum text width).
+        max_btn_from_w = w - self._min_text_width_px - self._h_spacing_px
+        if max_btn_from_w <= 0:
+            max_btn_from_w = self._min_button_px
+        btn = max(self._min_button_px, min(btn, max_btn_from_w))
+
+        input_w = max(10, w - btn - self._h_spacing_px)
+        col_x = input_w + self._h_spacing_px
+
+        # Place the text input to fill the available height.
+        self.input_text.setGeometry(0, 0, input_w, h)
+
+        # Place the square buttons stacked on the right with strict spacing.
+        # We anchor to the top to keep the tiny leftover (0-2px) at the bottom.
+        used_h = (n * btn) + ((n - 1) * self._v_spacing_px)
+        top = 0
+        if used_h < h:
+            # If there's slack (usually 0-2px), split it so borders look even.
+            top = (h - used_h) // 2
+
+        for i, b in enumerate(action_buttons):
+            y = top + i * (btn + self._v_spacing_px)
+            b.setGeometry(col_x, y, btn, btn)
+
+        # Scale icon glyphs with the square size.
+        self._set_button_font_px(int(btn * 0.55))
+
+
 class QtChatBubble(QWidget):
     """Modern Qt-based chat bubble."""
     
@@ -273,6 +954,7 @@ class QtChatBubble(QWidget):
         self.config = config
         self.debug = debug
         self.listening_mode = listening_mode
+        self._theme: Dict[str, Any] = {}
         
         # State - default to LMStudio with qwen/qwen3-next-80b
         self.current_provider = 'lmstudio'  # Default to LMStudio
@@ -282,6 +964,11 @@ class QtChatBubble(QWidget):
         
         # Message history for session management
         self.message_history: List[Dict] = []
+        self._session_auto_approve_tools: set[str] = set()
+        self._voice_busy: bool = False
+        # Full Voice Mode lifecycle: treat "running" as separate from the toggle state so
+        # late callbacks cannot keep the UI in LISTENING after a user-initiated stop.
+        self._full_voice_running: bool = False
 
         # History dialog instance for toggle behavior
         self.history_dialog = None
@@ -291,6 +978,13 @@ class QtChatBubble(QWidget):
         
         # Track file attachments per message for history display
         self.message_file_attachments: Dict[int, List[str]] = {}
+
+        # Tool selection (external tools): controls the per-run allowlist passed to AbstractAgent.
+        self._available_external_tools: List[Dict[str, str]] = []
+        self._enabled_external_tools: set[str] = set()
+        self._safe_external_tools: set[str] = set()
+        self._require_approval_tools: set[str] = set()
+        self._refresh_tool_inventory()
         
         # Initialize new manager classes
         self.provider_manager = None
@@ -331,6 +1025,19 @@ class QtChatBubble(QWidget):
         self.setup_ui()
         self.setup_styling()
         self.load_providers()
+
+        # Bootstrap UI state from the durable active session (tokens/history).
+        try:
+            if self.llm_manager and hasattr(self.llm_manager, "refresh"):
+                self.llm_manager.refresh()
+        except Exception:
+            pass
+        try:
+            self._update_message_history_from_session()
+            self._update_token_count_from_session()
+            self._reload_session_combo()
+        except Exception:
+            pass
         
         if self.debug:
             print("✅ QtChatBubble initialized")
@@ -356,15 +1063,29 @@ class QtChatBubble(QWidget):
     def setup_ui(self):
         """Set up the modern user interface with SOTA UX practices."""
         self.setWindowTitle("AbstractAssistant")
+        self.setObjectName("AbstractAssistantBubble")
+        try:
+            attr = getattr(Qt, "WA_StyledBackground", None)
+            if attr is None and hasattr(Qt, "WidgetAttribute"):
+                attr = Qt.WidgetAttribute.WA_StyledBackground
+            if attr is not None:
+                self.setAttribute(attr, True)
+        except Exception:
+            pass
         self.setWindowFlags(
             Qt.WindowType.FramelessWindowHint | 
             Qt.WindowType.WindowStaysOnTopHint |
             Qt.WindowType.Tool
         )
+        try:
+            self.setWindowOpacity(0.97)
+        except Exception:
+            pass
         
-        # Set optimal size for modern chat interface - much wider to nearly touch screen edge
+        # Set optimal size for modern chat interface.
+        # Keep the default lightweight and compact: ~15% narrower than the previous 630px.
         # Initial size - will be adjusted dynamically based on file attachments
-        self.base_width = 630
+        self.base_width = 536
         self.base_height = 196
         self.setFixedSize(self.base_width, self.base_height)
         self.position_near_tray()
@@ -399,40 +1120,102 @@ class QtChatBubble(QWidget):
             }
         """)
         header_layout.addWidget(self.close_button)
-        
-        # Session buttons (minimal, rounded)
-        session_buttons = [
-            ("Clear", self.clear_session),
-            ("Load", self.load_session), 
-            ("Save", self.save_session),
-            # ("Compact", self.compact_session),  # Hidden for now - functionality preserved
-            ("History", self.show_history)
-        ]
-        
-        for text, handler in session_buttons:
-            btn = QPushButton(text)
-            btn.setFixedHeight(22)
-            btn.clicked.connect(handler)
-
-            # Store reference to history button for toggle appearance
-            if text == "History":
-                self.history_button = btn
-            btn.setStyleSheet("""
-                QPushButton {
-                    background: rgba(255, 255, 255, 0.06);
-                    border: none;
-                    border-radius: 11px;
-                    font-size: 10px;
-                    color: rgba(255, 255, 255, 0.7);
-                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
-                    padding: 0 10px;
-                }
-                QPushButton:hover {
-                    background: rgba(255, 255, 255, 0.12);
-                    color: rgba(255, 255, 255, 0.9);
-                }
-            """)
-            header_layout.addWidget(btn)
+
+        # Session selector + New session (replaces legacy "Clear" in the header).
+        self.session_combo = QComboBox()
+        self.session_combo.setFixedHeight(22)
+        self.session_combo.setMinimumWidth(160)
+        self.session_combo.setToolTip("Select a session")
+        self.session_combo.setStyleSheet("""
+            QComboBox {
+                background: rgba(255, 255, 255, 0.06);
+                border: none;
+                border-radius: 6px;
+                font-size: 10px;
+                color: rgba(255, 255, 255, 0.8);
+                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                padding: 0 10px;
+            }
+            QComboBox:hover {
+                background: rgba(255, 255, 255, 0.12);
+                color: rgba(255, 255, 255, 0.9);
+            }
+            QComboBox::drop-down {
+                border: none;
+            }
+        """)
+        try:
+            self.session_combo.view().setMinimumWidth(420)
+        except Exception:
+            pass
+        self.session_combo.currentIndexChanged.connect(self._on_session_combo_changed)
+        header_layout.addWidget(self.session_combo)
+
+        self.new_session_button = QPushButton("New")
+        self.new_session_button.setFixedHeight(22)
+        self.new_session_button.setToolTip("Start a new session")
+        self.new_session_button.clicked.connect(self._start_new_session)
+        self.new_session_button.setStyleSheet("""
+            QPushButton {
+                background: rgba(255, 255, 255, 0.06);
+                border: none;
+                border-radius: 6px;
+                font-size: 10px;
+                color: rgba(255, 255, 255, 0.7);
+                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                padding: 0 10px;
+            }
+            QPushButton:hover {
+                background: rgba(255, 255, 255, 0.12);
+                color: rgba(255, 255, 255, 0.9);
+            }
+        """)
+        header_layout.addWidget(self.new_session_button)
+
+        # Overflow menu to reduce header clutter (Load/Save/Debug actions).
+        self.more_button = QPushButton("⋯")
+        self.more_button.setFixedSize(28, 22)
+        self.more_button.setToolTip("More")
+        self.more_button.clicked.connect(self._show_more_menu)
+        self.more_button.setStyleSheet("""
+            QPushButton {
+                background: rgba(255, 255, 255, 0.06);
+                border: none;
+                border-radius: 6px;
+                font-size: 14px;
+                color: rgba(255, 255, 255, 0.7);
+                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                padding: 0px;
+            }
+            QPushButton:hover {
+                background: rgba(255, 255, 255, 0.12);
+                color: rgba(255, 255, 255, 0.9);
+            }
+        """)
+        header_layout.addWidget(self.more_button)
+
+        # Messages/history button (user-facing transcript).
+        self.history_button = QPushButton("💬")
+        self.history_button.setFixedHeight(22)
+        self.history_button.setFixedWidth(28)
+        self.history_button.setToolTip("Messages")
+        self.history_button.clicked.connect(self.show_history)
+        self.history_button.setStyleSheet("""
+            QPushButton {
+                background: rgba(255, 255, 255, 0.06);
+                border: none;
+                border-radius: 11px;
+                font-size: 12px;
+                color: rgba(255, 255, 255, 0.7);
+                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                padding: 0px;
+            }
+            QPushButton:hover {
+                background: rgba(255, 255, 255, 0.12);
+                color: rgba(255, 255, 255, 0.9);
+            }
+        """)
+        header_layout.addWidget(self.history_button)
         
         # TTS toggle (if available)
         if self.voice_manager and self.voice_manager.is_available():
@@ -453,7 +1236,9 @@ class QtChatBubble(QWidget):
         
         # Status (Cursor-style, enlarged to show full text including "Processing")
         self.status_label = QLabel("READY")
-        self.status_label.setFixedSize(120, 24)  # Increased from 80x24 to 120x24 for "Processing" text
+        self.status_label.setFixedHeight(24)
+        self.status_label.setMinimumWidth(92)
+        self.status_label.setMaximumWidth(120)
         self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.status_label.setStyleSheet("""
             QLabel {
@@ -472,94 +1257,106 @@ class QtChatBubble(QWidget):
         
         # Input section with modern card design
         self.input_container = QFrame()
+        self.input_container.setObjectName("inputContainer")
         self.input_container.setStyleSheet("""
             QFrame {
                 background: #2a2a2a;
                 border: 1px solid #404040;
-                border-radius: 8px;
+                border-radius: 6px;
                 padding: 4px;
             }
         """)
         input_layout = QVBoxLayout(self.input_container)
-        input_layout.setContentsMargins(4, 4, 4, 4)
-        input_layout.setSpacing(4)
-        
-        # Input field with inline send button
-        input_row = QHBoxLayout()
-        input_row.setSpacing(4)
+        # Keep this tight so the right-side action column visually reaches the card border.
+        input_layout.setContentsMargins(2, 2, 2, 2)
+        input_layout.setSpacing(2)
+
+        # Deterministic manual-geometry input row (no layout race on first show).
+        self._input_row = _MessageInputRow(parent=self.input_container, h_spacing_px=2, v_spacing_px=1)
+        self._input_row.setMinimumHeight(86)
+        input_layout.addWidget(self._input_row, 1)
+
+        # Expose the child widgets on the bubble for the rest of the codebase.
+        self.input_text = self._input_row.input_text
+        self.attach_button = self._input_row.attach_button
+        self.tools_button = self._input_row.tools_button
+        self.send_button = self._input_row.send_button
 
-        # File attachment button - modern paperclip icon
-        self.attach_button = QPushButton("📎")
+        self.input_text.setPlaceholderText("Ask me anything... (Shift+Enter to send)")
+        try:
+            self.input_text.installEventFilter(self)
+        except Exception:
+            pass
+
+        # Wiring
         self.attach_button.clicked.connect(self.attach_files)
-        self.attach_button.setFixedSize(36, 36)
         self.attach_button.setToolTip("Attach files (images, PDFs, Office docs, etc.)")
-        self.attach_button.setStyleSheet("""
+        self.tools_button.clicked.connect(self.open_tool_selector)
+        self.tools_button.setToolTip("Tools")
+        self.send_button.clicked.connect(self.send_message)
+
+        # Styling (theme methods will override these too; these are safe defaults for first paint)
+        self.attach_button.setStyleSheet(
+            """
             QPushButton {
                 background: rgba(255, 255, 255, 0.08);
                 border: 1px solid #404040;
-                border-radius: 18px;
-                font-size: 14px;
-                color: rgba(255, 255, 255, 0.7);
-                text-align: center;
+                border-radius: 4px;
+                color: rgba(255, 255, 255, 0.75);
                 padding: 0px;
+                margin: 0px;
             }
-
             QPushButton:hover {
                 background: rgba(255, 255, 255, 0.12);
                 border: 1px solid #0066cc;
-                color: rgba(255, 255, 255, 0.9);
+                color: rgba(255, 255, 255, 0.95);
             }
-
-            QPushButton:pressed {
-                background: rgba(255, 255, 255, 0.06);
-            }
-        """)
-        input_row.addWidget(self.attach_button)
-
-        # Text input - larger, primary focus
-        self.input_text = QTextEdit()
-        self.input_text.setPlaceholderText("Ask me anything... (Shift+Enter to send)")
-        self.input_text.setMaximumHeight(100)  # Increased to better use available space
-        self.input_text.setMinimumHeight(70)   # Increased to better use available space
-        input_row.addWidget(self.input_text)
-
-        # Send button - primary action with special styling
-        self.send_button = QPushButton("→")
-        self.send_button.clicked.connect(self.send_message)
-        self.send_button.setFixedSize(40, 40)
-        self.send_button.setStyleSheet("""
+            QPushButton:pressed { background: rgba(255, 255, 255, 0.06); }
+            """
+        )
+        self.tools_button.setStyleSheet(
+            """
             QPushButton {
-                background: #0066cc;
-                border: 1px solid #0080ff;
-                border-radius: 20px;
-                font-size: 16px;
-                font-weight: bold;
-                color: white;
-                text-align: center;
-                padding: 0px;
-            }
-
+                background: rgba(255, 255, 255, 0.08);
+                border: 1px solid #404040;
+                border-radius: 4px;
+                color: rgba(255, 255, 255, 0.75);
+                padding: 0px;
+                margin: 0px;
+            }
             QPushButton:hover {
-                background: #0080ff;
-                border: 1px solid #0099ff;
+                background: rgba(255, 255, 255, 0.12);
+                border: 1px solid #7c3aed;
+                color: rgba(255, 255, 255, 0.95);
             }
-
-            QPushButton:pressed {
-                background: #0052a3;
+            QPushButton:pressed { background: rgba(255, 255, 255, 0.06); }
+            """
+        )
+        self.send_button.setStyleSheet(
+            """
+            QPushButton {
+                background: #0066cc;
+                border: 1px solid #0080ff;
+                border-radius: 4px;
+                font-weight: 700;
+                color: #ffffff;
+                padding: 0px;
+                margin: 0px;
             }
-
+            QPushButton:hover { background: #0080ff; border: 1px solid #0099ff; }
+            QPushButton:pressed { background: #0052a3; }
             QPushButton:disabled {
                 background: #404040;
                 color: #666666;
                 border: 1px solid #333333;
             }
-        """)
-        input_row.addWidget(self.send_button)
-
-        input_layout.addLayout(input_row)
+            """
+        )
+        self._update_tools_button_state()
 
         # Attached files display area (initially hidden)
         self.attached_files_container = QFrame()
+        self.attached_files_container.setObjectName("attachedFilesContainer")
         self.attached_files_container.setStyleSheet("""
             QFrame {
                 background: rgba(255, 255, 255, 0.04);
@@ -615,6 +1412,7 @@ class QtChatBubble(QWidget):
         self.model_combo.currentTextChanged.connect(self.on_model_changed)
         self.model_combo.setFixedHeight(28)
         self.model_combo.setMinimumWidth(140)
+        self.model_combo.view().setMinimumWidth(380)  # Wider dropdown to show full model names
         self.model_combo.setStyleSheet("""
             QComboBox {
                 background: rgba(255, 255, 255, 0.08);
@@ -674,210 +1472,364 @@ class QtChatBubble(QWidget):
 
         # Enter key handling
         self.input_text.keyPressEvent = self.handle_key_press
-    
-    def setup_styling(self):
-        """Set up Cursor-style clean theme."""
-        self.setStyleSheet("""
-            /* Main Window - Cursor Style */
-            QWidget {
-                background: #1e1e1e;
-                border: none;
+
+        # Populate session selector (durable multi-session).
+        try:
+            self._reload_session_combo(select_session_id=getattr(self.llm_manager, "active_session_id", None))
+        except Exception:
+            pass
+
+    def _compute_theme(self) -> Dict[str, Any]:
+        palette = QApplication.instance().palette() if QApplication.instance() else self.palette()
+        window = palette.window().color()
+        base = palette.base().color()
+        mid = palette.mid().color()
+        text = palette.text().color()
+        accent = palette.highlight().color()
+
+        is_dark = window.lightness() < 128
+
+        def rgba(color: QColor, alpha: float) -> str:
+            return f"rgba({color.red()}, {color.green()}, {color.blue()}, {alpha})"
+
+        overlay = "rgba(255, 255, 255, 0.08)" if is_dark else "rgba(0, 0, 0, 0.06)"
+        overlay_hover = "rgba(255, 255, 255, 0.12)" if is_dark else "rgba(0, 0, 0, 0.10)"
+        overlay_pressed = "rgba(255, 255, 255, 0.06)" if is_dark else "rgba(0, 0, 0, 0.04)"
+
+        focus_bg = base.lighter(112) if is_dark else base.darker(102)
+        accent_hover = accent.lighter(115)
+        accent_pressed = accent.darker(115)
+
+        return {
+            "is_dark": is_dark,
+            "window_bg": window.name(),
+            "surface_bg": base.name(),
+            "surface_focus_bg": focus_bg.name(),
+            "border": mid.name(),
+            "text_primary": rgba(text, 0.9),
+            "text_secondary": rgba(text, 0.72),
+            "text_muted": rgba(text, 0.55 if is_dark else 0.5),
+            "accent": accent.name(),
+            "accent_hover": accent_hover.name(),
+            "accent_pressed": accent_pressed.name(),
+            "accent_rgba_12": rgba(accent, 0.12),
+            "accent_rgba_20": rgba(accent, 0.20),
+            "accent_rgba_35": rgba(accent, 0.35),
+            "overlay": overlay,
+            "overlay_hover": overlay_hover,
+            "overlay_pressed": overlay_pressed,
+        }
+
+    def _apply_theme(self) -> None:
+        t = self._theme or self._compute_theme()
+
+        input_focused = False
+        try:
+            input_focused = bool(getattr(self, "input_text", None) and self.input_text.hasFocus())
+        except Exception:
+            input_focused = False
+        input_border = t["accent"] if input_focused else t["border"]
+
+        # Window
+        self.setStyleSheet(
+            f"""
+            QWidget#AbstractAssistantBubble {{
+                background: {t['window_bg']};
+                border: 1px solid {t['border']};
                 border-radius: 12px;
-                color: #ffffff;
-            }
-            
-            /* Input Field - Modern Grey Design */
-            QTextEdit {
-                background: #2a2a2a;
-                border: 1px solid #404040;
-                border-radius: 8px;
-                padding: 12px 16px;
-                font-size: 14px;
-                font-weight: 400;
-                color: #ffffff;
-                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
-                selection-background-color: #0066cc;
-                line-height: 1.4;
-            }
-            
-            QTextEdit:focus {
-                border: 1px solid #0066cc;
-                background: #333333;
-            }
-            
-            QTextEdit::placeholder {
-                color: rgba(255, 255, 255, 0.6);
-            }
-            
-            /* Buttons - Grey Theme */
-            QPushButton {
-                background: #404040;
-                border: 1px solid #555555;
-                border-radius: 4px;
-                padding: 4px 8px;
-                font-size: 11px;
-                font-weight: 500;
-                color: #ffffff;
-                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
-            }
-            
-            QPushButton:hover {
-                background: #505050;
-                border: 1px solid #0066cc;
-            }
-            
-            QPushButton:pressed {
-                background: #353535;
-            }
-            
-            QPushButton:disabled {
-                background: #2a2a2a;
-                color: #666666;
-                border: 1px solid #333333;
-            }
-            
-            /* Dropdown Menus - Grey Theme */
-                QComboBox {
-                    background: #1e1e1e;
-                    border: 1px solid #404040;
+                color: {t['text_primary']};
+            }}
+            """
+        )
+
+        # Input container + text input
+        if hasattr(self, "input_container"):
+            self.input_container.setStyleSheet(
+                f"""
+                QFrame#inputContainer {{
+                    background: {t['surface_bg']};
+                    border: 1px solid {input_border};
                     border-radius: 6px;
-                    padding: 6px 10px;
-                    min-width: 80px;
-                    font-size: 12px;
+                    padding: 4px;
+                }}
+                """
+            )
+        if hasattr(self, "input_text"):
+            self.input_text.setStyleSheet(
+                f"""
+                QTextEdit {{
+                    background: transparent;
+                    border: none;
+                    padding: 4px 8px;
+                    font-size: 14px;
                     font-weight: 400;
-                    color: #ffffff;
+                    color: {t['text_primary']};
                     font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
-                    letter-spacing: 0.01em;
-                }
-            
-            QComboBox:hover {
-                border: 1px solid #0066cc;
-                background: #252525;
-            }
-            
-            QComboBox::drop-down {
-                border: none;
-                width: 20px;
-            }
-            
-            QComboBox::down-arrow {
-                image: none;
-                border-left: 5px solid transparent;
-                border-right: 5px solid transparent;
-                border-top: 5px solid rgba(255, 255, 255, 0.7);
-                width: 0px;
-                height: 0px;
-            }
-            
-                QComboBox QAbstractItemView {
-                    background: #1a202c;
-                    border: 1px solid #4a5568;
-                    border-radius: 8px;
-                    selection-background-color: #4299e1;
-                    color: #e2e8f0;
-                    padding: 4px;
-                    font-family: "Helvetica Neue", "Helvetica", "Segoe UI", Arial, sans-serif;
-                }
-                
-                QComboBox QAbstractItemView::item {
-                    height: 36px;
-                    padding: 8px 12px;
+                    selection-background-color: {t['accent']};
+                    line-height: 1.4;
+                }}
+
+                QTextEdit:focus {{
+                    background: transparent;
+                }}
+
+                QTextEdit::placeholder {{
+                    color: {t['text_muted']};
+                }}
+                """
+            )
+
+        # Header controls
+        pill_qss = f"""
+            background: {t['overlay_pressed']};
+            border: none;
+            border-radius: 11px;
+            font-size: 10px;
+            color: {t['text_secondary']};
+            font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+            padding: 0 10px;
+        """
+        pill_hover = f"background: {t['overlay_hover']}; color: {t['text_primary']};"
+
+        if hasattr(self, "session_combo"):
+            self.session_combo.setStyleSheet(
+                f"""
+                QComboBox {{ {pill_qss} }}
+                QComboBox:hover {{ {pill_hover} }}
+                QComboBox::drop-down {{ border: none; }}
+                """
+            )
+
+        if hasattr(self, "new_session_button"):
+            self.new_session_button.setStyleSheet(
+                f"""
+                QPushButton {{ {pill_qss} }}
+                QPushButton:hover {{ {pill_hover} }}
+                """
+            )
+
+        if hasattr(self, "more_button"):
+            self.more_button.setStyleSheet(
+                f"""
+                QPushButton {{
+                    background: {t['overlay_pressed']};
                     border: none;
+                    border-radius: 11px;
+                    font-size: 16px;
+                    color: {t['text_secondary']};
+                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                    padding: 0px;
+                }}
+                QPushButton:hover {{
+                    background: {t['overlay_hover']};
+                    color: {t['text_primary']};
+                }}
+                """
+            )
+
+        if hasattr(self, "history_button"):
+            self.history_button.setStyleSheet(
+                f"""
+                QPushButton {{
+                    background: {t['overlay_pressed']};
+                    border: none;
+                    border-radius: 11px;
                     font-size: 12px;
-                    font-weight: 400;  /* Changed from 500 to 400 (normal weight) */
-                    color: #e2e8f0;
-                    border-radius: 4px;
-                    margin: 2px;
-                }
-                
-                QComboBox QAbstractItemView::item:selected {
-                    background: #4299e1;
+                    color: {t['text_secondary']};
+                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                    padding: 0px;
+                }}
+                QPushButton:hover {{
+                    background: {t['overlay_hover']};
+                    color: {t['text_primary']};
+                }}
+                """
+            )
+
+        if hasattr(self, "close_button"):
+            self.close_button.setStyleSheet(
+                f"""
+                QPushButton {{
+                    background: {t['overlay_hover']};
+                    border: none;
+                    border-radius: 12px;
+                    font-size: 14px;
+                    font-weight: 600;
+                    color: {t['text_primary']};
+                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                }}
+                QPushButton:hover {{
+                    background: rgba(255, 60, 60, 0.85);
                     color: #ffffff;
-                }
-                
-                QComboBox QAbstractItemView::item:hover {
-                    background: #374151;
-                }
-            
-            QComboBox QAbstractItemView::item:selected {
-                background: #4299e1;
-            }
-            
-            /* Labels - Clean Typography */
-            QLabel {
-                color: rgba(255, 255, 255, 0.8);
-                font-size: 12px;
-                font-weight: 500;
-                font-family: "Helvetica Neue", "Helvetica", 'Segoe UI', Arial, sans-serif;
-                letter-spacing: 0.3px;
-            }
-            
-            /* Status and Token Labels - Accent Colors */
-            QLabel#status_ready {
-                background: rgba(166, 227, 161, 0.15);
-                border: 1px solid rgba(166, 227, 161, 0.3);
-                border-radius: 12px;
-                padding: 6px 12px;
-                font-size: 10px;
-                font-weight: 600;
-                text-transform: uppercase;
-                letter-spacing: 0.5px;
-                color: #a6e3a1;
-                font-family: "Helvetica Neue", "Helvetica", "Segoe UI", Arial, sans-serif;
-            }
-            
-            QLabel#status_generating {
-                background: rgba(250, 179, 135, 0.15);
-                border: 1px solid rgba(250, 179, 135, 0.3);
-                border-radius: 12px;
-                padding: 6px 12px;
-                font-size: 10px;
-                font-weight: 600;
-                text-transform: uppercase;
-                letter-spacing: 0.5px;
-                color: #fab387;
-                font-family: "Helvetica Neue", "Helvetica", "Segoe UI", Arial, sans-serif;
-            }
-            
-            QLabel#status_error {
-                background: rgba(243, 139, 168, 0.15);
-                border: 1px solid rgba(243, 139, 168, 0.3);
-                border-radius: 12px;
-                padding: 6px 12px;
-                font-size: 10px;
-                font-weight: 600;
-                text-transform: uppercase;
-                letter-spacing: 0.5px;
-                color: #f38ba8;
-                font-family: "Helvetica Neue", "Helvetica", "Segoe UI", Arial, sans-serif;
-            }
-            
-            QLabel#token_label {
-                background: #2d3748;
-                border: 1px solid #4a5568;
-                border-radius: 8px;
-                padding: 10px 12px;
-                font-family: "Helvetica Neue", "Helvetica", "Segoe UI", Arial, sans-serif;
-                font-size: 11px;
-                font-weight: 500;
-                color: #cbd5e0;
-                text-align: center;
-                letter-spacing: 0.025em;
-            }
-            
-            /* Frames - Invisible Containers */
-            QFrame {
-                border: none;
-                background: transparent;
-            }
-            
-            /* Separator Lines */
-            QLabel#separator {
-                color: rgba(255, 255, 255, 0.3);
-                font-size: 14px;
-                font-weight: 300;
-            }
-        """)
+                }}
+                QPushButton:pressed {{
+                    background: rgba(255, 60, 60, 0.65);
+                }}
+                """
+            )
+
+        # Input action buttons (stretch to fill vertical space)
+        icon_btn_qss = f"""
+	            QPushButton {{
+	                background: {t['overlay']};
+	                border: 1px solid {t['border']};
+	                border-radius: 4px;
+	                color: {t['text_secondary']};
+	                text-align: center;
+	                padding: 0px;
+	                margin: 0px;
+	            }}
+            QPushButton:hover {{
+                background: {t['overlay_hover']};
+                border: 1px solid {t['accent']};
+                color: {t['text_primary']};
+            }}
+            QPushButton:pressed {{
+                background: {t['overlay_pressed']};
+            }}
+        """
+        if hasattr(self, "attach_button"):
+            self.attach_button.setStyleSheet(icon_btn_qss)
+
+        # tools_button style is handled via _update_tools_button_state()
+
+        if hasattr(self, "send_button"):
+            self.send_button.setStyleSheet(
+                f"""
+	                QPushButton {{
+	                    background: {t['accent']};
+	                    border: 1px solid {t['accent_hover']};
+	                    border-radius: 4px;
+	                    font-weight: bold;
+	                    color: #ffffff;
+	                    text-align: center;
+	                    padding: 0px;
+	                    margin: 0px;
+	                }}
+                QPushButton:hover {{
+                    background: {t['accent_hover']};
+                    border: 1px solid {t['accent_hover']};
+                }}
+                QPushButton:pressed {{
+                    background: {t['accent_pressed']};
+                }}
+                QPushButton:disabled {{
+                    background: {t['overlay_pressed']};
+                    color: {t['text_muted']};
+                    border: 1px solid {t['border']};
+                }}
+                """
+            )
+
+        # Bottom controls
+        if hasattr(self, "provider_combo"):
+            self.provider_combo.setStyleSheet(
+                f"""
+                QComboBox {{
+                    background: {t['overlay']};
+                    border: none;
+                    border-radius: 14px;
+                    padding: 0 8px;
+                    font-size: 11px;
+                    color: {t['text_primary']};
+                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                }}
+                QComboBox:hover {{ background: {t['overlay_hover']}; }}
+                QComboBox::drop-down {{ border: none; width: 20px; }}
+                QComboBox::down-arrow {{ image: none; border: none; width: 0px; }}
+                """
+            )
+
+        if hasattr(self, "model_combo"):
+            self.model_combo.setStyleSheet(
+                f"""
+                QComboBox {{
+                    background: {t['overlay']};
+                    border: none;
+                    border-radius: 14px;
+                    padding: 0 8px;
+                    font-size: 11px;
+                    color: {t['text_primary']};
+                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                }}
+                QComboBox:hover {{ background: {t['overlay_hover']}; }}
+                QComboBox::drop-down {{ border: none; width: 20px; }}
+                QComboBox::down-arrow {{ image: none; border: none; width: 0px; }}
+                """
+            )
+
+        if hasattr(self, "token_label"):
+            self.token_label.setStyleSheet(
+                f"""
+                QLabel {{
+                    background: {t['overlay_pressed']};
+                    border: none;
+                    border-radius: 14px;
+                    font-size: 12px;
+                    color: {t['text_muted']};
+                    font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+                }}
+                """
+            )
+
+        # Attached files container
+        if hasattr(self, "attached_files_container"):
+            self.attached_files_container.setStyleSheet(
+                f"""
+                QFrame#attachedFilesContainer {{
+                    background: {t['overlay_pressed']};
+                    border: 1px solid {t['border']};
+                    border-radius: 6px;
+                    padding: 4px;
+                }}
+                """
+            )
+
+    def eventFilter(self, obj, event):
+        try:
+            if obj is getattr(self, "input_text", None):
+                etype = event.type()
+                focus_in = getattr(QEvent, "FocusIn", None)
+                focus_out = getattr(QEvent, "FocusOut", None)
+                if focus_in is None and hasattr(QEvent, "Type"):
+                    focus_in = QEvent.Type.FocusIn
+                    focus_out = QEvent.Type.FocusOut
+                if etype in {focus_in, focus_out}:
+                    try:
+                        self._apply_theme()
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+        return super().eventFilter(obj, event)
+
+    def changeEvent(self, event):
+        try:
+            etype = event.type()
+            palette_change = getattr(QEvent, "PaletteChange", None)
+            app_palette_change = getattr(QEvent, "ApplicationPaletteChange", None)
+            if palette_change is None and hasattr(QEvent, "Type"):
+                palette_change = QEvent.Type.PaletteChange
+                app_palette_change = QEvent.Type.ApplicationPaletteChange
+            if etype in {palette_change, app_palette_change}:
+                self._theme = self._compute_theme()
+                self._apply_theme()
+                try:
+                    self._update_tools_button_state()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+        super().changeEvent(event)
+
+    def setup_styling(self):
+        """Apply a system-aware theme (follows OS light/dark)."""
+        self._theme = self._compute_theme()
+        self._apply_theme()
+        try:
+            self._update_tools_button_state()
+        except Exception:
+            pass
     
     def position_near_tray(self):
         """Position the bubble near the system tray."""
@@ -986,7 +1938,7 @@ class QtChatBubble(QWidget):
 
                 # Add models to dropdown with display names
                 for model in models:
-                    display_name = self.provider_manager.create_model_display_name(model, max_length=25)
+                    display_name = self.provider_manager.create_model_display_name(model, max_length=55)
                     self.model_combo.addItem(display_name, model)
 
                 # Set preferred model
@@ -1014,9 +1966,10 @@ class QtChatBubble(QWidget):
                 models = get_available_models_for_provider(self.current_provider)
 
                 for model in models:
-                    display_name = model.split('/')[-1] if '/' in model else model
-                    if len(display_name) > 25:
-                        display_name = display_name[:22] + "..."
+                    # Use full model name (preserving provider prefix)
+                    display_name = model
+                    if len(display_name) > 55:
+                        display_name = display_name[:52] + "..."
                     self.model_combo.addItem(display_name, model)
 
                 if self.model_combo.count() > 0:
@@ -1047,15 +2000,46 @@ class QtChatBubble(QWidget):
     
     def update_token_limits(self):
         """Update token limits using AbstractCore's built-in detection."""
-        # Get token limits from LLMManager (which uses AbstractCore's detection)
-        if self.llm_manager and self.llm_manager.llm:
-            self.max_tokens = self.llm_manager.llm.max_tokens
-            
-            if self.debug:
-                print(f"📊 Token limits from AbstractCore: {self.max_tokens}")
-        else:
-            # Fallback if LLM not initialized
-            self.max_tokens = 128000
+        max_tokens = None
+        source = None
+
+        # Preferred: AbstractCore model capabilities (model_capabilities.json).
+        try:
+            from abstractcore.architectures.detection import get_model_capabilities
+
+            caps = get_model_capabilities(str(self.current_model or ""))
+            mt = caps.get("max_tokens") if isinstance(caps, dict) else None
+            if isinstance(mt, int) and mt > 0:
+                max_tokens = int(mt)
+                source = "abstractcore:model_capabilities"
+        except Exception:
+            max_tokens = None
+
+        # Fallback: provider instance (best-effort; may be lazy/unavailable).
+        if max_tokens is None:
+            try:
+                llm = getattr(self.llm_manager, "llm", None)
+                mt = getattr(llm, "max_tokens", None)
+                if isinstance(mt, int) and mt > 0:
+                    max_tokens = int(mt)
+                    source = "provider"
+            except Exception:
+                max_tokens = None
+
+        # Final fallback: keep UI stable even for unknown models.
+        if max_tokens is None:
+            max_tokens = 128000
+            source = "fallback"
+
+        self.max_tokens = int(max_tokens)
+
+        try:
+            self.token_label.setToolTip(f"Max context: {self.max_tokens} tokens ({source})")
+        except Exception:
+            pass
+
+        if self.debug:
+            print(f"📊 Token limit: {self.max_tokens} ({source})")
             
         self.update_token_display()
     
@@ -1112,6 +2096,142 @@ class QtChatBubble(QWidget):
             print(f"Model changed to: {self.current_model}")
     
 
+    def _refresh_tool_inventory(self) -> None:
+        """Refresh the list of available tools and keep the enabled set consistent."""
+        host = getattr(self.llm_manager, "agent_host", None)
+        tool_infos: List[Dict[str, str]] = []
+        safe: set[str] = set()
+        require: set[str] = set()
+
+        if host is not None:
+            try:
+                policy = getattr(host, "tool_policy", None)
+                safe = set(getattr(policy, "auto_approve_tools", set()) or set())
+                require = set(getattr(policy, "require_approval_tools", set()) or set())
+            except Exception:
+                safe = set()
+                require = set()
+
+            try:
+                for t in getattr(host, "tools", []) or []:
+                    td = getattr(t, "_tool_definition", None)
+                    name = getattr(td, "name", None) or getattr(t, "__name__", None)
+                    if not isinstance(name, str) or not name.strip():
+                        continue
+                    desc = ""
+                    try:
+                        desc = str(getattr(td, "description", "") or "") if td is not None else ""
+                    except Exception:
+                        desc = ""
+                    tool_infos.append({"name": name.strip(), "description": desc.strip()})
+            except Exception:
+                tool_infos = []
+
+        available_names = {info.get("name", "") for info in tool_infos if isinstance(info, dict) and info.get("name")}
+        available_names = {n for n in available_names if isinstance(n, str) and n.strip()}
+
+        safe = set(safe) & set(available_names)
+        require = set(require) & set(available_names)
+
+        def _sort_key(info: Dict[str, str]) -> tuple[int, str]:
+            name = str(info.get("name") or "")
+            if name in safe:
+                return (0, name)
+            if name in require:
+                return (1, name)
+            return (2, name)
+
+        self._available_external_tools = sorted(tool_infos, key=_sort_key)
+        self._safe_external_tools = set(safe)
+        self._require_approval_tools = set(require)
+
+        if not self._enabled_external_tools:
+            self._enabled_external_tools = set(available_names)
+        else:
+            self._enabled_external_tools &= set(available_names)
+
+        self._update_tools_button_state()
+
+    def _update_tools_button_state(self) -> None:
+        """Update the tools button tooltip/style based on current selection."""
+        btn = getattr(self, "tools_button", None)
+        if btn is None:
+            return
+        t = self._theme or self._compute_theme()
+
+        total = len(self._available_external_tools or [])
+        enabled = len(self._enabled_external_tools or set())
+        safe_enabled = len((self._enabled_external_tools or set()) & (self._safe_external_tools or set()))
+        approval_enabled = len((self._enabled_external_tools or set()) & (self._require_approval_tools or set()))
+
+        if total <= 0:
+            btn.setEnabled(False)
+            btn.setToolTip("Tools: none available")
+            return
+
+        btn.setEnabled(True)
+        btn.setToolTip(f"Tools enabled: {enabled}/{total} (safe: {safe_enabled}, approval: {approval_enabled})")
+
+        if enabled == 0:
+            border = t["border"]
+            bg = t["overlay_pressed"]
+            fg = t["text_muted"]
+        elif enabled < total:
+            border = t["accent"]
+            bg = t["accent_rgba_12"]
+            fg = t["text_primary"]
+        else:
+            border = t["border"]
+            bg = t["overlay"]
+            fg = t["text_secondary"]
+
+        btn.setStyleSheet(f"""
+            QPushButton {{
+                background: {bg};
+                border: 1px solid {border};
+	                border-radius: 4px;
+                color: {fg};
+                text-align: center;
+                padding: 0px;
+                margin: 0px;
+            }}
+            QPushButton:hover {{
+                background: {t['overlay_hover']};
+                border: 1px solid {t['accent']};
+                color: {t['text_primary']};
+            }}
+            QPushButton:pressed {{
+                background: {t['overlay_pressed']};
+            }}
+        """)
+
+    def open_tool_selector(self) -> None:
+        """Open the tool selector dialog (controls per-run tool allowlist)."""
+        self._refresh_tool_inventory()
+        if not self._available_external_tools:
+            QMessageBox.information(self, "Tools", "No tools are available in this configuration.")
+            return
+
+        dlg = ToolSelectorDialog(
+            parent=self,
+            tools=list(self._available_external_tools),
+            enabled=set(self._enabled_external_tools),
+            safe_preset=set(self._safe_external_tools),
+            require_approval=set(self._require_approval_tools),
+        )
+        result = dlg.exec()
+        accepted_code = getattr(QDialog, "Accepted", 1)
+        if result != accepted_code:
+            return
+
+        self._enabled_external_tools = set(dlg.selected_tools())
+        # Keep session auto-approve set consistent with enabled tool selection.
+        try:
+            self._session_auto_approve_tools &= set(self._enabled_external_tools)
+        except Exception:
+            pass
+        self._update_tools_button_state()
+
     def attach_files(self):
         """Open file dialog to attach files (AbstractCore 2.4.5+ media handling)."""
         file_dialog = QFileDialog(self)
@@ -1138,6 +2258,7 @@ class QtChatBubble(QWidget):
 
     def update_attached_files_display(self):
         """Update the visual display of attached files."""
+        t = self._theme or self._compute_theme()
         # Clear existing file chips
         while self.attached_files_layout.count():
             child = self.attached_files_layout.takeAt(0)
@@ -1158,14 +2279,16 @@ class QtChatBubble(QWidget):
 
             # Create file chip
             file_chip = QFrame()
-            file_chip.setStyleSheet("""
-                QFrame {
-                    background: rgba(0, 102, 204, 0.2);
-                    border: 1px solid rgba(0, 102, 204, 0.4);
+            file_chip.setStyleSheet(
+                f"""
+                QFrame {{
+                    background: {t['accent_rgba_20']};
+                    border: 1px solid {t['accent_rgba_35']};
                     border-radius: 6px;
                     padding: 1px 4px;
-                }
-            """)
+                }}
+                """
+            )
 
             chip_layout = QHBoxLayout(file_chip)
             chip_layout.setContentsMargins(2, 1, 2, 1)
@@ -1189,24 +2312,28 @@ class QtChatBubble(QWidget):
                 icon = "📎"
 
             file_label = QLabel(f"{icon} {file_name[:20]}{'...' if len(file_name) > 20 else ''}")
-            file_label.setStyleSheet("background: transparent; border: none; color: rgba(255, 255, 255, 0.9); font-size: 8px;")
+            file_label.setStyleSheet(
+                f"background: transparent; border: none; color: {t['text_primary']}; font-size: 8px;"
+            )
             chip_layout.addWidget(file_label)
 
             # Remove button
             remove_btn = QPushButton("✕")
             remove_btn.setFixedSize(12, 12)
-            remove_btn.setStyleSheet("""
-                QPushButton {
+            remove_btn.setStyleSheet(
+                f"""
+                QPushButton {{
                     background: transparent;
                     border: none;
-                    color: rgba(255, 255, 255, 0.6);
+                    color: {t['text_muted']};
                     font-size: 8px;
                     padding: 0px;
-                }
-                QPushButton:hover {
+                }}
+                QPushButton:hover {{
                     color: rgba(255, 60, 60, 0.9);
-                }
-            """)
+                }}
+                """
+            )
             remove_btn.clicked.connect(lambda checked, fp=file_path: self.remove_attached_file(fp))
             chip_layout.addWidget(remove_btn)
 
@@ -1277,6 +2404,7 @@ class QtChatBubble(QWidget):
         # 4. Update UI for sending state
         self.send_button.setEnabled(False)
         self.send_button.setText("⏳")
+        self._set_session_controls_enabled(False)
         self.status_label.setText("generating")
         self.status_label.setObjectName("status_generating")
         self.status_label.setStyleSheet("""
@@ -1293,32 +2421,222 @@ class QtChatBubble(QWidget):
             }
         """)
 
-        # Notify main app about status change (for icon animation)
-        if self.status_callback:
-            self.status_callback("generating")
+        # Notify main app about status change (for icon animation)
+        if self.status_callback:
+            self.status_callback("generating")
+
+        if self.debug:
+            print("🔄 QtChatBubble: UI updated, creating worker thread...")
+
+        # 5. Start worker thread to send request with optional media files
+        system_prompt_extra = None
+        if self._is_voice_mode_active():
+            system_prompt_extra = (
+                "You are in voice mode.\n"
+                "- Keep responses concise and conversational.\n"
+                "- Avoid markdown and heavy formatting.\n"
+            )
+
+        host = getattr(self.llm_manager, "agent_host", None)
+        if host is not None:
+            self.worker = AgentWorker(
+                agent_host=host,
+                user_text=message,
+                provider=self.current_provider,
+                model=self.current_model,
+                attachments=media_files if media_files else None,
+                system_prompt_extra=system_prompt_extra,
+                allowed_tools=sorted(self._enabled_external_tools),
+                debug=bool(self.debug),
+            )
+            self.worker.event_emitted.connect(self.on_agent_event)
+            self.worker.error_occurred.connect(self.on_error_occurred)
+        else:
+            self.worker = LLMWorker(
+                self.llm_manager,
+                message,
+                self.current_provider,
+                self.current_model,
+                media=media_files if media_files else None,
+                debug=bool(self.debug),
+            )
+            self.worker.response_ready.connect(self.on_response_ready)
+            self.worker.error_occurred.connect(self.on_error_occurred)
+
+        if self.debug:
+            print("🔄 QtChatBubble: Starting worker thread...")
+        self.worker.start()
+
+        if self.debug:
+            print("🔄 QtChatBubble: Worker thread started, hiding bubble...")
+        # Hide bubble after sending (like the original design)
+        QTimer.singleShot(500, self.hide)
+
+    @pyqtSlot(object)
+    def on_agent_event(self, event):
+        """Handle AgentHost events emitted by AgentWorker."""
+        if not isinstance(event, dict):
+            return
+
+        typ = event.get("type")
+        if typ == "status":
+            status = str(event.get("status") or "")
+            self._set_agent_status(status)
+            return
+
+        if typ == "tool_request":
+            self._handle_tool_request(event)
+            return
+
+        if typ == "ask_user":
+            self._handle_ask_user(event)
+            return
+
+        if typ == "assistant":
+            try:
+                if hasattr(self.llm_manager, "refresh"):
+                    self.llm_manager.refresh()
+            except Exception:
+                pass
+            self.on_response_ready(str(event.get("content") or ""))
+            return
+
+        if typ == "error":
+            self.on_error_occurred(str(event.get("error") or "error"))
+            return
+
+    def _set_agent_status(self, status: str) -> None:
+        st = str(status or "").strip().lower()
+        if st in {"thinking", "running"}:
+            self.status_label.setText("thinking")
+            if self.status_callback:
+                self.status_callback("thinking")
+            return
+        if st in {"executing_tools", "executing"}:
+            self.status_label.setText("executing")
+            if self.status_callback:
+                self.status_callback("executing")
+            return
+        if st in {"ready", "completed"}:
+            self.status_label.setText("ready")
+            if self.status_callback:
+                self.status_callback("ready")
+            return
+
+    def _handle_tool_request(self, event: Dict) -> None:
+        """Prompt user for tool approval when required."""
+        tool_calls = event.get("tool_calls")
+        if not isinstance(tool_calls, list):
+            tool_calls = []
+
+        host = getattr(self.llm_manager, "agent_host", None)
+        requires = True
+        try:
+            if host is not None:
+                requires = bool(host.tool_policy.requires_approval(tool_calls))
+        except Exception:
+            requires = True
+
+        # Session-level allowlist can bypass approval prompts (still bounded by policy).
+        try:
+            if all(
+                str(tc.get("name") or "") in self._session_auto_approve_tools
+                for tc in tool_calls
+                if isinstance(tc, dict)
+            ):
+                requires = False
+        except Exception:
+            pass
+
+        if not requires:
+            if self.debug:
+                print("✅ Auto-approving safe tool batch (no prompt).")
+            if self.status_callback:
+                self.status_callback("executing")
+            if isinstance(self.worker, AgentWorker):
+                self.worker.provide_tool_approval(True)
+            return
+
+        # Bring UI forward for interactive approvals.
+        try:
+            self.show()
+            self.raise_()
+            self.activateWindow()
+        except Exception:
+            pass
 
-        if self.debug:
-            print("🔄 QtChatBubble: UI updated, creating worker thread...")
+        self.status_label.setText("approve")
+        if self.status_callback:
+            self.status_callback("thinking")
+
+        # Format tool calls for display.
+        lines: List[str] = []
+        for i, tc in enumerate(tool_calls):
+            if not isinstance(tc, dict):
+                continue
+            name = str(tc.get("name") or f"tool_{i}")
+            args = tc.get("arguments")
+            try:
+                args_txt = json.dumps(args, ensure_ascii=False, indent=2)
+            except Exception:
+                args_txt = str(args)
+            lines.append(f"{name}({args_txt})")
+        details = "\n\n".join(lines).strip()
+        if len(details) > 8000:
+            details = details[:8000] + "\n…(truncated)…"
+
+        box = QMessageBox(self)
+        box.setWindowTitle("Tool approval required")
+        box.setIcon(QMessageBox.Icon.Warning)
+        box.setText("The assistant wants to run tools that may affect your system or workspace.")
+        box.setInformativeText("Review the tool calls and approve or deny this batch.")
+        box.setDetailedText(details)
+
+        allow_box = QCheckBox("Always allow these tools for this session (non-destructive tools only)")
+        box.setCheckBox(allow_box)
+
+        approve_btn = box.addButton("Approve", QMessageBox.ButtonRole.AcceptRole)
+        deny_btn = box.addButton("Deny", QMessageBox.ButtonRole.RejectRole)
+        box.setDefaultButton(deny_btn)
+
+        box.exec()
+        clicked = box.clickedButton()
+        approved = clicked == approve_btn
+
+        if approved and allow_box.isChecked() and host is not None:
+            try:
+                policy = host.tool_policy
+                for tc in tool_calls:
+                    if not isinstance(tc, dict):
+                        continue
+                    name = str(tc.get("name") or "").strip()
+                    if not name:
+                        continue
+                    # Only allow session auto-approvals for tools that are not in the explicit "requires approval" set.
+                    if name in getattr(policy, "require_approval_tools", set()):
+                        continue
+                    self._session_auto_approve_tools.add(name)
+            except Exception:
+                pass
 
-        # 5. Start worker thread to send request with optional media files
-        self.worker = LLMWorker(
-            self.llm_manager,
-            message,
-            self.current_provider,
-            self.current_model,
-            media=media_files if media_files else None
-        )
-        self.worker.response_ready.connect(self.on_response_ready)
-        self.worker.error_occurred.connect(self.on_error_occurred)
+        if isinstance(self.worker, AgentWorker):
+            self.worker.provide_tool_approval(bool(approved))
 
-        if self.debug:
-            print("🔄 QtChatBubble: Starting worker thread...")
-        self.worker.start()
+    def _handle_ask_user(self, event: Dict) -> None:
+        """Prompt user for input required by the run."""
+        prompt = str(event.get("prompt") or "Input required:")
 
-        if self.debug:
-            print("🔄 QtChatBubble: Worker thread started, hiding bubble...")
-        # Hide bubble after sending (like the original design)
-        QTimer.singleShot(500, self.hide)
+        try:
+            self.show()
+            self.raise_()
+            self.activateWindow()
+        except Exception:
+            pass
+
+        text, ok = QInputDialog.getText(self, "Assistant needs input", prompt)
+        response = str(text) if ok else ""
+        if isinstance(self.worker, AgentWorker):
+            self.worker.provide_user_response(response)
     
     @pyqtSlot(str)
     def on_response_ready(self, response):
@@ -1328,6 +2646,7 @@ class QtChatBubble(QWidget):
         
         self.send_button.setEnabled(True)
         self.send_button.setText("→")
+        self._set_session_controls_enabled(True)
         self.status_label.setText("ready")
         self.status_label.setObjectName("status_ready")
         self.status_label.setStyleSheet("""
@@ -1353,6 +2672,25 @@ class QtChatBubble(QWidget):
 
         # Update token count from AbstractCore
         self._update_token_count_from_session()
+
+        # Refresh sessions list (recency ordering).
+        try:
+            self._reload_session_combo()
+        except Exception:
+            pass
+
+        # Best-effort: auto-title the active session for the dropdown.
+        try:
+            if self.llm_manager and hasattr(self.llm_manager, "update_active_session_title_async"):
+                self.llm_manager.update_active_session_title_async(
+                    provider=self.current_provider,
+                    model=self.current_model,
+                    on_done=lambda _sid, _title: QMetaObject.invokeMethod(
+                        self, "_refresh_session_combo_ui", Qt.QueuedConnection
+                    ),
+                )
+        except Exception:
+            pass
         
         # Handle TTS if enabled (AbstractVoice integration)
         if self.tts_enabled and self.voice_manager and self.voice_manager.is_available():
@@ -1385,7 +2723,9 @@ class QtChatBubble(QWidget):
                 
                 # Speak the cleaned response using AbstractVoice-compatible interface
                 # Note: We don't set "speaking" status here anymore - we wait for the callback
-                self.voice_manager.speak(clean_response)
+                started = bool(self.voice_manager.speak(clean_response))
+                if not started:
+                    raise RuntimeError("TTS speak() returned False")
 
                 # Update toggle state to 'speaking'
                 self._update_tts_toggle_state()
@@ -1402,6 +2742,12 @@ class QtChatBubble(QWidget):
                         print(f"❌ TTS error: {e}")
                 # Show chat history as fallback - only if voice mode is OFF
                 QTimer.singleShot(100, self._show_history_if_voice_mode_off)
+                if self._is_full_voice_running():
+                    self._voice_busy = False
+                    try:
+                        self.update_status("LISTENING")
+                    except Exception:
+                        pass
         else:
             # Show chat history instead of toast when TTS is disabled - only if voice mode is OFF
             self._show_history_if_voice_mode_off()
@@ -1420,6 +2766,12 @@ class QtChatBubble(QWidget):
                 self.response_callback(response)
             if self.status_callback:
                 self.status_callback("ready")
+            if self._is_full_voice_running():
+                self._voice_busy = False
+                try:
+                    self.update_status("LISTENING")
+                except Exception:
+                    pass
         else:
             # TTS path: Stay in thinking mode until audio actually starts
             if self.debug:
@@ -1583,7 +2935,13 @@ class QtChatBubble(QWidget):
                 pass
 
     def on_full_voice_toggled(self, enabled: bool):
-        """Handle Full Voice Mode toggle state change."""
+        """Handle Full Voice Mode toggle state change (always apply on Qt main thread)."""
+        try:
+            QTimer.singleShot(0, lambda e=bool(enabled): self._apply_full_voice_toggled(e))
+        except Exception:
+            self._apply_full_voice_toggled(bool(enabled))
+
+    def _apply_full_voice_toggled(self, enabled: bool) -> None:
         if self.debug:
             print(f"🎙️  Full Voice Mode {'enabled' if enabled else 'disabled'}")
 
@@ -1606,7 +2964,8 @@ class QtChatBubble(QWidget):
                 if self.debug:
                     print("🚀 Starting Full Voice Mode...")
 
-            # Hide text input UI
+            # Keep the normal interface visible, but switch input actions to voice mode
+            # (attach + tools remain usable; send is hidden).
             self.hide_text_ui()
 
             # Enable TTS automatically
@@ -1620,6 +2979,9 @@ class QtChatBubble(QWidget):
             if self.llm_manager:
                 self.llm_manager.update_session_mode(tts_mode=True)
 
+            # Mark running before starting the underlying loop so late UI updates can be gated.
+            self._full_voice_running = True
+
             # Start listening
             self.voice_manager.listen(
                 on_transcription=self.handle_voice_input,
@@ -1644,77 +3006,132 @@ class QtChatBubble(QWidget):
                 traceback.print_exc()
 
             # Reset toggle state on error
+            self._full_voice_running = False
             self.full_voice_toggle.set_enabled(False)
             self.show_text_ui()
 
+    def _is_full_voice_running(self) -> bool:
+        """Centralized guard for any 'LISTENING' UI updates from async callbacks."""
+        try:
+            return bool(self._full_voice_running) and bool(self.full_voice_toggle.is_enabled())
+        except Exception:
+            return bool(getattr(self, "_full_voice_running", False))
+
     def stop_full_voice_mode(self):
         """Stop Full Voice Mode and return to normal text mode."""
-        try:
+        # IMPORTANT: make this robust. Even if voice backend stop throws, the UI must restore.
+        if self.debug:
             if self.debug:
-                if self.debug:
-                    print("🛑 Stopping Full Voice Mode...")
+                print("🛑 Stopping Full Voice Mode...")
+
+        # Gate all future async 'LISTENING' updates immediately.
+        self._full_voice_running = False
+        self._voice_busy = False
 
-            # Stop listening
-            if self.voice_manager:
+        # 1) Stop listening/speaking (best-effort, never block UI restore)
+        if self.voice_manager:
+            try:
+                # Detach callbacks to avoid late status flips after shutdown.
+                try:
+                    self.voice_manager.on_speech_start = None
+                    self.voice_manager.on_speech_end = None
+                except Exception:
+                    pass
                 self.voice_manager.stop_listening()
+            except Exception as e:
+                if self.debug:
+                    print(f"❌ Error stopping listening: {e}")
+            try:
                 self.voice_manager.stop_speaking()
+            except Exception as e:
+                if self.debug:
+                    print(f"❌ Error stopping speaking: {e}")
+
+        # 2) Turn off the speaker toggle (TTS) when leaving voice mode (as requested)
+        try:
+            if hasattr(self, "tts_toggle") and self.tts_toggle:
+                self.tts_toggle.set_enabled(False)
+            self.tts_enabled = False
+        except Exception:
+            pass
 
-            # Show text input UI
+        # 3) Restore normal UI (Send visible again)
+        try:
             self.show_text_ui()
+        except Exception:
+            pass
 
-            # No longer updating voice toggle appearance - it's a simple user control
+        # If no run is currently in progress, restore the send affordance immediately.
+        try:
+            if not self._is_run_in_progress():
+                if getattr(self, "send_button", None) is not None:
+                    self.send_button.setEnabled(True)
+                    self.send_button.setText("→")
+                self._set_session_controls_enabled(True)
+        except Exception:
+            pass
+
+        # 4) Status back to Ready (green) + tray icon ready
+        try:
             self.update_status("READY")
+        except Exception:
+            pass
+        try:
+            if self.status_callback:
+                self.status_callback("ready")
+        except Exception:
+            pass
 
+        if self.debug:
             if self.debug:
-                if self.debug:
-                    print("✅ Full Voice Mode stopped")
-
-        except Exception as e:
-            if self.debug:
-                if self.debug:
-                    print(f"❌ Error stopping Full Voice Mode: {e}")
-                import traceback
-                traceback.print_exc()
+                print("✅ Full Voice Mode stopped")
 
     def handle_voice_input(self, transcribed_text: str):
-        """Handle speech-to-text input from the user."""
-        try:
-            if self.debug:
-                if self.debug:
-                    print(f"👤 Voice input: {transcribed_text}")
+        """Handle speech-to-text input (thread-safe, routes through agentic pipeline)."""
+        # Ignore any late STT callbacks after the user stopped voice mode.
+        if not self._is_full_voice_running():
+            return
 
-            # No longer updating voice toggle appearance - it's a simple user control
-            self.update_status("PROCESSING")
+        text = str(transcribed_text or "").strip()
+        if not text:
+            return
 
-            # Generate AI response (AbstractCore will handle message logging automatically)
-            response = self.llm_manager.generate_response(
-                transcribed_text,
-                self.current_provider,
-                self.current_model
-            )
+        if self.debug:
+            print(f"👤 Voice input: {text}")
 
-            # Update message history from AbstractCore session
-            self._update_message_history_from_session()
+        # Ensure we run UI + agent turn creation on the Qt main thread.
+        QTimer.singleShot(0, lambda t=text: self._handle_voice_input_main_thread(t))
 
-            if self.debug:
-                if self.debug:
-                    print(f"🤖 AI response: {response[:100]}...")
+    def _handle_voice_input_main_thread(self, transcribed_text: str) -> None:
+        """Execute a voice input turn on the Qt main thread."""
+        if not self._is_full_voice_running():
+            self._voice_busy = False
+            return
 
-            # Speak the response
-            self.voice_manager.speak(response)
+        if self._voice_busy:
+            if self.debug:
+                print("🎙️  Ignoring transcription while busy")
+            return
 
-            # No longer updating voice toggle appearance - it's a simple user control
-            self.update_status("LISTENING")
+        self._voice_busy = True
+        try:
+            self.update_status("PROCESSING")
 
+            # Route through the same agentic sending path as typed input.
+            try:
+                self.input_text.setPlainText(str(transcribed_text or ""))
+            except Exception:
+                pass
+            self.send_message()
         except Exception as e:
+            self._voice_busy = False
             if self.debug:
-                if self.debug:
-                    print(f"❌ Error handling voice input: {e}")
-                import traceback
-                traceback.print_exc()
-
-            # No longer updating voice toggle appearance - it's a simple user control
-            self.update_status("LISTENING")
+                print(f"❌ Error handling voice input: {e}")
+            try:
+                if self._is_full_voice_running():
+                    self.update_status("LISTENING")
+            except Exception:
+                pass
 
     def handle_voice_stop(self):
         """Handle when user says 'stop' to exit Full Voice Mode."""
@@ -1723,28 +3140,64 @@ class QtChatBubble(QWidget):
                 print("🛑 User said 'stop' - exiting Full Voice Mode")
 
         # Disable Full Voice Mode
+        self._full_voice_running = False
         self.full_voice_toggle.set_enabled(False)
 
     def hide_text_ui(self):
-        """Hide the text input interface during Full Voice Mode."""
-        # Hide the input container and other text-related UI elements
-        if hasattr(self, 'input_container'):
-            self.input_container.hide()
-
-        # Update window size to be smaller but maintain wider width
-        voice_base_height = 120
-        attachment_height = 28 if (self.attached_files and self.attached_files_container.isVisible()) else 0
-        voice_height = voice_base_height + attachment_height
-        self.setFixedSize(self.base_width, voice_height)  # Dynamic height for voice mode
+        """Enter Full Voice Mode UI (keep input visible; hide Send; keep attach/tools)."""
+        self._set_voice_ui_mode(True)
 
     def show_text_ui(self):
-        """Show the text input interface when exiting Full Voice Mode."""
-        # Show the input container and other text-related UI elements
-        if hasattr(self, 'input_container'):
-            self.input_container.show()
+        """Exit Full Voice Mode UI (restore Send and normal text interaction)."""
+        self._set_voice_ui_mode(False)
 
-        # Restore normal window size with wider width - use dynamic sizing
-        self._adjust_window_size_for_attachments()
+    def _set_voice_ui_mode(self, enabled: bool) -> None:
+        """
+        Centralized UI state switch for voice mode.
+
+        Requirements:
+        - Even in voice mode, user can still change file attachments and tools.
+        - Send is hidden/disabled in voice mode (end-of-sentence acts as "send").
+        """
+        enabled = bool(enabled)
+        try:
+            if hasattr(self, "input_container") and self.input_container:
+                self.input_container.show()
+        except Exception:
+            pass
+
+        # Toggle the action column behavior (2 buttons in voice mode, 3 otherwise).
+        try:
+            if hasattr(self, "_input_row") and self._input_row:
+                self._input_row.set_voice_mode(enabled)
+        except Exception:
+            pass
+
+        # Ensure attach/tools remain available in both modes.
+        for btn_attr in ("attach_button", "tools_button"):
+            b = getattr(self, btn_attr, None)
+            if b is None:
+                continue
+            try:
+                b.setEnabled(True)
+                b.setVisible(True)
+            except Exception:
+                pass
+
+        # Send button is only relevant in text mode.
+        sb = getattr(self, "send_button", None)
+        if sb is not None:
+            try:
+                sb.setVisible(not enabled)
+                sb.setEnabled(not enabled)
+            except Exception:
+                pass
+
+        # Keep the window sizing consistent with attachments.
+        try:
+            self._adjust_window_size_for_attachments()
+        except Exception:
+            pass
 
     def update_status(self, status_text: str):
         """Update the status label with the given text."""
@@ -1893,6 +3346,7 @@ class QtChatBubble(QWidget):
         """Handle LLM error."""
         self.send_button.setEnabled(True)
         self.send_button.setText("→")
+        self._set_session_controls_enabled(True)
         self.status_label.setText("error")
         self.status_label.setObjectName("status_error")
         self.status_label.setStyleSheet("""
@@ -1920,6 +3374,14 @@ class QtChatBubble(QWidget):
 
         # Show history so user can see the error context - only if voice mode is OFF
         QTimer.singleShot(100, self._show_history_if_voice_mode_off)
+
+        # If we're in full voice mode, unblock the STT loop.
+        if self._is_full_voice_running():
+            self._voice_busy = False
+            try:
+                self.update_status("LISTENING")
+            except Exception:
+                pass
         
         # Call error callback
         if self.error_callback:
@@ -1936,41 +3398,257 @@ class QtChatBubble(QWidget):
     def set_status_callback(self, callback):
         """Set status callback function."""
         self.status_callback = callback
+
+    def _set_session_controls_enabled(self, enabled: bool) -> None:
+        for attr in ("session_combo", "new_session_button"):
+            w = getattr(self, attr, None)
+            if w is None:
+                continue
+            try:
+                w.setEnabled(bool(enabled))
+            except Exception:
+                pass
+
+    def _selected_session_id(self) -> Optional[str]:
+        combo = getattr(self, "session_combo", None)
+        if combo is None:
+            return None
+        try:
+            sid = combo.currentData()
+        except Exception:
+            sid = None
+        sid = str(sid or "").strip()
+        return sid or None
+
+    def _reload_session_combo(self, *, select_session_id: Optional[str] = None) -> None:
+        combo = getattr(self, "session_combo", None)
+        if combo is None:
+            return
+        if not self.llm_manager or not hasattr(self.llm_manager, "list_sessions"):
+            try:
+                combo.clear()
+                combo.addItem("Session")
+                combo.setEnabled(False)
+            except Exception:
+                pass
+            return
+
+        try:
+            sessions = list(self.llm_manager.list_sessions() or [])
+        except Exception:
+            sessions = []
+
+        active = select_session_id or self._selected_session_id()
+        if not active:
+            try:
+                active = str(getattr(self.llm_manager, "active_session_id", "") or "").strip()
+            except Exception:
+                active = None
+
+        try:
+            combo.blockSignals(True)
+            combo.clear()
+
+            select_index = 0
+            items = 0
+            for rec in sessions:
+                if not isinstance(rec, dict):
+                    continue
+                sid = str(rec.get("session_id") or "").strip()
+                if not sid:
+                    continue
+                title = str(rec.get("title") or "New session").strip() or "New session"
+                label = title
+                if title.strip().lower() == "new session":
+                    stamp = str(rec.get("updated_at") or rec.get("created_at") or "").strip()
+                    human = None
+                    if stamp:
+                        try:
+                            dt = datetime.fromisoformat(stamp)
+                            human = dt.astimezone().strftime("%b %d %H:%M")
+                        except Exception:
+                            human = None
+                    label = f"{title} • {human}" if human else f"{title} • {sid[-6:]}"
+                combo.addItem(label, sid)
+                try:
+                    idx = combo.count() - 1
+                    role = getattr(Qt, "ToolTipRole", None) or getattr(getattr(Qt, "ItemDataRole", object), "ToolTipRole", None)
+                    if role is not None:
+                        tip_lines = [title, sid]
+                        updated = str(rec.get("updated_at") or "").strip()
+                        if updated:
+                            tip_lines.append(f"Updated: {updated}")
+                        combo.setItemData(idx, "\n".join(tip_lines), role)
+                except Exception:
+                    pass
+                if active and sid == active:
+                    select_index = items
+                items += 1
+
+            if combo.count() <= 0:
+                combo.addItem("New session")
+                combo.setEnabled(False)
+            else:
+                combo.setEnabled(True)
+                combo.setCurrentIndex(select_index)
+        finally:
+            try:
+                combo.blockSignals(False)
+            except Exception:
+                pass
+
+    def _is_run_in_progress(self) -> bool:
+        try:
+            if self.worker is not None and hasattr(self.worker, "isRunning") and self.worker.isRunning():
+                return True
+        except Exception:
+            pass
+        try:
+            return not bool(self.send_button.isEnabled())
+        except Exception:
+            return False
+
+    def _on_session_combo_changed(self, index: int) -> None:
+        if not self.llm_manager or not hasattr(self.llm_manager, "switch_session"):
+            return
+
+        combo = getattr(self, "session_combo", None)
+        if combo is None:
+            return
+
+        try:
+            sid = combo.itemData(int(index))
+        except Exception:
+            sid = None
+        sid = str(sid or "").strip()
+        if not sid:
+            return
+
+        try:
+            current = str(getattr(self.llm_manager, "active_session_id", "") or "").strip()
+        except Exception:
+            current = ""
+        if sid == current:
+            return
+
+        if self._is_run_in_progress():
+            QMessageBox.information(self, "Session switch", "Please wait for the current response to finish.")
+            self._reload_session_combo(select_session_id=current or None)
+            return
+
+        try:
+            self.llm_manager.switch_session(sid)
+        except Exception as e:
+            QMessageBox.warning(self, "Session switch", f"Failed to switch session:\n{e}")
+            self._reload_session_combo(select_session_id=current or None)
+            return
+
+        try:
+            if hasattr(self.llm_manager, "refresh"):
+                self.llm_manager.refresh()
+        except Exception:
+            pass
+
+        self._reload_session_combo(select_session_id=sid)
+
+        # Reset per-session UI caches.
+        self.attached_files.clear()
+        self.message_file_attachments.clear()
+        self.update_attached_files_display()
+
+        self._update_message_history_from_session()
+        self._update_token_count_from_session()
+        self._rebuild_chat_display()
+
+        # If the history window is open but the new session is empty, hide it.
+        if self.history_dialog and self.history_dialog.isVisible() and not self.message_history:
+            try:
+                self.history_dialog.hide()
+                self._update_history_button_appearance(False)
+            except Exception:
+                pass
+
+    def _start_new_session(self) -> None:
+        if not self.llm_manager or not hasattr(self.llm_manager, "create_new_session"):
+            return
+
+        if self._is_run_in_progress():
+            QMessageBox.information(self, "New session", "Please wait for the current response to finish.")
+            return
+
+        try:
+            new_id = str(self.llm_manager.create_new_session() or "").strip()
+        except Exception as e:
+            QMessageBox.warning(self, "New session", f"Failed to create a new session:\n{e}")
+            return
+
+        # Reset per-session UI caches.
+        self.attached_files.clear()
+        self.message_file_attachments.clear()
+        self.update_attached_files_display()
+
+        self._update_message_history_from_session()
+        self._update_token_count_from_session()
+        self._rebuild_chat_display()
+
+        if self.history_dialog and self.history_dialog.isVisible():
+            try:
+                self.history_dialog.hide()
+                self._update_history_button_appearance(False)
+            except Exception:
+                pass
+
+        self._reload_session_combo(select_session_id=new_id or None)
+
+    @pyqtSlot()
+    def _refresh_session_combo_ui(self) -> None:
+        try:
+            self._reload_session_combo()
+        except Exception:
+            pass
+
+    def _show_more_menu(self) -> None:
+        btn = getattr(self, "more_button", None)
+        if btn is None:
+            return
+        menu = QMenu(self)
+        menu.addAction("Load…", self.load_session)
+        menu.addAction("Save…", self.save_session)
+        if bool(getattr(self, "debug", False)):
+            menu.addSeparator()
+            menu.addAction("Run trace (debug)…", self.show_trace)
+
+        try:
+            pos = btn.mapToGlobal(QPoint(0, btn.height()))
+        except Exception:
+            pos = None
+
+        try:
+            if pos is None:
+                if hasattr(menu, "exec_"):
+                    menu.exec_()
+                else:
+                    menu.exec()
+            else:
+                if hasattr(menu, "exec_"):
+                    menu.exec_(pos)
+                else:
+                    menu.exec(pos)
+        except Exception:
+            return
     
     def clear_session(self):
-        """Clear the current session."""
+        """Start a new session (prior sessions remain available)."""
         reply = QMessageBox.question(
-            self, 
-            "Clear Session", 
-            "Are you sure you want to clear the current session?\nThis will remove all messages, attached files, and reset the token count.",
+            self,
+            "New Session",
+            "Start a new session?\nYour previous sessions will remain available in the session dropdown.",
             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
-            QMessageBox.StandardButton.No
+            QMessageBox.StandardButton.No,
         )
-        
-        if reply == QMessageBox.StandardButton.Yes:
-            if hasattr(self, 'chat_display'):
-                self.chat_display.clear()
-                self.chat_display.hide()
-
-            # Clear AbstractCore session and create a new one
-            if self.llm_manager:
-                self.llm_manager.create_new_session()
-                if self.debug:
-                    if self.debug:
-                        print("🧹 AbstractCore session cleared and recreated")
 
-            self.message_history.clear()
-            self.token_count = 0
-            self.update_token_display()
-
-            # Clear attached files as part of session clearing
-            self.attached_files.clear()
-            self.message_file_attachments.clear()
-            self.update_attached_files_display()
-
-            if self.debug:
-                if self.debug:
-                    print("🧹 Session cleared (including attached files and file tracking)")
+        if reply == QMessageBox.StandardButton.Yes:
+            self._start_new_session()
     
     def compact_session(self):
         """Compact the current session using AbstractCore's summarizer functionality."""
@@ -2151,8 +3829,8 @@ Please provide the summary in a clear, structured format:"""
     def _create_compacted_session(self, summary: str, recent_messages: list):
         """Create a new session with the summary and recent messages."""
         try:
-            # Create new session with summary as enhanced system prompt
-            enhanced_system_prompt = f"""You are a helpful AI assistant who has access to tools to help the user.
+            # Create new session with summary embedded in the system prompt.
+            final_system_prompt = f"""You are a helpful AI assistant who has access to tools to help the user.
 Always be a critical and creative thinker who leverage constructive skepticism to progress and evolve its reasoning and answers.
 Always answer in nicely formatted markdown.
 
@@ -2165,7 +3843,7 @@ The following is a summary of our previous conversation:
 
 Continue the conversation naturally, referring to the context above when relevant."""
 
-            # Create new session with enhanced system prompt
+            # Create new session with the composed system prompt
             if self.llm_manager:
                 # Create new session with custom system prompt
                 from abstractcore import BasicSession
@@ -2187,7 +3865,7 @@ Continue the conversation naturally, referring to the context above when relevan
                 # Create new session with summary in system prompt
                 new_session = BasicSession(
                     self.llm_manager.llm,
-                    system_prompt=enhanced_system_prompt,
+                    system_prompt=final_system_prompt,
                     tools=tools
                 )
                 
@@ -2260,6 +3938,8 @@ Continue the conversation naturally, referring to the context above when relevan
 
                         # Update our local message history from AbstractCore
                         self._update_message_history_from_session()
+                        self._update_token_count_from_session()
+                        self._reload_session_combo()
                         self._rebuild_chat_display()
 
                         QMessageBox.information(
@@ -2357,37 +4037,78 @@ Continue the conversation naturally, referring to the context above when relevan
         return not self._is_voice_mode_active()
 
     def _update_message_history_from_session(self):
-        """Update local message history from AbstractCore session."""
-        if self.llm_manager and self.llm_manager.current_session:
+        """Update local message history from the durable agent snapshot (preferred).
+
+        Notes:
+        - Runtime-backed agents include role="tool" observations in the transcript so the
+          model can continue tool loops. Those are hidden from the user-visible history
+          and replaced with a compact per-answer tool summary + resource links.
+        """
+        if not self.llm_manager:
+            return
+
+        from ..core.transcript_summary import build_display_messages
+
+        raw_messages = None
+        try:
+            host = getattr(self.llm_manager, "agent_host", None)
+            snap = getattr(host, "snapshot", None) if host is not None else None
+            raw_messages = getattr(snap, "messages", None) if snap is not None else None
+        except Exception:
+            raw_messages = None
+
+        messages: List[Dict] = []
+        if isinstance(raw_messages, list):
+            messages = [dict(m) for m in raw_messages if isinstance(m, dict)]
+        elif getattr(self.llm_manager, "current_session", None) is not None:
             try:
-                # Get messages from AbstractCore session
-                session_messages = getattr(self.llm_manager.current_session, 'messages', [])
-
-                # Convert AbstractCore messages to our format
-                self.message_history = []
-                for i, msg in enumerate(session_messages):
-                    # Skip system messages
-                    if hasattr(msg, 'role') and msg.role == 'system':
-                        continue
+                session_messages = getattr(self.llm_manager.current_session, "messages", [])
+                for msg in session_messages:
+                    role = getattr(msg, "role", "unknown")
+                    content = getattr(msg, "content", str(msg))
+                    messages.append({"role": str(role), "content": str(content)})
+            except Exception:
+                messages = []
 
-                    message = {
-                        'timestamp': datetime.now().isoformat(),  # AbstractCore doesn't store timestamps
-                        'type': getattr(msg, 'role', 'unknown'),
-                        'content': getattr(msg, 'content', str(msg)),
-                        'provider': self.current_provider,
-                        'model': self.current_model,
-                        'attached_files': self.message_file_attachments.get(len(self.message_history), [])
-                    }
-                    self.message_history.append(message)
+        try:
+            rendered = build_display_messages(messages)
+
+            self.message_history = []
+            for m in rendered:
+                role = str(m.get("role") or "unknown")
+                content = str(m.get("content") or "")
+                timestamp = m.get("timestamp")
+                if not isinstance(timestamp, (str, int, float)) or (isinstance(timestamp, str) and not timestamp.strip()):
+                    timestamp = datetime.now().isoformat()
+
+                entry: Dict[str, Any] = {
+                    "timestamp": timestamp,
+                    "type": role,
+                    "content": content,
+                    "provider": self.current_provider,
+                    "model": self.current_model,
+                    "attached_files": self.message_file_attachments.get(len(self.message_history), []),
+                }
 
-                if self.debug:
-                    if self.debug:
-                        print(f"📚 Updated message history from AbstractCore: {len(self.message_history)} messages")
+                tool_summary = m.get("tool_summary")
+                if isinstance(tool_summary, str) and tool_summary.strip():
+                    entry["tool_summary"] = tool_summary.strip()
+                tool_links = m.get("tool_links")
+                if isinstance(tool_links, list) and tool_links:
+                    entry["tool_links"] = [dict(x) for x in tool_links if isinstance(x, dict)]
 
-            except Exception as e:
-                if self.debug:
-                    if self.debug:
-                        print(f"❌ Error updating message history from session: {e}")
+                image_thumbnails = m.get("image_thumbnails")
+                if isinstance(image_thumbnails, list) and image_thumbnails:
+                    entry["image_thumbnails"] = [dict(x) for x in image_thumbnails if isinstance(x, dict)]
+
+                self.message_history.append(entry)
+
+            if self.debug:
+                print(f"📚 Updated message history: {len(self.message_history)} messages")
+
+        except Exception as e:
+            if self.debug:
+                print(f"❌ Error updating message history from snapshot/session: {e}")
 
     def _rebuild_chat_display(self):
         """Rebuild chat display after session loading.
@@ -2426,6 +4147,75 @@ Continue the conversation naturally, referring to the context above when relevan
                 if self.debug:
                     print(f"❌ Error updating token count from session: {e}")
 
+    def show_trace(self):
+        """Show a lightweight debug trace for the last run."""
+        host = getattr(self.llm_manager, "agent_host", None)
+        run_id = None
+        try:
+            snap = getattr(host, "snapshot", None)
+            run_id = getattr(snap, "last_run_id", None) if snap else None
+        except Exception:
+            run_id = None
+
+        rid = str(run_id or "").strip()
+        if not host or not rid:
+            QMessageBox.information(self, "Run trace", "No run is available yet.")
+            return
+
+        try:
+            ensure = getattr(host, "_ensure_ready", None)
+            if callable(ensure):
+                ensure()
+        except Exception:
+            pass
+
+        rt = getattr(host, "_runtime", None)
+        if rt is None:
+            QMessageBox.information(self, "Run trace", "Runtime is not initialized yet.")
+            return
+
+        try:
+            state = rt.get_state(rid)
+            payload = {
+                "run_id": getattr(state, "run_id", rid),
+                "status": str(getattr(state, "status", "")),
+                "workflow_id": getattr(state, "workflow_id", None),
+                "actor_id": getattr(state, "actor_id", None),
+                "session_id": getattr(state, "session_id", None),
+                "waiting": str(getattr(state, "waiting", None) or ""),
+                "error": str(getattr(state, "error", None) or ""),
+                "vars_keys": sorted(list(getattr(state, "vars", {}).keys())) if isinstance(getattr(state, "vars", None), dict) else [],
+                "output_keys": sorted(list(getattr(state, "output", {}).keys())) if isinstance(getattr(state, "output", None), dict) else [],
+            }
+
+            details_obj = {
+                "summary": payload,
+                "vars": getattr(state, "vars", None),
+                "output": getattr(state, "output", None),
+            }
+            details_txt = json.dumps(details_obj, ensure_ascii=False, indent=2, default=str)
+            if len(details_txt) > 20000:
+                details_txt = details_txt[:20000] + "\n…(truncated)…"
+
+            box = QMessageBox(self)
+            box.setWindowTitle("Run trace")
+            box.setIcon(QMessageBox.Icon.Information)
+            box.setText("Last run trace (summary).")
+            box.setInformativeText(
+                "\n".join(
+                    [
+                        f"Run ID: {payload['run_id']}",
+                        f"Status: {payload['status']}",
+                        f"Workflow: {payload['workflow_id']}",
+                        f"Actor: {payload['actor_id']}",
+                    ]
+                )
+            )
+            box.setDetailedText(details_txt)
+            box.exec()
+        except Exception as e:
+            QMessageBox.warning(self, "Run trace", f"Failed to load trace:\n{e}")
+
     def _show_history_if_voice_mode_off(self):
         """Show chat history only if voice mode is OFF."""
         if not self._should_show_chat_history():
@@ -2767,6 +4557,14 @@ Continue the conversation naturally, referring to the context above when relevan
             if self.debug:
                 print("🔊 QtChatBubble: Speech ended, setting ready status")
             self.status_callback("ready")
+
+        # Voice loop: allow next transcription after speaking ends.
+        if self._is_full_voice_running():
+            self._voice_busy = False
+            try:
+                self.update_status("LISTENING")
+            except Exception:
+                pass
     
     @pyqtSlot()
     def _execute_tts_completion_callbacks(self):
@@ -2786,6 +4584,8 @@ Continue the conversation naturally, referring to the context above when relevan
                 self._tts_completion_callback = None
     
     
+    # NOTE: The message input row now owns sizing of the square action buttons via `_MessageInputRow`.
+
     def closeEvent(self, event):
         """Handle close event."""
         if self.worker and self.worker.isRunning():