dreadnode 2.0.4__tar.gz → 2.0.5__tar.gz

{dreadnode-2.0.4 → dreadnode-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.4
+Version: 2.0.5
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/agents/events.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 from uuid import UUID, uuid4
 
 import typing_extensions as te
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, PlainSerializer, WithJsonSchema
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.panel import Panel
 from rich.rule import Rule
@@ -55,6 +55,14 @@ if t.TYPE_CHECKING:
 AgentEventT = te.TypeVar("AgentEventT", bound="AgentEvent", default="AgentEvent")
 AgentStepT = te.TypeVar("AgentStepT", bound="AgentStep", default="AgentStep")
 AgentStopReason = t.Literal["finished", "max_steps_reached", "error", "stalled"]
+
+# Reusable annotation for error fields that store raw exception objects.
+# Pydantic can't serialize exceptions to JSON, so we coerce to str on serialization.
+# Same pattern as dreadnode.generators.chat.Chat.error.
+_ErrorSerializer = PlainSerializer(lambda x: str(x), return_type=str, when_used="json-unless-none")
+_ErrorJsonSchema = WithJsonSchema({"type": "string", "description": "Error message"})
+SerializableError = t.Annotated[BaseException, _ErrorSerializer, _ErrorJsonSchema]
+SerializableException = t.Annotated[Exception, _ErrorSerializer, _ErrorJsonSchema]
 AgentStatus = t.Literal["running", "stalled", "errored", "finished"]
 
 
@@ -139,7 +147,7 @@ class AgentStep(AgentEvent):
     step: int = 0
     messages: list[Message] = Field(default_factory=list)
     usage: Usage = Usage(input_tokens=0, output_tokens=0, total_tokens=0)
-    error: Exception | None = None
+    error: SerializableException | None = None
     stop: bool | None = None
 
     @property
@@ -231,7 +239,7 @@ class AgentEnd(AgentEvent):
     """
 
     stop_reason: AgentStopReason
-    error: Exception | str | None = None
+    error: SerializableException | str | None = None
 
     def _get_data(self) -> dict[str, t.Any]:
         error = self.error
@@ -336,7 +344,7 @@ class AgentError(AgentEvent):
         error: The error that occurred during the agent's execution.
     """
 
-    error: BaseException
+    error: SerializableError
 
     def _get_data(self) -> dict[str, t.Any]:
         return {
@@ -543,7 +551,7 @@ class ToolError(AgentEvent):
     """
 
     tool_call: ToolCall
-    error: BaseException
+    error: SerializableError
 
     def _get_data(self) -> dict[str, t.Any]:
         return {
@@ -817,7 +825,7 @@ class GenerationError(AgentEvent):
     """
 
     generator: Generator | None = None
-    error: BaseException
+    error: SerializableError
     step: int = 0
     messages: list["Message"] = Field(default_factory=list)
 

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/main.py

@@ -1926,6 +1926,8 @@ class Dreadnode:
 
                 remote_sha = remote_digests.get(env_name)
                 if not force and remote_sha and remote_sha == local_sha:
+                    if public:
+                        self.api.update_task_visibility(org, env_name, is_public=True)
                     with lock:
                         result.skipped.append(env_name)
                     if on_progress:

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/server/app.py

@@ -60,7 +60,7 @@ if t.TYPE_CHECKING:
     from dreadnode.storage import SessionRecord, SessionStore
 
 EventPayload = dict[str, t.Any]
-_TERMINAL_CHAT_EVENT_TYPES = frozenset({"agentend", "error"})
+_TERMINAL_CHAT_EVENT_TYPES = frozenset({"agentend", "error", "cancelled"})
 DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514"
 _DREADNODE_LLM_BASE_ENV = "DREADNODE_LLM_BASE"
 _DREADNODE_LLM_API_KEY_ENV = "DREADNODE_LLM_API_KEY"
@@ -1827,6 +1827,28 @@ class SessionRuntime:
         if self._processing_task is not None and not self._processing_task.done():
             self._processing_task.cancel()
 
+    async def cancel(self) -> bool:
+        """Cancel the active turn and drain queued requests.
+
+        Returns True if a running turn was cancelled, False if already idle.
+        """
+        was_busy = False
+        if self._processing_task is not None and not self._processing_task.done():
+            self._processing_task.cancel()
+            was_busy = True
+            # Wait for the task to finish its cancellation cleanup
+            with suppress(asyncio.CancelledError):
+                await self._processing_task
+
+        # Drain any queued requests so their SSE connections terminate
+        async with self._queue_lock:
+            while self._queue:
+                queued = self._queue.popleft()
+                await queued.event_queue.put(None)
+            self._processing_task = None
+
+        return was_busy
+
     def persist_manifest(self) -> None:
         """Persist minimal runtime metadata needed to rebind the session."""
         self._ensure_session_dir()
@@ -1906,6 +1928,7 @@ class SessionRuntime:
             )
             _log_chat_timing(self.session_id, "processor_start", request.queued_at_monotonic)
 
+            cancelled = False
             try:
                 if request.model is not None and request.model != self.model:
                     self.model = request.model
@@ -2005,13 +2028,25 @@ class SessionRuntime:
                 # Clear cached agent so restore paths create fresh
                 self._agent = None
                 self._persist_state()
+            except asyncio.CancelledError:
+                cancelled = True
+                logger.info("Session {}: turn cancelled by user", self.session_id[:8])
+                # Persist whatever trajectory we have so far
+                self._agent = None
+                self._persist_state()
+                await request.event_queue.put(
+                    {"type": "cancelled", "data": {"reason": "user_interrupt"}}
+                )
+                # Don't re-raise — let the method exit cleanly so cancel() can drain remaining queue
+                return
             except Exception as exc:
                 logger.exception("Error during chat for session {}", self.session_id)
                 await request.event_queue.put({"type": "error", "error": str(exc)})
             finally:
                 logger.debug("Session {}: chat turn complete", self.session_id[:8])
                 _log_chat_timing(self.session_id, "processor_complete", request.queued_at_monotonic)
-                await request.event_queue.put(None)
+                if not cancelled:
+                    await request.event_queue.put(None)
 
     def _first_user_preview(self, max_len: int = 200) -> str | None:
         """Extract preview text from the first user message in the trajectory."""
@@ -2229,6 +2264,21 @@ async def reset_session(session_id: str) -> JSONResponse:
     return JSONResponse(content={"status": "reset", "session_id": session_id})
 
 
+@app.post("/api/sessions/{session_id}/cancel")
+async def cancel_session(session_id: str) -> JSONResponse:
+    """Cancel the active turn and drain queued requests for a session."""
+    session = get_state().get_session(session_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    was_busy = await session.cancel()
+    return JSONResponse(
+        content={
+            "status": "cancelled" if was_busy else "idle",
+            "session_id": session_id,
+        }
+    )
+
+
 @app.post("/api/sessions/{session_id}/compact")
 async def compact_session(session_id: str, body: dict[str, t.Any] | None = None) -> JSONResponse:
     """Compact a session's conversation history (CMP-API-001)."""

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/app.py

@@ -404,6 +404,7 @@ class DreadnodeTextualApp(App[None]):
             yield ConversationView(
                 id="conversation",
             )
+            yield ToolProgress(id="tool-progress")
             yield PermissionPrompt(id="human-prompt")
             yield SlashOverlay(id="slash-overlay")
             yield MentionOverlay(id="mention-overlay")
@@ -430,7 +431,7 @@ class DreadnodeTextualApp(App[None]):
             logger.opt(exception=True).debug("Could not import VERSION")
             version = ""
         else:
-            version = VERSION
+            version = f"v{VERSION}"
         welcome = Welcome(id="welcome")
         welcome.version = version
         welcome.working_dir = str(Path.cwd())
@@ -617,7 +618,7 @@ class DreadnodeTextualApp(App[None]):
                     record.transcript.append(entry)
                 conv.append_entry(entry)
             self._set_status("Thinking", busy=True)
-            conv.query_one(ToolProgress).show_activity("thinking")
+            self.query_one("#tool-progress", ToolProgress).show_activity("thinking")
             self._send_chat(value, _user_entry_shown=session is not None)
 
     def _submit_human_prompt_response(self, prompt: HumanPrompt, raw_value: str) -> None:
@@ -810,11 +811,14 @@ class DreadnodeTextualApp(App[None]):
     @on(SlashOverlay.SlashSelected)
     def _on_slash_selected(self, event: SlashOverlay.SlashSelected) -> None:
         composer = self.query_one("#composer", ComposerInput)
-        # Commands without a hint take no args — execute immediately
         from dreadnode.app.tui.commands import SLASH_COMMANDS
 
         cmd_def = next((c for c in SLASH_COMMANDS if c.name == event.command), None)
-        if cmd_def and not cmd_def.hint:
+        # Builtins without a hint and all skills take no args — execute immediately
+        is_skill = cmd_def is None and any(
+            name == event.command.lstrip("/") for name, _ in self._skill_names
+        )
+        if is_skill or (cmd_def and not cmd_def.hint):
             composer.load_text("")
             self._handle_command(event.command)
             return
@@ -1145,6 +1149,7 @@ class DreadnodeTextualApp(App[None]):
                 self._last_quit_time = now
                 return
             self.workers.cancel_group(self, "session")
+            self._cancel_server_turn()
             self._commit_draft_to_transcript(self.active_session_id or "")
             self._set_status("Interrupted", busy=False)
             self._set_composer_enabled(True)
@@ -1196,6 +1201,7 @@ class DreadnodeTextualApp(App[None]):
                 self._flash("Prompt cancelled", severity="warning")
                 return
             self.workers.cancel_group(self, "session")
+            self._cancel_server_turn()
             self._commit_draft_to_transcript(self.active_session_id or "")
             self._set_status("Interrupted", busy=False)
             self._set_composer_enabled(True)
@@ -1206,6 +1212,20 @@ class DreadnodeTextualApp(App[None]):
         # 5. Nothing to do — just ensure composer has focus
         composer.focus()
 
+    def _cancel_server_turn(self) -> None:
+        """Fire-and-forget: tell the server to cancel the active turn."""
+        sid = self.active_session_id
+        if not sid:
+            return
+
+        async def _do_cancel() -> None:
+            try:
+                await self.server_client.cancel_session(sid)
+            except Exception:
+                logger.debug("Server cancel request failed (session may already be idle)")
+
+        asyncio.get_running_loop().create_task(_do_cancel())
+
     def _require_authenticated(self) -> bool:
         if not self.authenticated:
             self._flash("Not authenticated", severity="warning")
@@ -1269,7 +1289,7 @@ class DreadnodeTextualApp(App[None]):
 
         resolved_url = server_url or self._resolved_server_url()
         update_banner = (
-            f"Update available: {VERSION} \u2192 {self.update_available} \u2014 press F9 to update now, or /update after login"
+            f"Update available: v{VERSION} \u2192 v{self.update_available} \u2014 press F9 to update now, or /update after login"
             if self.update_available
             else None
         )
@@ -1354,7 +1374,7 @@ class DreadnodeTextualApp(App[None]):
 
             screen = self.screen
             if isinstance(screen, AuthModal):
-                banner = f"Update available: {VERSION} \u2192 {info.latest} \u2014 press F9 to update now, or /update after login"
+                banner = f"Update available: v{VERSION} \u2192 v{info.latest} \u2014 press F9 to update now, or /update after login"
                 screen.query_one("#auth-update-banner", Static).update(f"[bold yellow]{banner}[/]")
         except Exception:
             logger.opt(exception=True).debug("Failed to update auth modal banner")
@@ -1959,7 +1979,7 @@ class DreadnodeTextualApp(App[None]):
                 self._flash("Failed to create a session", severity="error")
                 return
 
-        tp = self.query_one(ConversationView).query_one(ToolProgress)
+        tp = self.query_one("#tool-progress", ToolProgress)
         if not _user_entry_shown:
             self._set_status("Thinking", busy=True)
             tp.show_activity("thinking")
@@ -2033,7 +2053,7 @@ class DreadnodeTextualApp(App[None]):
             TranscriptEntry(kind="user", title="shell", body=f"$ {command}"), sid
         )
         self._set_status("Running", busy=True)
-        tp = self.query_one(ConversationView).query_one(ToolProgress)
+        tp = self.query_one("#tool-progress", ToolProgress)
         tp.show_activity("running")
         try:
             result = await self.server_client.execute_shell(command)
@@ -2073,7 +2093,7 @@ class DreadnodeTextualApp(App[None]):
             return
         # Inline the chat logic to avoid nesting @work calls
         self._set_status("Thinking", busy=True)
-        tp = self.query_one(ConversationView).query_one(ToolProgress)
+        tp = self.query_one("#tool-progress", ToolProgress)
         tp.show_activity("thinking")
 
         logger.info(
@@ -2211,6 +2231,30 @@ class DreadnodeTextualApp(App[None]):
     # Event handling
     # ==================================================================
 
+    def _sync_progress_indicator(self, state: TurnState) -> None:
+        """Update the progress indicator based on current turn state."""
+        tp = self.query_one("#tool-progress", ToolProgress)
+        running = [r for r in state.tool_runs.values() if r.status == "running"]
+
+        if state.phase == "running_tools" and running:
+            if len(running) == 1:
+                tp.show_tool(running[0].tool_name)
+            else:
+                tp.show_activity(f"running {len(running)} tools")
+        elif state.phase == "generating":
+            if self._draft_active:
+                tp.show_activity("streaming")
+            else:
+                tp.show_activity("thinking")
+        elif state.phase in ("completed", "failed", "idle"):
+            # Idle between tool_end and next generation — show thinking
+            # unless the turn is actually done
+            if state.phase == "idle" and state.tool_runs:
+                tp.show_activity("thinking")
+            else:
+                tp.hide_tool()
+        # awaiting_permission / awaiting_input — keep current state
+
     def _handle_event(self, event: dict[str, t.Any], session_id: str) -> None:
         normalized = normalize_event(event, session_id)
         prev_state = self._turn_state.get(session_id, TurnState.empty(session_id))
@@ -2223,6 +2267,10 @@ class DreadnodeTextualApp(App[None]):
         if normalized.usage_total_tokens is not None:
             self.total_tokens = max(self.total_tokens, normalized.usage_total_tokens)
 
+        if event_type == "cancelled":
+            logger.debug("Server confirmed turn cancellation for session {}", session_id[:8])
+            return
+
         if event_type == "generation_step":
             # Render reasoning/thinking content (expanded, muted, left-border)
             if normalized.reasoning_content and self._show_thinking:
@@ -2242,16 +2290,21 @@ class DreadnodeTextualApp(App[None]):
                     draft.start_stream()
                     self._draft_active = True
                 draft.append_token(text)
-                self.query_one(ConversationView).query_one(ToolProgress).show_activity("streaming")
+            self._sync_progress_indicator(next_state)
             return
 
         if event_type == "generation_end":
             return
 
         if event_type == "tool_start":
-            self._commit_draft_to_transcript(session_id)
-            tool_name = normalized.tool_name or "tool"
-            self.query_one(ConversationView).query_one(ToolProgress).show_tool(tool_name)
+            if self._draft_active:
+                draft = self.query_one("#draft", StreamingDraft)
+                if draft._buffer.strip():
+                    self._commit_draft_to_transcript(session_id)
+                else:
+                    draft.clear_stream()
+                    self._draft_active = False
+            self._sync_progress_indicator(next_state)
             return
 
         if event_type == "tool_end":
@@ -2270,11 +2323,14 @@ class DreadnodeTextualApp(App[None]):
                 if self._tool_details_mode == "expanded"
                 else ""
             )
+            conv = self.query_one(ConversationView)
             self._append_transcript(
                 TranscriptEntry(kind="tool", title=label, body=details, meta=summary),
                 session_id,
+                scroll=False,
             )
-            self.query_one(ConversationView).query_one(ToolProgress).show_activity("thinking")
+            self._sync_progress_indicator(next_state)
+            self.call_after_refresh(conv.scroll_end, animate=False)
             return
 
         if event_type == "tool_step":
@@ -3490,8 +3546,12 @@ class DreadnodeTextualApp(App[None]):
         import subprocess
         import sys
 
+        # Sanitize: replace unrepresentable characters so encode() never raises
+        safe_text = text.encode("utf-8", errors="replace").decode("utf-8")
+
         # Try Textual's OSC 52 first (works in iTerm2, WezTerm, kitty, etc.)
-        self.copy_to_clipboard(text)
+        with contextlib.suppress(Exception):
+            self.copy_to_clipboard(safe_text)
 
         # Also try native clipboard commands as fallback
         if sys.platform == "darwin":
@@ -3504,10 +3564,10 @@ class DreadnodeTextualApp(App[None]):
             cmd = "wl-copy"
         else:
             return
-        with contextlib.suppress(subprocess.SubprocessError, FileNotFoundError):
+        with contextlib.suppress(subprocess.SubprocessError, FileNotFoundError, OSError):
             subprocess.run(  # noqa: S603 - command is selected from a fixed local allowlist
                 cmd.split(),
-                input=text.encode(),
+                input=safe_text.encode("utf-8"),
                 check=True,
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
@@ -3601,15 +3661,16 @@ class DreadnodeTextualApp(App[None]):
         self._sync_sessions()
         self._update_context()
 
-    def _append_transcript(self, entry: TranscriptEntry, session_id: str) -> None:
+    def _append_transcript(
+        self, entry: TranscriptEntry, session_id: str, *, scroll: bool = True
+    ) -> None:
         record = self.sessions.get(session_id)
         if record is None:
             return
         record.transcript.append(entry)
         if self.active_session_id == session_id:
-            self.call_after_refresh(
-                self.query_one("#conversation", ConversationView).append_entry, entry
-            )
+            conv = self.query_one("#conversation", ConversationView)
+            self.call_after_refresh(conv.append_entry, entry, scroll=scroll)
 
     def _commit_draft_to_transcript(self, session_id: str) -> None:
         """Flush live draft text into transcript and reset draft widget state."""

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/client.py

@@ -20,7 +20,7 @@ DEFAULT_SERVER_PORT = int(os.environ.get("DREADNODE_SERVER_PORT", "8787"))
 DEFAULT_SERVER_URL = f"http://{DEFAULT_SERVER_HOST}:{DEFAULT_SERVER_PORT}"
 DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514"
 DEFAULT_START_TIMEOUT_S = 20.0
-_TERMINAL_CHAT_EVENT_TYPES = frozenset({"agentend", "error"})
+_TERMINAL_CHAT_EVENT_TYPES = frozenset({"agentend", "error", "cancelled"})
 
 _SENTINEL = object()
 
@@ -623,6 +623,14 @@ class RuntimeServerClient:
         )
         response.raise_for_status()
 
+    async def cancel_session(self, session_id: str) -> None:
+        """Cancel the active turn for a session."""
+        await self.start()
+        response = await self._client.post(
+            f"/api/sessions/{session_id}/cancel",
+        )
+        response.raise_for_status()
+
     async def stream_chat(
         self,
         *,

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/dreadnode.tcss

@@ -90,22 +90,16 @@ Screen {
 
 ToolProgress {
     display: none;
-    height: auto;
-    padding-left: 0;
-    margin-top: 1;
+    height: 1;
+    padding: 0 2;
     color: $fg-faintest;
     background: $bg;
 }
 
 ToolProgress.-active {
     display: block;
-    height: 1;
-    color: $fg-subtle;
-}
-
-ToolProgress.-tool-mode {
-    padding-left: 2;
-    margin-top: 0;
+    margin-top: 1;
+    color: $fg-muted;
 }
 
 /* -- Message Queue ----------------------------------------- */

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/event_contract.py

@@ -236,6 +236,12 @@ def normalize_event(raw: dict[str, t.Any], session_id: str) -> NormalizedEvent:
             error_text=_as_str(payload.get("reason")) or "Agent stalled",
             **base,
         )
+    elif event_type == "cancelled":
+        normalized = NormalizedEvent(
+            type="cancelled",
+            error_text=_as_str(payload.get("reason")) or "Turn cancelled",
+            **base,
+        )
     elif event_type == "error":
         normalized = NormalizedEvent(
             type="runtime_error",

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/model_variants.py

@@ -18,10 +18,10 @@ import typing as t
 # ---------------------------------------------------------------------------
 
 _ANTHROPIC_VARIANTS: dict[str, dict[str, t.Any]] = {
-    "low": {"thinking": {"type": "adaptive"}, "effort": "low"},
-    "medium": {"thinking": {"type": "adaptive"}, "effort": "medium"},
-    "high": {"thinking": {"type": "adaptive"}, "effort": "high"},
-    "max": {"thinking": {"type": "adaptive"}, "effort": "max"},
+    "low": {"reasoning_effort": "low"},
+    "medium": {"reasoning_effort": "medium"},
+    "high": {"reasoning_effort": "high"},
+    "max": {"reasoning_effort": "max"},
 }
 
 _OPENAI_VARIANTS: dict[str, dict[str, t.Any]] = {
@@ -158,6 +158,7 @@ def cycle_variant(
 _MODEL_DISPLAY_NAMES: dict[str, str] = {
     # Anthropic — versioned (e.g. claude-opus-4-6) and base (e.g. claude-sonnet-4-20250514)
     "claude-opus-4-6": "Opus 4.6",
+    "claude-opus-4-5": "Opus 4.5",
     "claude-sonnet-4-5": "Sonnet 4.5",
     "claude-haiku-4-5": "Haiku 4.5",
     "claude-haiku-3-5": "Haiku 3.5",
@@ -212,10 +213,13 @@ def display_name(model: str) -> str:
     """
     bare = _strip_provider(model).lower()
 
+    # Normalize both sides: dots ↔ dashes so "claude-opus-4.5" matches "claude-opus-4-5"
+    bare_norm = bare.replace(".", "-")
     best_key: str | None = None
     for key in _MODEL_DISPLAY_NAMES:
-        if key in bare:
-            if best_key is None or len(key) > len(best_key):
+        key_norm = key.replace(".", "-")
+        if key_norm in bare_norm:
+            if best_key is None or len(key_norm) > len(best_key.replace(".", "-")):
                 best_key = key
 
     if best_key is not None:

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/turn_reducer.py

@@ -128,6 +128,8 @@ def reduce_event(
         pass  # Lifecycle signal — no phase change
     elif event.type == "tool_step":
         pass  # Intermediate tool progress — no phase change
+    elif event.type == "agent_start":
+        pass  # Agent lifecycle start — no phase change
     elif event.type == "heartbeat":
         next_state.last_heartbeat_at = event.timestamp
     elif event.type == "agent_end":

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/widgets/conversation.py

@@ -20,7 +20,6 @@ from textual.widgets import Markdown, Static
 
 from dreadnode.app.tui.theme import ACCENT, ERROR, FG, FG_FAINTEST, FG_MUTED, FG_SUBTLE
 from dreadnode.app.tui.widgets.tool import ToolCall
-from dreadnode.app.tui.widgets.tool_progress import ToolProgress
 
 if t.TYPE_CHECKING:
     from textual.app import ComposeResult
@@ -105,7 +104,6 @@ class ConversationView(VerticalScroll):
     def compose(self) -> ComposeResult:
         """Compose the content of the conversation view."""
         yield StreamingDraft(id="draft", classes="-empty")
-        yield ToolProgress(id="tool-progress")
 
     def show_empty(self) -> None:
         """Show an empty-state hint."""
@@ -140,7 +138,7 @@ class ConversationView(VerticalScroll):
             self.mount_all(widgets)
         self.call_after_refresh(self.scroll_end, animate=False)
 
-    def append_entry(self, entry: TranscriptEntry) -> None:
+    def append_entry(self, entry: TranscriptEntry, *, scroll: bool = True) -> None:
         """Add a single message to the stream."""
         # Remove empty-state hint if present
         for w in self.query("#empty-hint"):
@@ -156,7 +154,8 @@ class ConversationView(VerticalScroll):
             self.mount_all(widgets, before=draft)
         except NoMatches:
             self.mount_all(widgets)
-        self.call_after_refresh(self.scroll_end, animate=False)
+        if scroll:
+            self.call_after_refresh(self.scroll_end, animate=False)
 
     def write(self, renderable: t.Any) -> None:
         """Write a renderable to the stream."""

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/widgets/skills_dialog.py

@@ -8,7 +8,7 @@ from rich.text import Text
 from textual.message import Message
 from textual.widgets.option_list import Option
 
-from dreadnode.app.tui.theme import BRAND, FG, FG_FAINTEST, FG_MUTED
+from dreadnode.app.tui.theme import ACCENT, FG, FG_FAINTEST, FG_MUTED
 from dreadnode.app.tui.widgets.overlay_mixin import OverlayMixin
 
 
@@ -51,8 +51,8 @@ class SkillsDialog(OverlayMixin):
 
         for name, desc in skills:
             label = Text()
-            label.append(" /", style=BRAND)
-            label.append(name, style=f"bold {FG}")
+            label.append(" /", style=ACCENT)
+            label.append(name, style=FG)
             if desc:
                 truncated = desc[:60] + "\u2026" if len(desc) > 60 else desc
                 label.append(f"  {truncated}", style=FG_FAINTEST)

{dreadnode-2.0.4 → dreadnode-2.0.5}/dreadnode/app/tui/widgets/slash_overlay.py

@@ -7,7 +7,7 @@ from textual.message import Message
 from textual.widgets.option_list import Option
 
 from dreadnode.app.tui.commands import SLASH_COMMANDS, SlashCommand
-from dreadnode.app.tui.theme import BRAND, FG, FG_MUTED, FG_SUBTLE
+from dreadnode.app.tui.theme import ACCENT, FG, FG_MUTED, FG_SUBTLE
 from dreadnode.app.tui.widgets.overlay_mixin import OverlayMixin
 
 
@@ -33,6 +33,9 @@ class SlashOverlay(OverlayMixin):
         if extra_commands:
             all_commands.extend(c for c in extra_commands if c.name not in builtin_names)
 
+        # Sort all commands alphabetically so skills interleave with builtins
+        all_commands.sort(key=lambda c: c.name.lstrip("/").lower())
+
         query = prefix.lstrip("/").lower()
         matches: list[SlashCommand] = []
         for cmd in all_commands:
@@ -46,17 +49,23 @@ class SlashOverlay(OverlayMixin):
             self.add_option(Option("No matching commands", disabled=True))
             return
 
+        # Truncate labels to overlay width; fall back to container width when
+        # the overlay hasn't been laid out yet (display: none → width 0).
+        width = self.size.width or (self.container_size.width or 0) or 120
+        max_width = width - 4  # borders + scrollbar
+
         for cmd in matches:
             is_skill = cmd.name not in builtin_names
             label = Text()
             if is_skill:
-                label.append(" /", style=BRAND)
-                label.append(cmd.name.lstrip("/"), style=f"{FG}")
+                label.append(" /", style=ACCENT)
+                label.append(cmd.name.lstrip("/"), style=FG)
             else:
-                label.append(f" {cmd.name}", style=f"bold {BRAND}")
+                label.append(f" {cmd.name}", style=f"bold {ACCENT}")
             if cmd.hint:
-                label.append(f" {cmd.hint}", style=FG_MUTED)
-            label.append(f"  {cmd.description}", style=FG_SUBTLE)
+                label.append(f" {cmd.hint}", style=FG_SUBTLE)
+            label.append(f"  {cmd.description}", style=FG_MUTED)
+            label.truncate(max_width, overflow="ellipsis")
             self.add_option(Option(label, id=cmd.name))
 
         self.highlighted = 0