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

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/.github/workflows/release.yml

@@ -118,11 +118,20 @@ jobs:
         if: runner.os != 'Windows'
         run: chmod +x "dist/${{ matrix.binname }}"
 
+      - name: Generate SHA256 checksum
+        shell: pwsh
+        run: |
+          $hash = (Get-FileHash -Algorithm SHA256 -LiteralPath "dist/${{ matrix.binname }}").Hash.ToLower()
+          Set-Content -LiteralPath "dist/${{ matrix.binname }}.sha256" -Value $hash -NoNewline
+          Write-Host "sha256 for ${{ matrix.binname }}: $hash"
+
       - name: Upload executable artifact
         uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.artifact }}
-          path: dist/${{ matrix.binname }}
+          path: |
+            dist/${{ matrix.binname }}
+            dist/${{ matrix.binname }}.sha256
           if-no-files-found: error
 
   release:

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

@@ -8,6 +8,32 @@ All entries are written in English.
 
 ---
 
+## v0.1.43
+
+### New Features
+
+- Added Scoop distribution support: a new `bucket/synapse.json` manifest (with `checkver`/`autoupdate`) and a single-file Windows executable let Windows users install and auto-update Synapse via Scoop (`scoop install synapse`).
+
+### Engineering
+
+- The release workflow now publishes a SHA-256 checksum (`<bin>.sha256`) alongside each platform executable, so Scoop's `autoupdate` can verify downloads without manual hash maintenance.
+- Documented Scoop installation in the README.
+
+---
+
+## v0.1.42
+
+### Bug Fixes
+
+- Retried a stale native Responses WebSocket connection once on a fresh socket when the request failed before any output, while avoiding replay after partial streaming output.
+- Classified native WebSocket send/receive connection failures as transient without broadly retrying unrelated operating-system errors.
+
+### Engineering
+
+- Added focused coverage for WebSocket reconnect/replay behavior and transient transport-error classification.
+
+---
+
 ## v0.1.41
 
 ### New Features

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.41
+Version: 0.1.43
 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
@@ -270,6 +270,20 @@ One command, no clone required:
 uv tool install synapse-cli-agent
 ```
 
+Windows users can also install via Scoop (single-file executable, auto-updated
+through `checkver`): add the bucket, then install:
+
+```powershell
+scoop bucket add synapse https://github.com/alex8224/synapse-agent
+scoop install synapse
+```
+
+Or install directly from the manifest URL:
+
+```powershell
+scoop install https://raw.githubusercontent.com/alex8224/synapse-agent/main/bucket/synapse.json
+```
+
 Then start the TUI from anywhere:
 
 ```bash

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/README.md

@@ -37,6 +37,20 @@ One command, no clone required:
 uv tool install synapse-cli-agent
 ```
 
+Windows users can also install via Scoop (single-file executable, auto-updated
+through `checkver`): add the bucket, then install:
+
+```powershell
+scoop bucket add synapse https://github.com/alex8224/synapse-agent
+scoop install synapse
+```
+
+Or install directly from the manifest URL:
+
+```powershell
+scoop install https://raw.githubusercontent.com/alex8224/synapse-agent/main/bucket/synapse.json
+```
+
 Then start the TUI from anywhere:
 
 ```bash

synapse_cli_agent-0.1.43/bucket/synapse.json

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

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

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

synapse_cli_agent-0.1.43/release_body.md

@@ -0,0 +1,12 @@
+## v0.1.43
+
+### New Features
+
+- Added Scoop distribution support: a new `bucket/synapse.json` manifest (with `checkver`/`autoupdate`) and a single-file Windows executable let Windows users install and auto-update Synapse via Scoop (`scoop install synapse`).
+
+### Engineering
+
+- The release workflow now publishes a SHA-256 checksum (`<bin>.sha256`) alongside each platform executable, so Scoop's `autoupdate` can verify downloads without manual hash maintenance.
+- Documented Scoop installation in the README.
+
+---

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/models/rust_openai.py

@@ -1052,37 +1052,56 @@ class RustOpenAIChatModel(BaseChatModel):
         req = self._build_request(messages, tools=tools, stop=stop, streaming=True, **kwargs)
         response_state: dict[str, Any] = {}
         if self.use_responses_api and self.use_websocket:
-            from synapse.integrations.llm_openai_websocket import (
-                prepare_responses_websocket_event,
-            )
+            from synapse.integrations.llm_openai_websocket import prepare_responses_websocket_event
+            from synapse.runtime.middleware import should_retry_transient_model_error
 
             event = prepare_responses_websocket_event(req)
-            ws: Any | None = None
-            try:
-                ws = self._ensure_websocket()
-                stream = ws.request(json.dumps(event, default=str))
-                for raw in stream:
-                    payload = json.loads(raw)
-                    chunk_msg = aimessage_chunk_from_responses_event(payload, response_state)
-                    if chunk_msg is None:
-                        continue
-                    gen = ChatGenerationChunk(message=chunk_msg)
-                    if run_manager:
-                        text = chunk_msg.content if isinstance(chunk_msg.content, str) else ""
-                        if text:
-                            run_manager.on_llm_new_token(text, chunk=gen)
-                    yield gen
-            except Exception:
-                # A socket error (or consumer cancellation) leaves the connection
-                # unusable; drop it so the next request opens a fresh one.
-                self._reset_websocket()
-                raise
-            except BaseException:
-                # GeneratorExit is raised when a synchronous consumer closes the
-                # iterator early. The native producer then closes its socket, so
-                # do not leave the now-invalid handle cached on this model.
-                self._reset_websocket()
-                raise
+            # A long-lived WebSocket connection sits idle in the cache while the
+            # peer or an intermediate idle-timeout recycles the socket, so the
+            # next ``send_raw`` can fail with a connection-aborted IO error
+            # (Windows 10053) without any warning. Retry once on a fresh
+            # connection, but only before any chunk has been emitted — replaying
+            # after output would duplicate tokens.
+            websocket_replay_attempts = 1
+            for attempt in range(websocket_replay_attempts + 1):
+                response_state = {}
+                yielded_chunk = False
+                try:
+                    ws = self._ensure_websocket()
+                    stream = ws.request(json.dumps(event, default=str))
+                    for raw in stream:
+                        payload = json.loads(raw)
+                        chunk_msg = aimessage_chunk_from_responses_event(payload, response_state)
+                        if chunk_msg is None:
+                            continue
+                        gen = ChatGenerationChunk(message=chunk_msg)
+                        yielded_chunk = True
+                        if run_manager:
+                            text = chunk_msg.content if isinstance(chunk_msg.content, str) else ""
+                            if text:
+                                run_manager.on_llm_new_token(text, chunk=gen)
+                        yield gen
+                    return
+                except Exception as exc:
+                    # A socket error (or consumer cancellation) leaves the
+                    # connection unusable; drop it so the next attempt opens a
+                    # fresh one.
+                    self._reset_websocket()
+                    if (
+                        yielded_chunk
+                        or attempt >= websocket_replay_attempts
+                        or not should_retry_transient_model_error(exc)
+                    ):
+                        raise
+                    # Connection failed before any output; reconnect and retry.
+                    continue
+                except BaseException:
+                    # GeneratorExit is raised when a synchronous consumer closes
+                    # the iterator early. The native producer then closes its
+                    # socket, so do not leave the now-invalid handle cached on
+                    # this model.
+                    self._reset_websocket()
+                    raise
             return
         client = self._ensure_client()
         if self.use_responses_api:

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/runtime/middleware.py

@@ -39,6 +39,18 @@ _TRANSIENT_MODEL_ERROR_MARKERS = (
     "upstream request timeout",
     "rate limit",
     "rate_limit",
+    # Connection-level failures (TCP reset / aborted / timed-out sockets and
+    # the native WebSocket transport) are transient: the underlying peer or an
+    # intermediate idle-timeout recycles the socket, but a fresh connection
+    # usually succeeds. Match these so the model retry middleware recovers the
+    # call instead of surfacing a one-shot "websocket send failed" to the user.
+    "connection reset",
+    "connection aborted",
+    "connection closed",
+    "software caused connection abort",
+    "websocket send failed",
+    "websocket recv failed",
+    "websocket connection is closed",
 )
 
 # ---------------------------------------------------------------------------
@@ -668,11 +680,15 @@ def current_prompt_cleanup_saved_tokens() -> int:
 # Text block prefixes injected by deepagents middleware.  Each block
 # duplicates content already present in the corresponding tool definition
 # (e.g. ``write_todos`` description, filesystem tool docs).  Stripping them
-# saves ~720 tokens per model call without losing any capability.
+# saves tokens per model call without losing any capability.
+#
+# ``## Skills System`` is intentionally NOT stripped: it is the skill index
+# (name + description + path) that lets the model auto-discover and trigger
+# local skills.  Without it, skills are not auto-discoverable from the prompt
+# and must be surfaced via the /skills command or a human pointer.
 
 _REDUNDANT_BLOCK_PREFIXES: tuple[str, ...] = (
     "\n\n## `write_todos`",
-    "\n\n## Skills System",
     "\n\n## Following Conventions",
 )
 

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/ui/rendering.py

@@ -11,6 +11,7 @@ from rich import box
 from rich.console import Console, ConsoleOptions, RenderResult
 from rich.markdown import BlockQuote as _BlockQuote
 from rich.markdown import CodeBlock as _CodeBlock
+from rich.markdown import ImageItem as _RichImageItem
 from rich.markdown import Markdown as _Markdown
 from rich.markdown import MarkdownElement
 from rich.markdown import TableElement as _TableElement
@@ -633,11 +634,77 @@ class _QuoteLineBlockQuote(_BlockQuote):
             yield new_line
 
 
+_IMAGE_MAX_COLS = 100
+_IMAGE_MAX_ROWS = 30
+
+
+def _render_image_path(destination: str) -> Any | None:
+    """Best-effort terminal pixel renderable for a local image path.
+
+    Mirrors ``_render_mermaid_image``: decode the image with Pillow and wrap it
+    in the active ``textual_image`` protocol renderer (sixel / TGP / half-cell /
+    unicode). Returns ``None`` when the path is not a readable local image or no
+    renderer is available so callers can fall back to the Rich ``[image]``
+    placeholder. HTTP(S) URLs are not resolved here and fall through.
+    """
+    if not destination or destination.startswith(("http://", "https://")):
+        return None
+    try:
+        from PIL import Image as PILImage
+
+        from synapse.ui.image_render import (
+            _resolve_renderer,
+            fit_cell_size,
+            renderer_needs_extra_row,
+        )
+        from synapse.ui.workspace import resolve_workspace_path
+
+        renderer_cls = _resolve_renderer()
+        if renderer_cls is None:
+            return None
+        path = resolve_workspace_path(destination)
+        if path is None:
+            return None
+        image = PILImage.open(path)
+        image.load()
+        width, height = image.size
+        cols, rows = fit_cell_size(
+            width,
+            height,
+            max_cols=_IMAGE_MAX_COLS,
+            max_rows=_IMAGE_MAX_ROWS,
+            extra_rows=1 if renderer_needs_extra_row() else 0,
+        )
+        return renderer_cls(image, width=cols, height=rows)
+    except Exception:  # noqa: BLE001 - any image-path failure falls back to placeholder
+        return None
+
+
+class _ImageItem(_RichImageItem):
+    """Markdown image element that renders local images via the pixel pipeline.
+
+    Overrides Rich's ``ImageItem`` placeholder so ``![alt](path)`` resolves a
+    readable local image through ``_render_image_path`` (the same Pillow +
+    ``textual_image`` pipeline used for mermaid / math). Any failure falls back
+    to the original Rich ``[image]`` placeholder.
+    """
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        image = _render_image_path(self.destination)
+        if image is not None:
+            yield image
+            return
+        yield from super().__rich_console__(console, options)
+
+
 class _FullBorderMarkdown(_Markdown):
     """Rich Markdown with full table borders and mermaid diagram fences."""
 
     elements: ClassVar[dict[str, type[MarkdownElement]]] = {
         **_Markdown.elements,
+        "image": _ImageItem,
         "table_open": _FullTableElement,
         "fence": _MermaidCodeBlock,
         "code_block": _MermaidCodeBlock,

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/ui/status_controller.py

@@ -10,6 +10,7 @@ import time
 from typing import Any
 
 from rich.text import Text
+from textual.css.query import NoMatches
 from textual.widgets import Input, Static
 
 import synapse.ui.tui_styles as _styles
@@ -45,7 +46,13 @@ class StatusController:
         self._phase = phase or "idle"
         self._detail = detail
         busy = self._phase not in {"idle", "ready", ""}
-        app.query_one("#status", Static).set_class(busy, "busy")
+        try:
+            app.query_one("#status", Static).set_class(busy, "busy")
+        except NoMatches:
+            # A timer/worker callback can race with screen teardown. Keep the
+            # controller state, but do not turn an already-unmounted UI into
+            # an application error.
+            return
         if busy:
             app.sub_title = f"{model_status_label(app.settings)} · {self._phase}"
         else:
@@ -158,7 +165,12 @@ class StatusController:
         app = self._app
         elapsed = max(0.0, time.monotonic() - self._activity_started)
         busy = self._phase not in {"idle", "ready", ""}
-        status = app.query_one("#status", Static)
+        try:
+            status = app.query_one("#status", Static)
+        except NoMatches:
+            # Textual removes the screen tree before all interval callbacks
+            # have necessarily drained during shutdown.
+            return
         width = max(int(getattr(app.size, "width", 0) or 0), 48)
         # Account for CSS padding (0 2).
         usable = max(16, width - 4)
@@ -228,4 +240,4 @@ class StatusController:
         except Exception:  # noqa: BLE001
             pass
         self.render_status()
-        self.sync_prompt_placeholder()
+        self.sync_prompt_placeholder()

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/ui/transcript/controller.py

@@ -13,6 +13,7 @@ from typing import Any
 
 from rich.text import Text
 from textual.containers import Vertical, VerticalScroll
+from textual.css.query import NoMatches
 from textual.events import MouseUp
 from textual.widgets import Static
 
@@ -188,7 +189,13 @@ class TranscriptController:
     def _mount_block(self, block: Any, *, dismiss_welcome: bool = True) -> None:
         if dismiss_welcome:
             self._dismiss_welcome()
-        timeline = self._app.query_one("#log", VerticalScroll)
+        try:
+            timeline = self._app.query_one("#log", VerticalScroll)
+        except NoMatches:
+            # Background callbacks may arrive after Textual has torn down the
+            # screen tree. The event is no longer renderable, so discard only
+            # the UI write instead of surfacing a shutdown error.
+            return
         follow = timeline.max_scroll_y <= 0 or timeline.scroll_y >= timeline.max_scroll_y - 1
         timeline.mount(block)
         self.state.current_turn_blocks.append(block)
@@ -716,4 +723,4 @@ class TranscriptController:
         st.last_answer_text = ""
         st.last_thought_body = ""
         st.last_thought_elapsed = 0.0
-        st.thought_expanded = False
+        st.thought_expanded = False

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/ui/transcript_blocks.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import io
+import re
 import threading
 import time
 from collections.abc import Callable
@@ -47,6 +49,59 @@ _markdown_render_executor = ThreadPoolExecutor(
 )
 
 
+_IMAGE_RENDER_WORKERS = 2
+_image_render_executor = ThreadPoolExecutor(
+    max_workers=_IMAGE_RENDER_WORKERS,
+    thread_name_prefix="synapse-image",
+)
+_IMAGE_MAX_COLS = 100
+_IMAGE_MAX_ROWS = 30
+
+_MD_IMAGE_RE = re.compile(r"!\[[^\]]*\]\(([^)]*)\)")
+
+
+def _image_src(destination: str) -> str:
+    """Extract the image path from an ``![alt](src "title")`` render target."""
+    stripped = destination.strip()
+    return stripped.split()[0] if stripped else ""
+
+
+def split_markdown_images(text: str) -> list[tuple[str, str]]:
+    """Split Markdown into ``(kind, content)`` runs.
+
+    ``image`` runs carry the raw image source from ``![alt](path)``; ``markdown``
+    runs are plain text kept verbatim for the Rich renderer. Used by answer
+    blocks so attached images render through the terminal pixel pipeline.
+    """
+    if not text:
+        return [("markdown", "")]
+    parts: list[tuple[str, str]] = []
+    cursor = 0
+    for match in _MD_IMAGE_RE.finditer(text):
+        if match.start() > cursor:
+            parts.append(("markdown", text[cursor : match.start()]))
+        src = _image_src(match.group(1))
+        if src:
+            parts.append(("image", src))
+        cursor = match.end()
+    if cursor < len(text):
+        parts.append(("markdown", text[cursor:]))
+    return parts or [("markdown", text)]
+
+
+def _read_image_bytes(source: str) -> bytes | None:
+    """Read a local image file in a background worker; ``None`` on failure."""
+    from synapse.ui.workspace import resolve_workspace_path
+
+    path = resolve_workspace_path(source)
+    if path is None:
+        return None
+    try:
+        return path.read_bytes()
+    except Exception:  # noqa: BLE001 - unreadable image falls back to placeholder
+        return None
+
+
 def _render_mermaid_png(source: str) -> bytes | None:
     """Run only native Mermaid PNG rendering in a background worker."""
     from synapse.ui.rendering import render_mermaid_png
@@ -291,6 +346,7 @@ class AnswerBlock(SelectableStatic):
         self._markdown_max_chars = max(1, int(markdown_max_chars))
         self._mermaid_render_generation = 0
         self._markdown_render_generation = 0
+        self._image_render_generation = 0
         # Historical restore defers long-body markdown parsing to a worker so
         # first paint stays cheap: show plain text, then swap in the renderable.
         self._defer_markdown = bool(defer_markdown)
@@ -351,6 +407,9 @@ class AnswerBlock(SelectableStatic):
                 if any(sub.kind == "math" for sub in split_block_math(segment.source)):
                     has_enriched = True
                     break
+                if _MD_IMAGE_RE.search(segment.source):
+                    has_enriched = True
+                    break
             if not has_enriched:
                 return []
 
@@ -370,8 +429,12 @@ class AnswerBlock(SelectableStatic):
                     if sub.kind == "math":
                         widget = make_math_widget(sub.source, color=fg)
                         widgets.append(widget or MathFallbackBlock(sub.source))
-                    elif sub.source.strip():
-                        widgets.append(Static(render_markdown(sub.source)))
+                        continue
+                    for kind, content in split_markdown_images(sub.source):
+                        if kind == "image" and content:
+                            widgets.append(_ImageRenderPlaceholder(content))
+                        elif content.strip():
+                            widgets.append(Static(render_markdown(content)))
             return widgets
         except Exception:  # noqa: BLE001 - composite rendering is optional
             return []
@@ -384,11 +447,13 @@ class AnswerBlock(SelectableStatic):
             if widgets:
                 self.mount(*widgets)
                 self.call_after_refresh(self._start_mermaid_renders)
+                self.call_after_refresh(self._start_image_renders)
         except Exception:  # noqa: BLE001 - widget may be detaching during session switch
             pass
 
     def on_mount(self) -> None:
         self.call_after_refresh(self._start_mermaid_renders)
+        self.call_after_refresh(self._start_image_renders)
         if self._pending_markdown:
             self._pending_markdown = False
             self._schedule_markdown_render(self.body)
@@ -461,8 +526,84 @@ class AnswerBlock(SelectableStatic):
         except Exception:  # noqa: BLE001 - transcript may detach during session switch
             pass
 
+    def _start_image_renders(self) -> None:
+        """Submit unrendered image placeholders without blocking Textual's loop."""
+        if not self.is_attached:
+            return
+        generation = self._image_render_generation
+        for placeholder in self.query(_ImageRenderPlaceholder):
+            if placeholder.render_started:
+                continue
+            placeholder.render_started = True
+            future = _image_render_executor.submit(
+                _read_image_bytes, placeholder.source
+            )
+            future.add_done_callback(
+                lambda completed, target=placeholder, expected=generation: (
+                    self._deliver_image(completed, target, expected)
+                )
+            )
+
+    def _deliver_image(
+        self,
+        future: Future[bytes | None],
+        placeholder: _ImageRenderPlaceholder,
+        generation: int,
+    ) -> None:
+        """Schedule a completed background image load back onto the UI thread."""
+        try:
+            data = future.result()
+        except Exception:  # noqa: BLE001 - app/widget may be shutting down
+            return
+        try:
+            _schedule_on_app_thread(
+                self.app,
+                self._replace_image_placeholder,
+                placeholder,
+                data,
+                generation,
+            )
+        except Exception:  # noqa: BLE001 - app/widget may be shutting down
+            pass
+
+    def _replace_image_placeholder(
+        self,
+        placeholder: _ImageRenderPlaceholder,
+        data: bytes | None,
+        generation: int,
+    ) -> None:
+        """Replace a still-current image placeholder once its file is loaded."""
+        if (
+            generation != self._image_render_generation
+            or not self.is_attached
+            or not placeholder.is_attached
+        ):
+            return
+        widget = None
+        if data:
+            try:
+                from PIL import Image as PILImage
+
+                from synapse.ui.image_render import make_pil_image_widget
+
+                img = PILImage.open(io.BytesIO(data))
+                img.load()
+                widget = make_pil_image_widget(
+                    img, max_cols=_IMAGE_MAX_COLS, max_rows=_IMAGE_MAX_ROWS
+                )
+            except Exception:  # noqa: BLE001 - corrupt image falls back to placeholder
+                widget = None
+        if widget is None:
+            widget = Static(Text(f"[image: {placeholder.source}]", style="dim italic"))
+        try:
+            self.mount(widget, before=placeholder)
+            placeholder.remove()
+        except Exception:  # noqa: BLE001 - transcript may detach during session switch
+            pass
+
     def _render_block(self) -> None:
         self._mermaid_render_generation += 1
+        self._image_render_generation += 1
         body = self.body or ""
         fg = _resolve_color(self._fg_color, _DEFAULT_FG, "fg")
         if self.live:
@@ -560,6 +701,15 @@ class _MermaidRenderPlaceholder(Static):
         super().__init__(Text("Rendering Mermaid diagram...", style="dim italic"))
 
 
+class _ImageRenderPlaceholder(Static):
+    """Lightweight UI-thread placeholder while a local image loads on a worker."""
+
+    def __init__(self, source: str) -> None:
+        self.source = source
+        self.render_started = False
+        super().__init__(Text("Loading image...", style="dim italic"))
+
+
 class _MarkdownBlock(Static):
     """A Markdown transcript block that can rebuild after a theme switch."""
 

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

@@ -1490,6 +1490,9 @@ class CodingAgentApp(App[None]):
         # Swap the app's project context.
         self.settings = project_settings
         self.project_root = workspace
+        from synapse.ui.workspace import set_current_workspace
+
+        set_current_workspace(workspace)
         self.thread_id = target_thread
         if turn is not None:
             try:

{synapse_cli_agent-0.1.41 → synapse_cli_agent-0.1.43}/src/synapse/ui/tui_launch.py

@@ -24,6 +24,9 @@ def run_tui(
     # ``run_tui`` re-export, so CodingAgentApp must resolve lazily.
     from synapse.observability.startup_trace import global_mark, span
     from synapse.ui.tui import CodingAgentApp
+    from synapse.ui.workspace import set_current_workspace
+
+    set_current_workspace(settings.workspace)
 
     try:
         from synapse.ui.theme import bootstrap_theme