synapse-cli-agent 0.1.43__tar.gz → 0.1.44__tar.gz

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/.gitignore

@@ -35,6 +35,11 @@ conversation_history/
 /ear-anatomy-exploded.html
 /ear-models/
 
+# Local scratch output (untracked scratch files)
+/article-translation/
+/article_ltt.html
+/twitter-replica/
+
 # IDE
 .idea/
 .vscode/

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/CHANGELOG.md

@@ -8,6 +8,25 @@ All entries are written in English.
 
 ---
 
+## v0.1.44
+
+### New Features
+
+- Centered the topbar title and elided topbar components by width.
+
+### Bug Fixes
+
+- Slash path completion now stops once whitespace follows the active `@` token, avoiding spurious path suggestions mid-line.
+- Reworked process-tree termination: on Windows the runtime falls back to `proc.kill()` when `taskkill` fails, and on Unix it kills the whole process group so descendants cannot survive. Commands are also detached from the TUI's controlling terminal (`start_new_session` on Unix, `CREATE_NO_WINDOW` on Windows) so non-interactive tools such as `ssh` cannot block on a hidden console.
+- Re-probe git chrome after mount to retry transient probe failures.
+
+### Engineering
+
+- Ignored local scratch output files.
+- Updated the Scoop manifest.
+
+---
+
 ## v0.1.43
 
 ### New Features

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.43
+Version: 0.1.44
 Summary: Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)
 Project-URL: Homepage, https://github.com/alex8224/synapse-agent
 Project-URL: Repository, https://github.com/alex8224/synapse-agent

synapse_cli_agent-0.1.44/bucket/synapse.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.1.43",
+  "description": "Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)",
+  "homepage": "https://github.com/alex8224/synapse-agent",
+  "license": "Apache-2.0",
+  "bin": [
+    ["synapse-windows-x64.exe", "synapse"]
+  ],
+  "checkver": {
+    "github": "https://github.com/alex8224/synapse-agent"
+  },
+  "architecture": {
+    "64bit": {
+      "url": "https://github.com/alex8224/synapse-agent/releases/download/v0.1.43/synapse-windows-x64.exe",
+      "hash": "c1fcc815af508e1051440dd944dc735ce1102e98b71e4cea40f3cdd31bababd3"
+    }
+  },
+  "autoupdate": {
+    "architecture": {
+      "64bit": {
+        "url": "https://github.com/alex8224/synapse-agent/releases/download/v$version/synapse-windows-x64.exe",
+        "hash": {
+          "url": "$baseurl/synapse-windows-x64.exe.sha256",
+          "mode": "extract"
+        }
+      }
+    }
+  }
+}

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synapse-cli-agent"
-version = "0.1.43"
+version = "0.1.44"
 description = "Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)"
 readme = "README.md"
 license = { file = "LICENSE" }

synapse_cli_agent-0.1.44/release_body.md

@@ -0,0 +1,18 @@
+## v0.1.44
+
+### New Features
+
+- Centered the topbar title and elided topbar components by width.
+
+### Bug Fixes
+
+- Slash path completion now stops once whitespace follows the active `@` token, avoiding spurious path suggestions mid-line.
+- Reworked process-tree termination: on Windows the runtime falls back to `proc.kill()` when `taskkill` fails, and on Unix it kills the whole process group so descendants cannot survive. Commands are also detached from the TUI's controlling terminal (`start_new_session` on Unix, `CREATE_NO_WINDOW` on Windows) so non-interactive tools such as `ssh` cannot block on a hidden console.
+- Re-probe git chrome after mount to retry transient probe failures.
+
+### Engineering
+
+- Ignored local scratch output files.
+- Updated the Scoop manifest.
+
+---

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/commands/slash_complete.py

@@ -583,17 +583,16 @@ def _find_at(value: str) -> tuple[int, str] | None:
     """Find the last ``@`` and extract the path token after it.
 
     Returns ``(at_index, path_prefix)``, e.g. for ``"cat @src/main"``
-    returns ``(4, "src/main")``.  Returns ``None`` when there is no ``@``.
+    returns ``(4, "src/main")``. Returns ``None`` when there is no ``@`` or
+    whitespace after the active ``@`` token has ended path completion.
     """
     idx = value.rfind("@")
     if idx < 0:
         return None
-    # Everything after @ until end or next whitespace.
     rest = value[idx + 1 :]
-    # Split on whitespace to get the path token.
-    parts = rest.split(maxsplit=1)
-    token = parts[0] if parts else ""
-    return idx, token
+    if any(char.isspace() for char in rest):
+        return None
+    return idx, rest
 
 
 def _at_path_prefix(token: str) -> str:

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/runtime/backends.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import os
 import shutil
+import signal
 import subprocess
 import sys
 from pathlib import Path
@@ -121,20 +122,36 @@ def _kill_process_tree(proc: subprocess.Popen[Any] | None) -> None:
     if pid is None:
         return
     if os.name == "nt":
+        taskkill_succeeded = False
         try:
-            subprocess.run(
+            completed = subprocess.run(
                 ["taskkill", "/T", "/F", "/PID", str(pid)],
+                stdin=subprocess.DEVNULL,
                 capture_output=True,
                 timeout=10,
                 check=False,
             )
+            taskkill_succeeded = completed.returncode == 0
         except Exception:  # noqa: BLE001
             pass
+        if not taskkill_succeeded:
+            try:
+                proc.kill()
+            except Exception:  # noqa: BLE001
+                pass
     else:
         try:
-            proc.kill()
-        except Exception:  # noqa: BLE001
+            # execute starts each command in a new session, whose process-group
+            # ID is the shell PID. Kill the group so descendants cannot survive
+            # while retaining stdout/stderr pipe handles.
+            os.killpg(pid, signal.SIGKILL)
+        except ProcessLookupError:
             pass
+        except Exception:  # noqa: BLE001
+            try:
+                proc.kill()
+            except Exception:  # noqa: BLE001
+                pass
     # Drain pipes with a short timeout so we don't hang forever if child
     # processes still hold them open.
     try:
@@ -426,6 +443,14 @@ class CodingLocalShellBackend(LocalShellBackend):
             "env": self._env,
             "cwd": str(self.cwd),
         }
+        if os.name == "nt":
+            # execute is non-interactive. Do not let commands such as ssh attach
+            # to the TUI console and wait for credentials outside captured stdin.
+            run_kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+        else:
+            # Detach from the TUI's controlling terminal. Programs that bypass
+            # stdin and open /dev/tty then fail instead of blocking invisibly.
+            run_kwargs["start_new_session"] = True
         if executable:
             run_kwargs["executable"] = executable
 

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/ui/chrome/controller.py

@@ -656,6 +656,12 @@ class ChromeController:
                 "min_width": 0,
                 "priority": 40,
                 "gap_after": gap,
+                # Fallback cap only: keep the left chrome (workspace + branch +
+                # diff stats like "6f +314 -13") fully visible for normal
+                # projects, and reserve room for the centered title on wide
+                # terminals. A very long branch/workspace elides via
+                # render_for_width only when it exceeds this fallback.
+                "max_width": 80,
             },
             "center": {
                 "flex": 1,
@@ -684,6 +690,7 @@ class ChromeController:
                 min_width=int(conf.get("min_width", 0)),
                 priority=int(conf.get("priority", 0)),
                 gap_after=int(conf.get("gap_after", 0)),
+                max_width=int(conf.get("max_width", 0)),
             )
 
     def install_default_bottombar(self) -> None:

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/ui/topbar/components/branch.py

@@ -5,7 +5,12 @@ from __future__ import annotations
 from rich.text import Text
 
 from synapse.ui.topbar.context import TopBarContext
-from synapse.ui.topbar.core import TopBarRegion, TopBarRegistry
+from synapse.ui.topbar.core import (
+    TopBarRegion,
+    TopBarRegistry,
+    display_width,
+    truncate_to_width,
+)
 
 ID = "branch"
 REGION = TopBarRegion.LEFT
@@ -31,6 +36,23 @@ def install(registry: TopBarRegistry, ctx: TopBarContext) -> None:
         mark = (ctx.branch_mark or "").strip()
         return f"{mark} {name}" if mark else name
 
+    def render_for_width(width: int) -> str | Text:
+        """Adapt to available width.
+
+        Keep the fully styled chrome (name + dirty + diff stats) when it fits;
+        otherwise truncate the *prefix* so the meaningful head (branch name and
+        the ``…f +n -n`` stats) survives and only the trailing ahead/behind
+        indicators are dropped.
+        """
+        raw = ctx.branch()
+        plain = raw.plain if isinstance(raw, Text) else str(raw or "")
+        max_w = max(0, int(width))
+        if not plain:
+            return raw if isinstance(raw, Text) else ""
+        if display_width(plain) <= max_w:
+            return raw
+        return truncate_to_width(plain, max_w)
+
     registry.register_fn(
         ID,
         render,
@@ -38,4 +60,5 @@ def install(registry: TopBarRegistry, ctx: TopBarContext) -> None:
         order=ORDER,
         priority=PRIORITY,
         min_width=MIN_WIDTH,
+        render_for_width=render_for_width,
     )

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/ui/topbar/components/workspace.py

@@ -3,7 +3,12 @@
 from __future__ import annotations
 
 from synapse.ui.topbar.context import TopBarContext
-from synapse.ui.topbar.core import TopBarRegion, TopBarRegistry
+from synapse.ui.topbar.core import (
+    TopBarRegion,
+    TopBarRegistry,
+    _elide_tail,
+    display_width,
+)
 
 ID = "workspace"
 REGION = TopBarRegion.LEFT
@@ -22,6 +27,19 @@ def install(registry: TopBarRegistry, ctx: TopBarContext) -> None:
         mark = (ctx.workspace_mark or "").strip()
         return f"{mark}  {label}" if mark else label
 
+    def render_for_width(width: int) -> str:
+        """Adapt to available width: keep the full label when it fits, otherwise
+        elide to the trailing (meaningful) path segment."""
+        label = (ctx.workspace() or "").strip()
+        if not label:
+            return ""
+        mark = (ctx.workspace_mark or "").strip()
+        head = f"{mark}  {label}" if mark else label
+        max_w = max(0, int(width))
+        if display_width(head) <= max_w:
+            return head
+        return _elide_tail(head, max_w)
+
     registry.register_fn(
         ID,
         render,
@@ -29,4 +47,5 @@ def install(registry: TopBarRegistry, ctx: TopBarContext) -> None:
         order=ORDER,
         priority=PRIORITY,
         min_width=MIN_WIDTH,
+        render_for_width=render_for_width,
     )

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/ui/topbar/core.py

@@ -85,6 +85,9 @@ def normalize_region_id(value: TopBarRegion | str | None) -> str:
 
 
 RenderFn = Callable[[], str | Text]
+# Optional width-aware renderer: given the allocated cell width, produce a
+# "keep the meaningful part" representation (elide smartly instead of hard cut).
+WidthRenderFn = Callable[[int], str | Text]
 
 
 @dataclass(slots=True)
@@ -132,6 +135,8 @@ class TopBarComponent:
     gap_before: str = DEFAULT_REGION_GAP
     style: str | None = None
     visible: bool = True
+    # Optional width-aware renderer; falls back to ``render`` when absent/errors.
+    render_for_width: WidthRenderFn | None = None
 
     def content(self) -> str | Text:
         """Return render output as plain str or styled Rich Text."""
@@ -151,6 +156,18 @@ class TopBarComponent:
             return raw.plain
         return raw
 
+    def render_width(self, width: int) -> str | Text:
+        """Width-aware render, falling back to ``render`` when unavailable."""
+        if self.render_for_width is not None:
+            try:
+                raw = self.render_for_width(max(0, int(width)))
+            except Exception:  # noqa: BLE001
+                return self.content()
+            if isinstance(raw, Text):
+                return raw
+            return str(raw or "")
+        return self.content()
+
 
 def _default_regions() -> dict[str, TopBarRegionSpec]:
     # Classic chrome: left/right hug content, center flex-fills leftover.
@@ -338,6 +355,7 @@ class TopBarRegistry:
                 gap_before=component.gap_before,
                 style=component.style,
                 visible=component.visible,
+                render_for_width=component.render_for_width,
             )
         else:
             component.region = rid
@@ -356,6 +374,7 @@ class TopBarRegistry:
         style: str | None = None,
         visible: bool = True,
         replace: bool = True,
+        render_for_width: WidthRenderFn | None = None,
     ) -> TopBarComponent:
         comp = TopBarComponent(
             id=str(id),
@@ -367,6 +386,7 @@ class TopBarRegistry:
             gap_before=str(gap_before),
             style=style,
             visible=bool(visible),
+            render_for_width=render_for_width,
         )
         self.register(comp, replace=replace)
         return comp
@@ -470,6 +490,34 @@ def truncate_to_width(text: str, max_w: int) -> str:
     return "".join(out) + "…"
 
 
+def _elide_tail(text: str, max_w: int) -> str:
+    """Keep the *tail* of ``text``, prefixing ``…`` when it does not fit.
+
+    Used by width-aware components to retain the meaningful tail (e.g. the last
+    path segment for a workspace, or the concrete branch name) instead of a hard
+    cut at the end that would drop exactly the informative part.
+    """
+    raw = text or ""
+    max_w = max(0, int(max_w))
+    if max_w <= 0:
+        return ""
+    if display_width(raw) <= max_w:
+        return raw
+    if max_w == 1:
+        return "…"
+    # Reserve a single cell for the leading ellipsis.
+    budget = max_w - 1
+    tail: list[str] = []
+    used = 0
+    for ch in reversed(raw):
+        cw = display_width(ch)
+        if used + cw > budget:
+            break
+        tail.append(ch)
+        used += cw
+    return "…" + "".join(reversed(tail))
+
+
 def center_in_width(text: str, width: int) -> str:
     """Pad ``text`` so it appears centered within ``width`` terminal cells."""
     return align_in_width(text, width, TopBarAlign.CENTER)
@@ -495,6 +543,26 @@ def align_in_width(text: str, width: int, align: TopBarAlign | str) -> str:
     return body + (" " * pad)
 
 
+def _center_lead_for_band(
+    natural: str,
+    *,
+    band_width: int,
+    band_start: int,
+    usable: int,
+) -> int:
+    """Leading pad so ``natural`` centers on the *full* row, not its band.
+
+    ``band_start`` is the absolute content column where this region begins.
+    This keeps a ``center`` region that flex-fills the leftover width visually
+    centered on the row even when a sibling region (e.g. the previously-populated
+    right side) is empty. The result is clamped to the band so the text never
+    overlaps a neighbor or collapses to a negative offset.
+    """
+    cw = display_width(natural)
+    lead = max(0, (usable - cw) // 2 - band_start)
+    return min(lead, max(0, band_width - cw))
+
+
 def join_region_parts(parts: Iterable[tuple[str, str]]) -> str:
     """Join ``(gap_before, text)`` pairs, skipping empty texts."""
     chunks: list[str] = []
@@ -818,7 +886,15 @@ def locate_component_span(
         if reg.spec.align is TopBarAlign.RIGHT:
             lead = max(0, reg.width - display_width(natural))
         elif reg.spec.align is TopBarAlign.CENTER:
-            lead = max(0, (reg.width - display_width(natural)) // 2)
+            if int(reg.spec.flex or 0) > 0:
+                lead = _center_lead_for_band(
+                    natural,
+                    band_width=reg.width,
+                    band_start=cursor,
+                    usable=packed.usable,
+                )
+            else:
+                lead = max(0, (reg.width - display_width(natural)) // 2)
 
         x = cursor + lead
         first = True
@@ -878,6 +954,129 @@ def _append_chunk_with_region_bg(
     line.append(str(chunk), style=_with_bg(style, bg) if bg else style)
 
 
+def _region_has_width_aware(components: list[TopBarComponent]) -> bool:
+    """True when any component can elide to a width-aware representation."""
+    return any(c.render_for_width is not None for c in components)
+
+
+def _allocate_region_span(
+    comps: list[TopBarComponent],
+    ideal: list[int],
+    mins: list[int],
+    budget: int,
+) -> list[int]:
+    """Split ``budget`` cells among components.
+
+    Guarantees each component its ``min_width`` when possible, then hands the
+    leftover proportionally to the natural (ideal) width. If the budget cannot
+    cover all minimums, earlier components win (keeps the chrome anchored left)
+    and the rest are elided away.
+    """
+    n = len(comps)
+    if n == 0:
+        return []
+    if sum(ideal) <= budget:
+        return list(ideal)
+    alloc = [0] * n
+    if sum(mins) > budget:
+        rem = budget
+        for i in range(n):
+            if rem <= 0:
+                break
+            take = min(mins[i], rem)
+            alloc[i] = take
+            rem -= take
+        used = sum(alloc)
+        if used < budget and n:
+            alloc[n - 1] += budget - used
+        return alloc
+    alloc = list(mins)
+    rem = budget - sum(mins)
+    if rem > 0:
+        weight = [max(0, ideal[i] - mins[i]) for i in range(n)]
+        total = sum(weight) or 1
+        for i in range(n):
+            if weight[i] <= 0:
+                continue
+            alloc[i] += min(weight[i], int(rem * weight[i] // total))
+        used = sum(alloc)
+        if used < budget:
+            for i in range(n - 1, -1, -1):
+                room = max(0, ideal[i] - alloc[i])
+                if room <= 0:
+                    continue
+                take = min(room, budget - used)
+                alloc[i] += take
+                used += take
+                if used >= budget:
+                    break
+    return alloc
+
+
+def _render_region_width_aware(
+    reg: PackedRegion,
+    *,
+    style: str | None,
+    bg: str,
+) -> Text:
+    """Render region components with width-aware elision.
+
+    Each visible component gets a slice of ``reg.width`` (min-width floor plus a
+    proportional share of the leftovers) and, if it provides ``render_for_width``,
+    renders exactly that slice by eliding to the meaningful part. Components
+    without one render normally, then a final hard truncation keeps the band from
+    overflowing so neighbour regions stay put.
+    """
+    comps = [c for c in reg.components if c.visible]
+    if not comps:
+        return Text()
+    gap_before = [display_width(c.gap_before) for c in comps]
+    total_gap = sum(gap_before[1:])  # first component has no leading gap
+    budget = max(0, reg.width - total_gap)
+    if budget <= 0:
+        return Text()
+    ideal = []
+    for comp in comps:
+        if comp.render_for_width is not None:
+            raw = comp.render_for_width(budget)
+            plain = raw.plain if isinstance(raw, Text) else str(raw or "")
+            ideal.append(max(1, display_width(plain)))
+        else:
+            ideal.append(max(1, display_width(comp.text())))
+    mins = [max(0, int(c.min_width or 0)) for c in comps]
+    alloc = _allocate_region_span(comps, ideal, mins, budget)
+
+    out = Text()
+    first = True
+    for comp, sub_w in zip(comps, alloc, strict=True):
+        gap = comp.gap_before
+        if not first and gap and sub_w > 0:
+            out.append(gap, style=style)
+        if sub_w <= 0:
+            first = False
+            continue
+        chunk = comp.render_width(sub_w)
+        plain = chunk.plain if isinstance(chunk, Text) else str(chunk or "")
+        if not plain:
+            first = False
+            continue
+        w = display_width(plain)
+        if w > sub_w:
+            # Final cap so the band never overflows.
+            if isinstance(chunk, Text):
+                chunk = Text(truncate_to_width(plain, sub_w))
+            else:
+                chunk = truncate_to_width(plain, sub_w)
+            w = sub_w
+        if isinstance(chunk, Text):
+            _append_chunk_with_region_bg(out, chunk, style=style, bg=bg)
+        else:
+            c_style = comp.style if comp.style is not None else style
+            _append_chunk_with_region_bg(out, chunk, style=c_style, bg=bg)
+        first = False
+    return out
+
+
 def render_packed_line(
     layout: TopBarLayout,
     *,
@@ -898,6 +1097,8 @@ def render_packed_line(
         default_fb = ""
 
     visible = [r for r in layout.regions if r.width > 0 or r.content]
+    # Track cells written so a center+flex region can center on the full row.
+    written = 0
     for i, reg in enumerate(visible):
         fb = fb_map.get(reg.spec.id, default_fb)
         style = reg.spec.style_string(fallback_fg=fb or None)
@@ -905,13 +1106,49 @@ def render_packed_line(
         body = reg.aligned_text()
         natural = reg.content
         # Prefer component path so branch/workspace keep their own styles, even
-        # when the region paints a solid background band.
-        if reg.components and render_region_text(reg.components) == natural:
+        # when the region paints a solid background band. Width-aware elision is
+        # used only when the *full* chrome would not fit the allocated band.
+        if (
+            reg.components
+            and _region_has_width_aware(reg.components)
+            and display_width(render_region_text(reg.components)) > reg.width
+        ):
+            band_style = style or (f"on {bg}" if bg else None)
             lead = 0
             if reg.spec.align is TopBarAlign.RIGHT:
                 lead = max(0, reg.width - display_width(natural))
             elif reg.spec.align is TopBarAlign.CENTER:
-                lead = max(0, (reg.width - display_width(natural)) // 2)
+                if int(reg.spec.flex or 0) > 0:
+                    lead = _center_lead_for_band(
+                        natural,
+                        band_width=reg.width,
+                        band_start=written,
+                        usable=layout.usable,
+                    )
+                else:
+                    lead = max(0, (reg.width - display_width(natural)) // 2)
+            if lead > 0:
+                line.append(" " * lead, style=band_style)
+            smart = _render_region_width_aware(reg, style=style, bg=bg)
+            line.append_text(smart)
+            used = lead + display_width(smart.plain)
+            trail = reg.width - used
+            if trail > 0:
+                line.append(" " * trail, style=band_style)
+        elif reg.components and render_region_text(reg.components) == natural:
+            lead = 0
+            if reg.spec.align is TopBarAlign.RIGHT:
+                lead = max(0, reg.width - display_width(natural))
+            elif reg.spec.align is TopBarAlign.CENTER:
+                if int(reg.spec.flex or 0) > 0:
+                    lead = _center_lead_for_band(
+                        natural,
+                        band_width=reg.width,
+                        band_start=written,
+                        usable=layout.usable,
+                    )
+                else:
+                    lead = max(0, (reg.width - display_width(natural)) // 2)
             # Always paint pad cells with the region style so bg fills the band,
             # not only the glyphs (hug regions used to look like text highlight).
             band_style = style or (f"on {bg}" if bg else None)
@@ -941,9 +1178,11 @@ def render_packed_line(
             band_style = style or (f"on {bg}" if bg else None)
             line.append(" " * reg.width, style=band_style)
 
+        written += reg.width
         if i < len(visible) - 1 and reg.spec.gap_after > 0:
             # Gaps stay unstyled so the widget CSS topbar bg shows between blocks.
             line.append(" " * reg.spec.gap_after, style=None)
+            written += reg.spec.gap_after
 
     plain_w = display_width(line.plain)
     if plain_w < layout.usable:

{synapse_cli_agent-0.1.43 → synapse_cli_agent-0.1.44}/src/synapse/ui/tui.py

@@ -633,6 +633,10 @@ class CodingAgentApp(App[None]):
             )
         except Exception:  # noqa: BLE001
             pass
+        # Re-probe after mount so a transient/timeout failure during __init__
+        # does not leave the branch chrome empty until the first completed turn.
+        # The controller schedules the actual git subprocess work off-thread.
+        self._refresh_git_chrome()
         self._reload_tool_output_stats()
         set_metrics_notifier(self._on_tool_output_metrics_changed)
         self._refresh_bottombar()