dreadnode 2.0.24__tar.gz → 2.0.25__tar.gz

{dreadnode-2.0.24 → dreadnode-2.0.25}/PKG-INFO

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

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/agents/agent.py

@@ -118,7 +118,16 @@ def _is_transient_api_error(error: BaseException) -> bool:
             if (cls := getattr(_litellm_exc, name, None)) is not None
         )
         if classes and isinstance(error, classes):
-            return True
+            # OpenAI returns 429 with code "insufficient_quota" when the
+            # account is out of credits — a permanent billing condition,
+            # not a rate limit. litellm packs the provider body into the
+            # message verbatim, so substring-match to exclude.
+            rate_limit_cls = getattr(_litellm_exc, "RateLimitError", None)
+            return not (
+                rate_limit_cls is not None
+                and isinstance(error, rate_limit_cls)
+                and "insufficient_quota" in str(error)
+            )
     return False
 
 

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/agents/skills.py

@@ -348,9 +348,9 @@ def discover_skills(directory: Path | None = None) -> list[Skill]:
                 try:
                     skill = load_skill(skill_file)
                     skills.append(skill)
-                    logger.debug(f"Discovered skill: {skill.name} at {skill_file}")
+                    logger.debug("Discovered skill: {} at {}", skill.name, skill_file)
                 except Exception as e:
-                    logger.warning(f"Failed to load skill from {skill_file}: {e}")
+                    logger.error("Failed to load skill from {}: {}", skill_file, e)
 
     return skills
 
@@ -515,7 +515,7 @@ def create_skill_tool(skills: list[Skill]) -> t.Any:
     examples = ", ".join(f"'{s.qualified_id}'" for s in skills[:3])
     hint = f" (e.g., {examples}, ...)" if examples else ""
 
-    @tool(catch=True, description=description)
+    @tool(description=description)
     async def skill(
         name: t.Annotated[str, f"The name of the skill from available_skills{hint}"],
     ) -> str:

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/agents/subagent.py

@@ -95,7 +95,7 @@ class SubAgentToolset(Toolset):
     run_in_background: bool = Config(default=False)
     """Whether to run sub-agents in background (not yet implemented)."""
 
-    @tool_method(catch=True)
+    @tool_method
     async def spawn_agent(
         self,
         task: t.Annotated[str, "The task for the sub-agent to complete"],

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/agents/tools.py

@@ -288,15 +288,13 @@ class Tool(BaseModel, t.Generic[P, R]):
         exclude=True,
     )
     """The function to call."""
-    catch: bool | t.Iterable[type[Exception]] = set(DEFAULT_CATCH_EXCEPTIONS)
+    catch: bool | t.Iterable[type[Exception]] = True
     """
     Whether to catch exceptions and return them as messages.
 
     - `False`: Do not catch exceptions.
-    - `True`: Catch all exceptions.
+    - `True`: Catch all exceptions (default).
     - `set[type[Exception]]`: Catch only the specified exceptions.
-
-    By default, catches `json.JSONDecodeError` and `ValidationError`.
     """
     truncate: int | None = None
     """If set, the maximum number of characters to truncate any tool output to."""
@@ -386,7 +384,7 @@ class Tool(BaseModel, t.Generic[P, R]):
             description=description,
             parameters_schema=schema,
             fn=fn,
-            catch=catch or DEFAULT_CATCH_EXCEPTIONS,
+            catch=True if catch is None else catch,
             truncate=truncate,
             offload=offload if offload is not None else True,
         )
@@ -471,8 +469,15 @@ class Tool(BaseModel, t.Generic[P, R]):
                 kwargs = self._type_adapter.validate_python(kwargs)
             kwargs = kwargs or {}
 
-            # Call the function
-            result = self.fn(**kwargs)  # ty: ignore[missing-argument]  # ParamSpec limitation
+            # Call the function. Sync tools are offloaded to a worker thread
+            # so blocking work (subprocess.run, network, large file I/O) does
+            # not stall the event loop — the TUI shares that loop with input
+            # parsing, and a multi-second block desyncs Textual's escape-
+            # sequence parser, leaking raw mouse/key bytes into the composer.
+            if inspect.iscoroutinefunction(self.fn):
+                result = self.fn(**kwargs)  # ty: ignore[missing-argument]  # ParamSpec limitation
+            else:
+                result = await asyncio.to_thread(self.fn, **kwargs)  # ParamSpec limitation
             if inspect.isawaitable(result):
                 result = await result
 
@@ -596,9 +601,9 @@ class Tool(BaseModel, t.Generic[P, R]):
             description: The description of the tool.
             catch: Whether to catch exceptions and return them as messages.
                 - `False`: Do not catch exceptions.
-                - `True`: Catch all exceptions.
+                - `True`: Catch all exceptions (default).
                 - `list[type[Exception]]`: Catch only the specified exceptions.
-                - `None`: By default, catches `json.JSONDecodeError` and `ValidationError
+                - `None`: Use the default (`True`)
             truncate: If set, the maximum number of characters to truncate any tool output to.
             offload: Whether large tool outputs should be offloaded to disk.
 
@@ -667,7 +672,7 @@ class ToolMethod(property, t.Generic[P, R]):
                 name=self.tool_name,
                 description=self.tool_description,
                 parameters_schema=self.tool_parameters_schema,
-                catch=self.tool_catch or DEFAULT_CATCH_EXCEPTIONS,
+                catch=True if self.tool_catch is None else self.tool_catch,
                 truncate=self.tool_truncate,
             )
             tool._signature = self._tool_signature
@@ -681,7 +686,7 @@ class ToolMethod(property, t.Generic[P, R]):
             name=self.tool_name,
             description=self.tool_description,
             parameters_schema=self.tool_parameters_schema,
-            catch=self.tool_catch or DEFAULT_CATCH_EXCEPTIONS,
+            catch=True if self.tool_catch is None else self.tool_catch,
             truncate=self.tool_truncate,
         )
         bound_tool._signature = self._tool_signature
@@ -835,9 +840,9 @@ def tool(
         description: The description of the tool.
         catch: Whether to catch exceptions and return them as messages.
             - `False`: Do not catch exceptions.
-            - `True`: Catch all exceptions.
+            - `True`: Catch all exceptions (default).
             - `list[type[Exception]]`: Catch only the specified exceptions.
-            - `None`: By default, catches `json.JSONDecodeError` and `ValidationError`.
+            - `None`: Use the default (`True`).
         truncate: If set, the maximum number of characters to truncate any tool output to.
 
     Returns:
@@ -908,9 +913,9 @@ def tool_method(
         description: Override the tool's description. Defaults to the docstring.
         catch: Whether to catch exceptions and return them as messages.
             - `False`: Do not catch exceptions.
-            - `True`: Catch all exceptions.
+            - `True`: Catch all exceptions (default).
             - `list[type[Exception]]`: Catch only the specified exceptions.
-            - `None`: By default, catches `json.JSONDecodeError` and `ValidationError`.
+            - `None`: Use the default (`True`).
         truncate: The maximum number of characters for the tool's output.
     """
 

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/airt/assessment.py

@@ -128,9 +128,12 @@ class Assessment:
         self.judge_model = judge_model or model
 
         if target_config is None and model is not None:
-            target_config = {"model": model}
+            target_config = {"model": self.target_model or model}
         if attacker_config is None and model is not None:
-            attacker_config = {"model": model, "evaluator_model": model}
+            attacker_config = {
+                "model": self.attacker_model or model,
+                "evaluator_model": self.judge_model or model,
+            }
 
         self.target_config = target_config
         self.attacker_config = attacker_config

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/cli/airt.py

@@ -1243,6 +1243,9 @@ def run(
             description=f"CLI attack: {goal}",
             target=target_fn,
             model=atk_model,
+            target_model=target_model,
+            attacker_model=atk_model,
+            judge_model=eval_model,
             goal=goal,
             goal_category=goal_category,
             project_id=final_project_id,
@@ -1440,6 +1443,9 @@ def run_suite(
                 description=f"Suite run: {goal_text}",
                 target=target_fn,
                 model=atk_model,
+                target_model=model,
+                attacker_model=atk_model,
+                judge_model=atk_model,
                 goal=goal_text,
                 goal_category=goal_cat,
                 project_id=final_project_id,

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/cli/capability.py

@@ -1398,15 +1398,22 @@ def validate(
             cap = Capability(cap_dir)
             agents = cap.agents
             tools = cap.tools
-            skills = cap.skills_paths or []
             mcp = cap.mcp_server_defs
             workers = cap.worker_defs
 
             health_errors = [h for h in cap.component_health if h.get("status") == "error"]
+            # Count loadable skills (one SKILL.md per skill), not manifest path
+            # entries — `skills_paths` is a list of search roots and overstates
+            # the count, especially when entries fail to parse.
+            skill_count = sum(
+                1
+                for h in cap.component_health
+                if h.get("kind") == "skill" and h.get("status") == "ok"
+            )
 
             summary = (
                 f"agents={len(agents)}, tools={len(tools)}, "
-                f"skills={len(skills)}, mcp={len(mcp)}, workers={len(workers)}"
+                f"skills={skill_count}, mcp={len(mcp)}, workers={len(workers)}"
             )
 
             if health_errors:

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/client/runtime_client.py

@@ -513,13 +513,6 @@ class RuntimeClient:
         response.raise_for_status()
         return models.SessionInfo.from_dict(response.json())
 
-    async def reset_session(self, session_id: str) -> None:
-        """Reset a server session."""
-        logger.info("Resetting session | session_id={}", session_id[:8])
-        await self.start()
-        response = await self._http_client.post(f"/api/sessions/{session_id}/reset")
-        response.raise_for_status()
-
     async def set_session_title(self, session_id: str, title: str) -> None:
         """Persist a session title on the server."""
         logger.info("Setting session title | session_id={}", session_id[:8])

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/server/app.py

@@ -2201,16 +2201,6 @@ class SessionRuntime:
         """Async wrapper around ``_persist_state`` with per-session locking."""
         await self.persistence.persist_state_locked(update_messages=update_messages)
 
-    def reset(self, *, persist: bool = True) -> None:
-        """Reset the conversation history."""
-        from dreadnode.agents.trajectory import Trajectory as TrajectoryModel
-
-        self._trajectory = TrajectoryModel()
-        self._message_count = 0
-        self._agent = None
-        if persist:
-            self._persist_state()
-
     def restore_messages(
         self,
         messages: list[SessionMessage],
@@ -3216,16 +3206,6 @@ async def set_session_policy(session_id: str, body: dict[str, t.Any]) -> JSONRes
     )
 
 
-@app.post("/api/sessions/{session_id}/reset")
-async def reset_session(session_id: str) -> JSONResponse:
-    """Reset the agent conversation."""
-    session = get_state().get_session(session_id)
-    if session is None:
-        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
-    session.reset()
-    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."""
@@ -3897,7 +3877,10 @@ def _populate_registry(instance: t.Any) -> None:
     """Discover capabilities and install them into app state."""
     from dreadnode.builtin_capabilities import load_builtin_capabilities
     from dreadnode.capabilities import Capability
-    from dreadnode.capabilities.capability import read_local_capability_records
+    from dreadnode.capabilities.capability import (
+        read_local_capability_records,
+        read_local_capability_state,
+    )
 
     state = get_state()
     registry = capability_manager.CapabilityRegistry()
@@ -3975,6 +3958,18 @@ def _populate_registry(instance: t.Any) -> None:
     except Exception:
         logger.exception("Failed to discover capabilities")
 
+    # Bundled caps don't flow through Capability.discover(), so the
+    # disabled-state filter that runs inside discover() never touches
+    # them — they'd always load as active regardless of
+    # local-capability-state.json. Apply the same filter here so the
+    # toggle is honored. The default capability is pinned active.
+    bundled_state = read_local_capability_state(instance.storage.local_capability_state_path)
+    for name in list(registry.capabilities):
+        if name == _BUNDLED_DEFAULT_CAPABILITY:
+            continue
+        if bundled_state.get(name, True) is False:
+            registry.disabled_local[name] = registry.capabilities.pop(name)
+
     if instance.can_sync:
         try:
             registry.update_info = _check_capability_updates(

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/app.py

@@ -1008,9 +1008,6 @@ class _AppCommandActions:
             agent = self._app._selected_agent_for_new_session()
         self._app._create_new_session(agent)
 
-    def reset_active_session(self) -> None:
-        self._app._reset_active_session()
-
     def rename_session(self, title: str) -> None:
         self._app._rename_session(title)
 
@@ -1611,16 +1608,18 @@ class DreadnodeTextualApp(App[None]):
                 surface=BG,
                 panel=BG,
                 variables={
-                    # Calm markdown headers — avoid primary orange bleeding in
+                    # Calm markdown headers — avoid primary orange bleeding in.
+                    # H1-H4 share $fg so headings read against $fg-subtle body
+                    # copy; H5/H6 step down to $fg-muted.
                     "markdown-h1-color": FG,
                     "markdown-h1-text-style": "bold",
                     "markdown-h2-color": FG,
                     "markdown-h2-text-style": "bold",
-                    "markdown-h3-color": FG_SUBTLE,
+                    "markdown-h3-color": FG,
                     "markdown-h3-text-style": "bold",
-                    "markdown-h4-color": FG_SUBTLE,
+                    "markdown-h4-color": FG,
                     "markdown-h4-text-style": "bold",
-                    "markdown-h5-color": FG_MUTED,
+                    "markdown-h5-color": FG_SUBTLE,
                     "markdown-h5-text-style": "bold",
                     "markdown-h6-color": FG_MUTED,
                     "markdown-h6-text-style": "bold",
@@ -1981,15 +1980,19 @@ class DreadnodeTextualApp(App[None]):
 
     def on_key(self, event: "Key") -> None:
         """Global key routing for history and vim-style navigation."""
-        # Only handle keys on the main screen where composer/conversation exist
-        composer_results = self.screen.query(ComposerInput)
-        conversation_results = self.screen.query(ConversationView)
-        if not len(composer_results) or not len(conversation_results):
+        # Only handle keys on the main screen where composer/conversation exist.
+        # ID-based lookup goes through Textual's _nodes_by_id index (O(1));
+        # the old class-based screen.query(ComposerInput) walked the entire
+        # screen DOM and cost ~40ms per keystroke at ~120 conversation entries.
+        screen = self.screen
+        try:
+            composer = screen.query_one("#composer", ComposerInput)
+            conversation = screen.query_one("#conversation", ConversationView)
+        except NoMatches:
             return
-        composer = composer_results.first()
 
-        # Overlay routing fallback — when the composer is disabled (e.g. during
-        # profile recovery), route keys to the active overlay directly.
+        # Overlay routing fallback — when the composer is disabled (e.g.
+        # during profile recovery), route keys to the active overlay directly.
         if composer.disabled and self._has_active_overlay():
             overlay = composer._get_active_overlay()
             if overlay is not None:
@@ -2015,7 +2018,6 @@ class DreadnodeTextualApp(App[None]):
                 # Forward unhandled keys to the overlay for custom handling
                 if overlay.on_key(event):
                     return
-        conversation = conversation_results.first()
 
         # ? shows help when conversation is focused (composer handled via HelpRequested)
         if event.key == "question_mark" and conversation.has_focus:
@@ -2962,31 +2964,6 @@ class DreadnodeTextualApp(App[None]):
         else:
             self._flash("Interactive mode restored", severity="info")
 
-    @work(exclusive=True, group="session-switch")
-    async def _reset_active_session(self) -> None:
-        session = self._active_session()
-        if session is None:
-            self._flash("No active session to reset", severity="warning")
-            return
-        logger.info("Session reset | session={}", session.info.session_id[:8])
-        await self.managed_client.reset_session(session.info.session_id)
-        session.transcript.clear()
-        session.info.message_count = 0
-        session.turn_count = 0
-        session.queued_messages.clear()
-        session.allowlisted_tools.clear()
-        session.turn_state = TurnState.empty(session.info.session_id)
-        session.unread_events = 0
-        session.inline_activity = None
-        await self._sync_runtime_session_subscriptions()
-
-        self._sync_conversation()
-        self._sync_active_session_projection()
-        self._sync_sessions()
-        self._sessions_manager.sync_queue()
-        display = session.info.session_id[:8]
-        self._flash(f"Reset session {display}", severity="info")
-
     async def _update_command(self) -> None:
         """Handle /update — check for updates and run upgrade."""
         import asyncio
@@ -3284,7 +3261,7 @@ class DreadnodeTextualApp(App[None]):
         # ``phase`` to GENERATING/RUNNING_TOOLS. Without this reset,
         # ``sync_progress_indicator`` sees ``phase=IDLE`` with non-empty
         # ``tool_runs`` and keeps the spinner up as "thinking between
-        # tool_end and next generation". Mirrors ``/reset``.
+        # tool_end and next generation".
         session.turn_state = TurnState.empty(session_id)
         self._sync_active_session_projection()
 

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/command_dispatcher.py

@@ -166,8 +166,6 @@ class CommandActions(t.Protocol):
 
     def create_new_session(self, agent: str | None = None) -> None: ...
 
-    def reset_active_session(self) -> None: ...
-
     def rename_session(self, title: str) -> None: ...
 
     def export_session(self, filename: str | None) -> None: ...
@@ -299,8 +297,8 @@ class CommandDispatcher:
             "q": self._actions.exit_app,
             "help": self._actions.show_help,
             "new": lambda: self._actions.create_new_session(),
-            "reset": lambda: self._actions.reset_active_session(),
-            "clear": lambda: self._actions.reset_active_session(),
+            "clear": lambda: self._actions.create_new_session(),
+            "reset": lambda: self._actions.create_new_session(),
             "sessions": self._actions.screen_router_open_sessions,
             "agents": self._actions.write_agent_listing,
             "reload": lambda: self._actions.run_command(self.reload_capabilities_command),

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/commands.py

@@ -32,8 +32,7 @@ class SlashCommand:
 SLASH_COMMANDS: list[SlashCommand] = [
     SlashCommand("/help", "Show available commands"),
     SlashCommand("/new", "Create a new session"),
-    SlashCommand("/reset", "Reset current session"),
-    SlashCommand("/clear", "Alias for /reset"),
+    SlashCommand("/clear", "Alias for /new"),
     SlashCommand("/sessions", "List all sessions"),
     SlashCommand("/agents", "List loaded agents"),
     SlashCommand("/agent", "Start agent session", "<name>"),

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/dreadnode.tcss

@@ -748,23 +748,16 @@ ToolCall {
     color: $fg-subtle;
 }
 
-/* Headers — theme variables control color/text-style; we only set margins here
- * to keep a clear hierarchy without overriding the theme-driven palette. */
-MarkdownH1 {
-    margin: 1 0 1 0;
-}
-
-MarkdownH2 {
-    margin: 1 0 0 0;
-    border-bottom: solid $border;
-    padding-bottom: 1;
-}
-
+/* Headers — colors come from theme variables; here we only set margins.
+ * Headings own the gap *below* them so adjacent blocks don't double-up
+ * (a list with bottom-margin + a heading with top-margin = 2 rows). */
+MarkdownH1,
+MarkdownH2,
 MarkdownH3,
 MarkdownH4,
 MarkdownH5,
 MarkdownH6 {
-    margin: 1 0 0 0;
+    margin: 0 0 1 0;
 }
 
 /* Paragraphs */
@@ -775,7 +768,7 @@ Markdown > MarkdownParagraph {
 /* Code — fenced blocks and inline */
 MarkdownFence {
     background: $bg-lighter;
-    margin: 1 0;
+    margin: 0 0 1 0;
 }
 
 MarkdownBlock > .code_inline {
@@ -787,7 +780,7 @@ MarkdownBlock > .code_inline {
 MarkdownBlockQuote {
     background: $bg-light;
     border-left: outer $border-light;
-    margin: 1 0;
+    margin: 0 0 1 0;
     padding: 0 1;
 }
 

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/screens/capabilities.py

@@ -296,10 +296,13 @@ def _build_actions(
         elif update_ver and is_sandbox and item.get("binding_id"):
             actions.append(("update", f"Update to v{update_ver}"))
 
-        if state == "enabled":
-            actions.append(("toggle", "Disable capability"))
-        else:
-            actions.append(("toggle", "Enable capability"))
+        # The default bundled capability provides the active agent and
+        # tool surface — disabling it from the UI would brick the runtime.
+        if item.get("name") != "dreadnode":
+            if state == "enabled":
+                actions.append(("toggle", "Disable capability"))
+            else:
+                actions.append(("toggle", "Enable capability"))
 
         if item.get("local_path"):
             actions.append(("browse_files", "Browse files"))
@@ -1383,7 +1386,11 @@ class CapabilitiesScreen(DreadnodeScreen):
                         ],
                         "components": {
                             "agents": len(agents),
-                            "skills": len(cap.skills_paths or []),
+                            "skills": sum(
+                                1
+                                for h in cap.component_health
+                                if h.get("kind") == "skill" and h.get("status") == "ok"
+                            ),
                             "mcp_servers": len(cap.mcp_server_defs),
                         },
                         "update_available": None,

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/screens/console.py

@@ -40,6 +40,9 @@ _LEVEL_COLORS: dict[str, str] = {
 }
 
 _LEVELS = ["TRACE", "DEBUG", "INFO", "SUCCESS", "WARNING", "ERROR", "CRITICAL"]
+# Cap per-entry rendered length so cycling to TRACE doesn't freeze the UI on
+# full LLM request/response payloads. Buffer + saved log still keep the full text.
+_MAX_DISPLAY_CHARS = 2000
 # Exports share the central dreadnode logs directory alongside worker logs
 # (and, eventually, MCP + TUI/SDK self-logs).
 _LOG_EXPORT_DIR = LOGS_DIR
@@ -124,7 +127,13 @@ class ConsoleScreen(DreadnodeScreen):
         t.append(" ")
         t.append(f"{entry.level:<8}", style=color)
         t.append(f" {entry.source}", style=FG_MUTED)
-        t.append(f"  {entry.message}")
+        msg = entry.message
+        if len(msg) > _MAX_DISPLAY_CHARS:
+            extra = len(msg) - _MAX_DISPLAY_CHARS
+            t.append(f"  {msg[:_MAX_DISPLAY_CHARS]}")
+            t.append(f" …[+{extra:,} chars]", style=FG_FAINTEST)
+        else:
+            t.append(f"  {msg}")
         return t
 
     def _title_markup(self) -> str:
@@ -141,7 +150,10 @@ class ConsoleScreen(DreadnodeScreen):
         self.dismiss()
 
     def action_cycle_level(self) -> None:
-        self._level_index = (self._level_index + 1) % len(_LEVELS)
+        # Cycle toward more-verbose first (INFO → DEBUG → TRACE …) so the
+        # common "I want a bit more detail" step doesn't have to wrap through
+        # WARNING/ERROR/CRITICAL.
+        self._level_index = (self._level_index - 1) % len(_LEVELS)
         level = _LEVELS[self._level_index]
         self._min_level_no = self._resolve_level_no(level)
         self._refresh_log()
@@ -165,7 +177,7 @@ class ConsoleScreen(DreadnodeScreen):
         ]
         _LOG_EXPORT_DIR.mkdir(parents=True, exist_ok=True)
         output_path = _LOG_EXPORT_DIR / filename
-        output_path.write_text("\n".join(lines), encoding="utf-8")
+        output_path.write_text("\n".join(lines), encoding="utf-8", errors="replace")
         self.notify(f"Saved to {output_path}")
 
     def action_clear_logs(self) -> None:

{dreadnode-2.0.24 → dreadnode-2.0.25}/dreadnode/app/tui/sessions_manager.py

@@ -1699,6 +1699,28 @@ class SessionsManager:
                 envelope_status or "ok",
                 error_text or "none",
             )
+            if is_active_session:
+                # Perf telemetry — log one summary line per turn so we can
+                # see how rendering cost correlates with session length.
+                # See widgets/conversation.py:perf_snapshot_and_reset.
+                try:
+                    conv = self._ui.query_conversation()
+                    draft = self._ui.query_draft()
+                    entries, vsize_changes = conv.perf_snapshot_and_reset()
+                    tok_n, tok_p50, tok_p95, tok_max = draft.perf_snapshot_and_reset()
+                    logger.info(
+                        "TUI perf | session={} | entries={} | vsize_events={} "
+                        "| tokens={} | tok_us_p50={:.0f} | tok_us_p95={:.0f} | tok_us_max={:.0f}",
+                        session_id[:8],
+                        entries,
+                        vsize_changes,
+                        tok_n,
+                        tok_p50,
+                        tok_p95,
+                        tok_max,
+                    )
+                except Exception:
+                    logger.opt(exception=True).debug("TUI perf snapshot failed")
             if error_text:
                 logger.error(
                     "Agent ended with error: {} (type={})",