runspec-console 0.44.0__tar.gz → 0.44.2__tar.gz

{runspec_console-0.44.0 → runspec_console-0.44.2}/CHANGELOG.md

@@ -8,6 +8,37 @@ Version numbers follow [Semantic Versioning](https://semver.org/).
 ---
 
 
+## [0.44.2] — 2026-06-12
+
+### Changed
+- **Helpdesk inbox moved on top of the conversation.** In queue mode the inbox is
+  now a full-width strip above the conversation (was a cramped side column), so
+  each thread row carries a real summary line — status · visitor · assignee ·
+  last-message snippet (catalog requests prefixed) · time — and the open count
+  shows in the header. Still collapses (now up/down) to give the conversation the
+  full screen. Group chat is unchanged.
+
+---
+
+## [0.44.1] — 2026-06-12
+
+### Fixed
+- **Helpdesk catalog re-published on every discovery refresh.** The periodic
+  refresh cycle re-sent (and re-logged `published N tool(s)`) each staffed
+  queue's catalog unconditionally — log spam plus redundant `catalog` frames to
+  the room. The publisher now tracks the last catalog sent per queue namespace
+  and only re-sends when its contents change. Subscribe still forces a send (a
+  fresh connection's hub has no catalog yet); a disconnect clears the cache so a
+  reconnect republishes from scratch.
+
+### Changed
+- **Helpdesk inbox layout.** The queue inbox column is now collapsible (fold to
+  a thin rail to focus on one conversation full-width), and the presence sidebar
+  is hidden in queue mode — a helpdesk thread is 1:1 (you + the visitor), so that
+  width goes to the conversation. Group chat is unchanged.
+
+---
+
 ## [0.44.0] — 2026-06-12
 
 ### Added

{runspec_console-0.44.0 → runspec_console-0.44.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runspec-console
-Version: 0.44.0
+Version: 0.44.2
 Requires-Python: >=3.11
 Requires-Dist: cryptography>=42.0
 Requires-Dist: paramiko>=3.0

{runspec_console-0.44.0 → runspec_console-0.44.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "runspec-console"
-version = "0.44.0"
+version = "0.44.2"
 requires-python = ">=3.11"
 dependencies = [
     "pywebview>=5.0",

{runspec_console-0.44.0 → runspec_console-0.44.2}/runspec_console/bridge.py

@@ -254,6 +254,10 @@ class Bridge:
         self._thread_states: dict[str, dict[str, Any]] = {}
         self._agent_rooms: dict[str, str] = {}
         self._catalog_index: dict[str, dict[str, dict[str, Any]]] = {}
+        # namespace → last catalog actually published, so the periodic refresh
+        # only re-sends (and logs) when the contents change. Cleared on disconnect
+        # so the next subscribe republishes from scratch.
+        self._published_catalogs: dict[str, list[dict[str, Any]]] = {}
         self._hosts: list[dict[str, Any]] = []
         # Named source-side stream filters (runspec_filters.toml). Loaded once at
         # startup and reloaded on save; resolved by name when a relay/download
@@ -5063,8 +5067,9 @@ class Bridge:
             backoff = self._CHAT_BACKOFF_START
             if queue:
                 # Publish the queue's self-service catalog right after subscribing
-                # (and again whenever discovery refreshes — _publish_catalogs).
-                self._publish_catalog(spec, source)
+                # (forced — a fresh connection's hub has no catalog yet; later
+                # discovery refreshes republish only on change — _publish_catalogs).
+                self._publish_catalog(spec, source, force=True)
             watcher = _RotaPresenceWatcher(self._build_clock_ok(), source.set_presence)
             watcher.start()
             self._dispatch(
@@ -5080,6 +5085,9 @@ class Bridge:
             with self._lock:
                 self._chat_sources.pop(room, None)
                 self._agent_rooms.pop(room, None)
+                self._published_catalogs.pop(
+                    room, None
+                )  # force a fresh publish on reconnect
             self._dispatch(
                 "runspec:room_connection",
                 {"room": room, "host": host, "connected": False, "queue": queue},
@@ -5091,23 +5099,34 @@ class Bridge:
                 break
             backoff = min(backoff * 2, self._CHAT_BACKOFF_MAX)
 
-    def _publish_catalog(self, spec: dict[str, Any], source: Any) -> None:
+    def _publish_catalog(
+        self, spec: dict[str, Any], source: Any, *, force: bool = False
+    ) -> None:
         """Build and publish one queue's self-service catalog from the discovery
-        cache (best-effort — a failed publish never breaks the connection; the
-        next discovery refresh or reconnect republishes)."""
+        cache. **Idempotent**: the catalog is only sent (and logged) when its
+        contents changed since the last publish for this namespace — so the
+        periodic discovery refresh doesn't re-emit an unchanged catalog every
+        cycle. ``force`` overrides the diff (the subscribe path always sends, as
+        a fresh connection's hub has no catalog yet). Best-effort — a failed
+        publish never breaks the connection; the next refresh or reconnect
+        republishes."""
         from .catalog import build_catalog
 
         try:
+            key = spec["room"]
             with self._lock:
                 runnables = list(self._runnables_cache)
             allowlist = spec.get("catalog_allowlist")
             tools, index = build_catalog(runnables, allowlist=allowlist)
             with self._lock:
-                self._catalog_index[spec["room"]] = index
+                self._catalog_index[key] = index  # enactment map — keep current
+                unchanged = not force and self._published_catalogs.get(key) == tools
+                if not unchanged:
+                    self._published_catalogs[key] = tools
+            if unchanged:
+                return  # nothing to send — the room already has this catalog
             source.send_catalog(tools)
-            logger.info(
-                "chat: published %d tool(s) to %r catalog", len(tools), spec["room"]
-            )
+            logger.info("chat: published %d tool(s) to %r catalog", len(tools), key)
         except Exception:
             logger.exception("chat: catalog publish for %r failed", spec.get("room"))
 

{runspec_console-0.44.0 → runspec_console-0.44.2}/tests/test_chat_bridge.py

@@ -237,6 +237,7 @@ def _supervisor_stub():
     s._chat_sources = {}
     s._agent_rooms = {}
     s._thread_states = {}
+    s._published_catalogs = {}
     s._trigger_engine = None
     s.dispatched: list[tuple[str, dict]] = []
     s._dispatch = lambda ev, detail: s.dispatched.append((ev, detail))
@@ -246,8 +247,10 @@ def _supervisor_stub():
     s._on_chat_event = types.MethodType(Bridge._on_chat_event, s)
     s._feed_engine_for = types.MethodType(Bridge._feed_engine_for, s)
     s._chat_supervise = types.MethodType(Bridge._chat_supervise, s)
-    s._publish_catalog = lambda spec, source: s.published.append(spec["room"])
     s.published: list[str] = []
+    s._publish_catalog = lambda spec, source, *, force=False: s.published.append(
+        spec["room"]
+    )
     return s
 
 
@@ -294,9 +297,9 @@ def test_chat_supervisor_agent_mode_publishes_catalog_and_registers():
     registered: list[dict[str, str]] = []
     orig_publish = s._publish_catalog
 
-    def publish_and_snapshot(sp, source):
+    def publish_and_snapshot(sp, source, *, force=False):
         registered.append(dict(s._agent_rooms))  # registered before publishing
-        orig_publish(sp, source)
+        orig_publish(sp, source, force=force)
 
     s._publish_catalog = publish_and_snapshot
     s._chat_stop.clear()
@@ -406,6 +409,62 @@ def test_send_room_message_unstaffed_conversation_fails():
     assert out["ok"] is False and "not connected" in out["error"]
 
 
+# ── catalog publish dedup ──────────────────────────────────────────────────────
+
+
+class _CatalogSource:
+    def __init__(self) -> None:
+        self.sends: list[list[dict]] = []
+
+    def send_catalog(self, tools: list[dict]) -> None:
+        self.sends.append(tools)
+
+
+def _catalog_stub(runnables: list[dict[str, Any]]):
+    s = types.SimpleNamespace()
+    s._lock = threading.Lock()
+    s._runnables_cache = runnables
+    s._catalog_index = {}
+    s._published_catalogs = {}
+    s._publish_catalog = types.MethodType(Bridge._publish_catalog, s)
+    return s
+
+
+def test_publish_catalog_skips_unchanged_then_sends_on_change():
+    rn = {
+        "name": "reset-password",
+        "host": "web01",
+        "description": "",
+        "autonomy": "confirm",
+        "args": [],
+        "requireCommand": False,
+        "rawSpec": {"discoverable": ["self-service"]},
+    }
+    s = _catalog_stub([rn])
+    spec = {"room": "helpdesk/it", "queue": "it"}
+    src = _CatalogSource()
+
+    s._publish_catalog(spec, src)  # first publish → sends
+    s._publish_catalog(spec, src)  # discovery refresh, nothing changed → skipped
+    assert len(src.sends) == 1
+    assert [t["name"] for t in src.sends[0]] == ["reset-password"]
+
+    # A new self-service runnable appears → the next refresh re-sends.
+    s._runnables_cache = [rn, {**rn, "name": "request-vm"}]
+    s._publish_catalog(spec, src)
+    assert len(src.sends) == 2
+    assert [t["name"] for t in src.sends[1]] == ["reset-password", "request-vm"]
+
+
+def test_publish_catalog_force_always_sends():
+    s = _catalog_stub([])
+    spec = {"room": "helpdesk/it", "queue": "it"}
+    src = _CatalogSource()
+    s._publish_catalog(spec, src, force=True)
+    s._publish_catalog(spec, src, force=True)  # reconnect → resend even if empty
+    assert src.sends == [[], []]
+
+
 # ── thread controls (claim / resolve / reopen / close) ─────────────────────────