synapse-cli-agent 0.1.30__tar.gz → 0.1.31__tar.gz

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/.github/workflows/release.yml

@@ -63,14 +63,17 @@ jobs:
           - name: windows
             os: windows-latest
             artifact: executable-windows
+            binname: synapse-windows-x64.exe
           # macOS executables target Apple Silicon only; Intel macOS is unsupported
           # (matches the native-core-tool wheels matrix).
           - name: macos
             os: macos-latest
             artifact: executable-macos
+            binname: synapse-macos-arm64
           - name: linux
             os: ubuntu-latest
             artifact: executable-linux
+            binname: synapse-linux-x64
     steps:
       - uses: actions/checkout@v4
 
@@ -100,15 +103,22 @@ jobs:
             --collect-all texicode `
             src/synapse/entry.py
 
+      - name: Rename executable for artifact
+        shell: pwsh
+        run: |
+          $ext = if ($env:RUNNER_OS -eq 'Windows') { '.exe' } else { '' }
+          Rename-Item "dist/synapse$ext" "dist/${{ matrix.binname }}"
+          Write-Host "Renamed to ${{ matrix.binname }}"
+
       - name: Fix executable permission (Unix)
         if: runner.os != 'Windows'
-        run: chmod +x dist/synapse
+        run: chmod +x "dist/${{ matrix.binname }}"
 
       - name: Upload executable artifact
         uses: actions/upload-artifact@v4
         with:
           name: ${{ matrix.artifact }}
-          path: dist/synapse*
+          path: dist/${{ matrix.binname }}
           if-no-files-found: error
 
   release:

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/CHANGELOG.md

@@ -8,6 +8,19 @@ All entries are written in English.
 
 ---
 
+## v0.1.31
+
+### New Features
+
+- The `Ctrl+O` / `Ctrl+Tab` recent-sessions switcher now lists the most recently changed sessions across every registered project (from the user-layer catalog) instead of current-project history only, and marks each row's live runtime status (`running` / `queued` / `idle` / `cold`, etc.). Sessions without an in-process runtime are shown as cold history, and the list degrades gracefully to the legacy view when the catalog is unavailable.
+
+### Bug Fixes
+
+- Fixed the standalone Windows executable exiting immediately after launch: the PyInstaller entry script only defined `main()` without invoking it, so the packaged binary ran the top-level code and quit. `synapse.entry` now has an `if __name__ == "__main__"` guard and the packaged executable runs the CLI correctly.
+- Fixed the release executable assets: the Linux and macOS binaries shared the same filename (`synapse`) and overwrote each other when merged into the release. Each platform is now uploaded under a distinct name: `synapse-windows-x64.exe`, `synapse-macos-arm64`, and `synapse-linux-x64`.
+
+---
+
 ## v0.1.30
 
 ### New Features

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.30
+Version: 0.1.31
 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
@@ -286,11 +286,13 @@ floating project drawer: it lists every registered project, groups their
 sessions, marks live runtime status, and lets you switch sessions in place or
 jump to another project (the TUI restarts into that project).
 
-Press `Ctrl+Tab` for a lighter active-session switcher: it lists only sessions
-that are doing work right now (across projects), lets you `Tab` / `Shift+Tab`
-through them and `Enter` to switch — the old session keeps running in the
-background and is never cancelled.  Some terminals never forward `Ctrl+Tab` to
-the app; `Ctrl+O` is a drop-in alternative.
+Press `Ctrl+Tab` for a global recent-sessions switcher: it lists the most
+recently changed sessions across every registered project (from the user-layer
+catalog), marks each one's live runtime status — `running` / `queued` /
+`idle` / `cold`, etc. — lets you `Tab` / `Shift+Tab` through them and `Enter`
+to switch.  The old session keeps running in the background and is never
+cancelled.  Some terminals never forward `Ctrl+Tab` to the app; `Ctrl+O` is a
+drop-in alternative.
 
 <details>
 <summary><b>Or run from source</b></summary>

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/README.md

@@ -55,11 +55,13 @@ floating project drawer: it lists every registered project, groups their
 sessions, marks live runtime status, and lets you switch sessions in place or
 jump to another project (the TUI restarts into that project).
 
-Press `Ctrl+Tab` for a lighter active-session switcher: it lists only sessions
-that are doing work right now (across projects), lets you `Tab` / `Shift+Tab`
-through them and `Enter` to switch — the old session keeps running in the
-background and is never cancelled.  Some terminals never forward `Ctrl+Tab` to
-the app; `Ctrl+O` is a drop-in alternative.
+Press `Ctrl+Tab` for a global recent-sessions switcher: it lists the most
+recently changed sessions across every registered project (from the user-layer
+catalog), marks each one's live runtime status — `running` / `queued` /
+`idle` / `cold`, etc. — lets you `Tab` / `Shift+Tab` through them and `Enter`
+to switch.  The old session keeps running in the background and is never
+cancelled.  Some terminals never forward `Ctrl+Tab` to the app; `Ctrl+O` is a
+drop-in alternative.
 
 <details>
 <summary><b>Or run from source</b></summary>

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/pyproject.toml

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

synapse_cli_agent-0.1.31/release_body.md

@@ -0,0 +1,12 @@
+## v0.1.31
+
+### New Features
+
+- The `Ctrl+O` / `Ctrl+Tab` recent-sessions switcher now lists the most recently changed sessions across every registered project (from the user-layer catalog) instead of current-project history only, and marks each row's live runtime status (`running` / `queued` / `idle` / `cold`, etc.). Sessions without an in-process runtime are shown as cold history, and the list degrades gracefully to the legacy view when the catalog is unavailable.
+
+### Bug Fixes
+
+- Fixed the standalone Windows executable exiting immediately after launch: the PyInstaller entry script only defined `main()` without invoking it, so the packaged binary ran the top-level code and quit. `synapse.entry` now has an `if __name__ == "__main__"` guard and the packaged executable runs the CLI correctly.
+- Fixed the release executable assets: the Linux and macOS binaries shared the same filename (`synapse`) and overwrote each other when merged into the release. Each platform is now uploaded under a distinct name: `synapse-windows-x64.exe`, `synapse-macos-arm64`, and `synapse-linux-x64`.
+
+---

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/src/synapse/entry.py

@@ -20,3 +20,7 @@ def main() -> None:
 
     mark("cli:imported")
     cli_main()
+
+
+if __name__ == "__main__":
+    main()

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/src/synapse/ui/turn/controller.py

@@ -354,44 +354,143 @@ class TurnController:
         return by_project
 
     def active_session_items(self) -> tuple[ActiveSessionItem, ...]:
-        """Snapshot of the 10 most recently touched sessions for the switcher.
-
-        Two sources are merged:
-
-        - in-process runtimes: the canonical ``ProjectRegistry`` (cross-project
-          background sessions) plus the legacy ``_sessions`` compatibility
-          index for early-startup sessions never registered there;
-        - the current project's persisted session store: cold history that has
-          no runtime in this process (e.g. sessions from before a restart), so
-          the switcher lists genuinely recent sessions, not only live ones.
-
-        Every in-memory runtime counts (active or idle); rows are ordered by
-        last activity (runtime ``last_activity_at`` for live sessions,
-        persisted ``updated_at`` for cold ones) and capped at
-        ``MAX_RECENT_SESSION_ITEMS``. Active statuses are still carried on each
-        item so the dialog can style them.
+        """Snapshot of the 10 most recently changed sessions, globally.
+
+        Primary source is the user-layer ``ProjectCatalog`` projection: it
+        lists every registered project's sessions ordered by ``updated_at``
+        (cross-project), so the switcher is a *global* recent-changes list
+        rather than current-project history.  Each row is then annotated with
+        its live runtime status:
+
+        - a session with an in-process runtime uses the runtime snapshot's
+          real status and ``last_activity_at`` (running / queued / idle / …);
+        - a session with no runtime in this process is marked ``COLD`` and
+          ordered by its persisted ``updated_at``.
+
+        Runtimes that the catalog has not projected yet (e.g. an active turn
+        that has not persisted) are appended so working sessions never vanish
+        from the list.  When the catalog is unavailable (disabled or not yet
+        ready) this degrades to the legacy view: cross-project in-process
+        runtimes plus the current project's persisted cold history.  Rows are
+        capped at ``MAX_RECENT_SESSION_ITEMS``.
         """
+        runtimes = self._runtime_index()
+        current = self._app.thread_id
+        catalog = getattr(self._app, "_project_catalog", None)
+        if catalog is not None:
+            try:
+                sessions = catalog.list_sessions(
+                    limit=MAX_RECENT_SESSION_ITEMS * 3
+                )
+            except Exception:  # noqa: BLE001 - catalog is best-effort
+                sessions = None
+            if sessions is not None:
+                return self._merge_global_items(sessions, runtimes, current)
+        return self._legacy_recent_items(runtimes, current)
+
+    def _runtime_index(self) -> dict[str, SessionRuntime]:
+        """thread_id -> runtime across projects; the registry wins on clashes."""
         runtimes: dict[str, SessionRuntime] = {}
         for runtime in self._project_registry.all_sessions():
             runtimes[runtime.thread_id] = runtime
         for runtime in tuple(self._sessions.values()):
             runtimes.setdefault(runtime.thread_id, runtime)
+        return runtimes
 
-        current = self._app.thread_id
+    def _merge_global_items(
+        self,
+        sessions: list[Any],
+        runtimes: dict[str, SessionRuntime],
+        current: str,
+    ) -> tuple[ActiveSessionItem, ...]:
+        """Merge global catalog rows with live runtimes into one ordered list."""
         items: list[ActiveSessionItem] = []
+        covered: set[tuple[str, str]] = set()
+        for cs in sessions:
+            runtime = self._runtime_for_session(cs, runtimes)
+            if runtime is not None:
+                snapshot = runtime.snapshot()
+                title = self._active_session_title(runtime, snapshot)
+                if title == snapshot.thread_id[:8] and (cs.title or "").strip():
+                    # Prefer the catalog title over the bare id fallback.
+                    title = (cs.title or "").strip()[:120]
+                items.append(
+                    ActiveSessionItem(
+                        project_id=cs.project_id,
+                        thread_id=cs.thread_id,
+                        title=title,
+                        project_label=cs.project_name or self._project_label(runtime),
+                        status=snapshot.status,
+                        last_activity_at=snapshot.last_activity_at,
+                        current=cs.thread_id == current,
+                    )
+                )
+            else:
+                updated = _parse_stored_timestamp(cs.updated_at)
+                if updated is None:
+                    continue
+                items.append(
+                    ActiveSessionItem(
+                        project_id=cs.project_id,
+                        thread_id=cs.thread_id,
+                        title=(cs.title or "").strip()[:120] or cs.thread_id[:8],
+                        project_label=cs.project_name or cs.project_id[:8],
+                        status=SessionStatus.COLD,
+                        last_activity_at=updated,
+                        current=False,
+                    )
+                )
+            covered.add((cs.project_id, cs.thread_id))
+        # Append runtimes the catalog has not projected yet (active, unpersisted).
         for runtime in runtimes.values():
             snapshot = runtime.snapshot()
-            items.append(
-                ActiveSessionItem(
-                    project_id=snapshot.project_id,
-                    thread_id=snapshot.thread_id,
-                    title=self._active_session_title(runtime, snapshot),
-                    project_label=self._project_label(runtime),
-                    status=snapshot.status,
-                    last_activity_at=snapshot.last_activity_at,
-                    current=snapshot.thread_id == current,
-                )
-            )
+            key = (snapshot.project_id, snapshot.thread_id)
+            if key in covered:
+                continue
+            items.append(self._item_from_runtime(runtime, snapshot, current))
+        items.sort(key=lambda item: item.last_activity_at, reverse=True)
+        return tuple(items[:MAX_RECENT_SESSION_ITEMS])
+
+    @staticmethod
+    def _runtime_for_session(cs: Any, runtimes: dict[str, SessionRuntime]) -> SessionRuntime | None:
+        """Exact ``(project_id, thread_id)`` match, then unique thread fallback."""
+        matches = [r for r in runtimes.values() if r.thread_id == cs.thread_id]
+        for runtime in matches:
+            if str(getattr(runtime, "project_id", "") or "") == cs.project_id:
+                return runtime
+        return matches[0] if len(matches) == 1 else None
+
+    def _item_from_runtime(
+        self,
+        runtime: SessionRuntime,
+        snapshot: Any,
+        current: str,
+    ) -> ActiveSessionItem:
+        """Build a switcher row straight from one live runtime snapshot."""
+        return ActiveSessionItem(
+            project_id=snapshot.project_id,
+            thread_id=snapshot.thread_id,
+            title=self._active_session_title(runtime, snapshot),
+            project_label=self._project_label(runtime),
+            status=snapshot.status,
+            last_activity_at=snapshot.last_activity_at,
+            current=snapshot.thread_id == current,
+        )
+
+    def _legacy_recent_items(
+        self,
+        runtimes: dict[str, SessionRuntime],
+        current: str,
+    ) -> tuple[ActiveSessionItem, ...]:
+        """Fallback when the global catalog is unavailable.
+
+        Cross-project in-process runtimes plus the current project's persisted
+        cold history (the pre-catalog behavior).
+        """
+        items: list[ActiveSessionItem] = []
+        for runtime in runtimes.values():
+            snapshot = runtime.snapshot()
+            items.append(self._item_from_runtime(runtime, snapshot, current))
         items.extend(self._stored_recent_items(current))
         items.sort(key=lambda item: item.last_activity_at, reverse=True)
         return tuple(items[:MAX_RECENT_SESSION_ITEMS])

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/tests/test_turn_controller.py

@@ -1363,6 +1363,117 @@ class TestActiveSessionItems:
 
         assert controller.active_session_items() == ()
 
+    def test_global_catalog_cold_sessions_across_projects(self) -> None:
+        from synapse.projects.catalog import CatalogSession
+
+        controller = self._controller()
+        controller._app._project_catalog = SimpleNamespace(
+            list_sessions=lambda *, limit=200: [
+                CatalogSession(
+                    project_id="pa", project_name="proj-a",
+                    workspace_path="/ws/a", thread_id="ca",
+                    title="cold a", model=None, summary=None,
+                    updated_at="2025-01-01T00:00:03+00:00",
+                    created_at="2025-01-01T00:00:00+00:00", tags=[],
+                ),
+                CatalogSession(
+                    project_id="pb", project_name="proj-b",
+                    workspace_path="/ws/b", thread_id="cb",
+                    title="cold b", model=None, summary=None,
+                    updated_at="2025-01-01T00:00:01+00:00",
+                    created_at="2025-01-01T00:00:00+00:00", tags=[],
+                ),
+            ]
+        )
+
+        items = controller.active_session_items()
+        by_id = {item.thread_id: item for item in items}
+        assert set(by_id) == {"ca", "cb"}
+        assert by_id["ca"].status == SessionStatus.COLD
+        assert by_id["ca"].project_id == "pa"
+        assert by_id["ca"].project_label == "proj-a"
+        assert by_id["ca"].title == "cold a"
+        assert by_id["ca"].current is False
+        # Sorted by persisted updated_at, newest first.
+        assert [item.thread_id for item in items] == ["ca", "cb"]
+
+    def test_runtime_status_overrides_catalog_row(self) -> None:
+        from synapse.projects.catalog import CatalogSession
+
+        controller = self._controller()
+        controller._sessions["live"] = self._runtime(
+            controller,
+            thread_id="live",
+            project_id="pa",
+            status=SessionStatus.RUNNING,
+            activity=1.0,
+            workspace="proj-a",
+        )
+        controller._app._project_catalog = SimpleNamespace(
+            list_sessions=lambda *, limit=200: [
+                CatalogSession(
+                    project_id="pa", project_name="proj-a",
+                    workspace_path="/ws/a", thread_id="live",
+                    title="catalog title", model=None, summary=None,
+                    updated_at="2025-01-01T00:00:00+00:00",
+                    created_at="2025-01-01T00:00:00+00:00", tags=[],
+                ),
+                CatalogSession(
+                    project_id="pb", project_name="proj-b",
+                    workspace_path="/ws/b", thread_id="cold",
+                    title="cold b", model=None, summary=None,
+                    updated_at="2025-01-01T00:00:01+00:00",
+                    created_at="2025-01-01T00:00:00+00:00", tags=[],
+                ),
+            ]
+        )
+
+        items = controller.active_session_items()
+        by_id = {item.thread_id: item for item in items}
+        # Runtime snapshot status wins over the catalog projection.
+        assert by_id["live"].status == SessionStatus.RUNNING
+        assert by_id["cold"].status == SessionStatus.COLD
+        # Live runtime (now - 1s) sorts before the cold 2025 row.
+        assert [item.thread_id for item in items] == ["live", "cold"]
+
+    def test_runtime_not_in_catalog_is_appended(self) -> None:
+        controller = self._controller()
+        controller._sessions["active"] = self._runtime(
+            controller,
+            thread_id="active",
+            project_id="pa",
+            status=SessionStatus.RUNNING,
+            activity=1.0,
+        )
+        # Catalog has no projection yet (active turn not persisted).
+        controller._app._project_catalog = SimpleNamespace(
+            list_sessions=lambda *, limit=200: []
+        )
+
+        items = controller.active_session_items()
+        assert [item.thread_id for item in items] == ["active"]
+        assert items[0].status == SessionStatus.RUNNING
+
+    def test_catalog_failure_falls_back_to_legacy(self) -> None:
+        def _boom(**kwargs: Any) -> list[Any]:
+            del kwargs
+            raise RuntimeError("db locked")
+
+        controller = self._controller()
+        controller._sessions["a"] = self._runtime(
+            controller,
+            thread_id="a",
+            project_id="p1",
+            status=SessionStatus.RUNNING,
+            activity=1.0,
+        )
+        controller._app._project_catalog = SimpleNamespace(list_sessions=_boom)
+
+        # Legacy fallback: live runtime survives, no exception leaks.
+        items = controller.active_session_items()
+        assert [item.thread_id for item in items] == ["a"]
+        assert items[0].status == SessionStatus.RUNNING
+
 
     def test_current_flag_marks_attached_thread(self) -> None:
         controller = self._controller()

{synapse_cli_agent-0.1.30 → synapse_cli_agent-0.1.31}/uv.lock

@@ -2326,7 +2326,7 @@ wheels = [
 
 [[package]]
 name = "synapse-cli-agent"
-version = "0.1.30"
+version = "0.1.31"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },

synapse_cli_agent-0.1.30/release_body.md

@@ -1,13 +0,0 @@
-## v0.1.30
-
-### New Features
-
-- TUI startup timing trace: the startup report now covers the full CLI module-tree import (typer, settings, stream modules) that previously fell outside the trace, making startup bottlenecks visible.
-- Faster TUI startup: the model registry prewarm is optimized so the interface appears sooner.
-
-### Engineering
-
-- Release workflow now builds standalone single-file executables for Windows, Linux, and macOS (PyInstaller) and attaches them to the GitHub Release; the GitHub Release creation was moved to a dedicated job that waits for both the Python distributions and the executables, while PyPI publishing stays independent.
-- Translated AGENTS.md and CHANGELOG.md to English; updated the README homepage demo media with an animated GIF and an mp4 fallback source.
-
----