@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

package/integrations/hermes/tests/test_supervisor_fsm.py

@@ -0,0 +1,581 @@
+"""Supervisor FSM transition tests with mock MCP."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from unittest.mock import MagicMock
+
+import pytest
+
+from open_gsd_hermes.binding import SessionBindStore
+from open_gsd_hermes.commands import GsdCommandRouter
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import McpProtocolError
+from open_gsd_hermes.notifications import NotificationService
+from open_gsd_hermes.supervisor import SupervisorContext, SupervisorFsm, SupervisorState
+from open_gsd_hermes.types import (
+    BindingContext,
+    DeliveryTarget,
+    ProgressSnapshot,
+    SessionStatus,
+)
+
+
+class MockClient:
+    def __init__(self) -> None:
+        self.status_calls = 0
+        self._status = SessionStatus(status="running")
+        self._progress = ProgressSnapshot(phase="execute")
+        self.invalidated: list[str | None] = []
+
+    def status(self, _session_id: str) -> SessionStatus:
+        self.status_calls += 1
+        return self._status
+
+    def progress(self, _project_dir: str) -> ProgressSnapshot:
+        return self._progress
+
+    def invalidate_cache(self, _project_dir: str | None = None) -> None:
+        self.invalidated.append(_project_dir)
+
+
+class MockSupervisor:
+    def __init__(self) -> None:
+        self.started = False
+        self.stopped = False
+        self.calls: list[str] = []
+
+    def start(self) -> None:
+        self.started = True
+        self.calls.append("start")
+
+    def stop(self) -> None:
+        self.stopped = True
+        self.calls.append("stop")
+
+
+def build_router(tmp_path, client, supervisor=None, ctx=None, notifications=None):
+    project_dir = tmp_path / "project"
+    (project_dir / ".gsd").mkdir(parents=True, exist_ok=True)
+    if supervisor is None:
+        supervisor = MockSupervisor()
+    if ctx is None:
+        ctx = SupervisorContext()
+    stored: list[SupervisorContext] = []
+    router = GsdCommandRouter(
+        GsdConfig(default_project=str(project_dir)),
+        client,
+        SessionBindStore(),
+        supervisor,  # type: ignore[arg-type]
+        lambda: "session-key",
+        lambda: BindingContext(),
+        lambda: ctx,
+        stored.append,
+        lambda: (None, None),
+        notifications,
+    )
+    return router, project_dir, supervisor, ctx, stored
+
+
+def test_supervisor_restart_keeps_abandoned_thread_stop_event_set() -> None:
+    fsm = SupervisorFsm(
+        GsdConfig(poll_interval_seconds=1),
+        MagicMock(),
+        MagicMock(),
+        lambda: SupervisorContext(),
+        lambda c: None,
+    )
+    abandoned_stop = fsm._stop
+    abandoned_stop.set()
+    fsm._thread = None
+
+    fsm.start()
+
+    try:
+        assert abandoned_stop.is_set()
+        assert fsm._stop is not abandoned_stop
+    finally:
+        fsm.stop()
+
+
+def test_bind_rejects_invalid_path_instead_of_falling_back_to_default(tmp_path) -> None:
+    project_dir = tmp_path / "project"
+    (project_dir / ".gsd").mkdir(parents=True)
+    bind_store = SessionBindStore()
+    client = MagicMock()
+
+    router = GsdCommandRouter(
+        GsdConfig(default_project=str(project_dir)),
+        client,
+        bind_store,
+        MockSupervisor(),  # type: ignore[arg-type]
+        lambda: "session-key",
+        lambda: BindingContext(),
+        lambda: SupervisorContext(),
+        lambda c: None,
+        lambda: (None, None),
+    )
+
+    result = asyncio.run(router._cmd_bind([str(tmp_path / "missing")]))
+
+    assert "is not a GSD project" in result
+    assert bind_store.get("session-key") is None
+    client.invalidate_cache.assert_not_called()
+
+
+def test_auto_resets_session_specific_supervisor_context(tmp_path) -> None:
+    project_dir = tmp_path / "project"
+    (project_dir / ".gsd").mkdir(parents=True)
+    ctx = SupervisorContext(
+        session_id="old-session",
+        project_dir="/tmp/old",
+        state=SupervisorState.COMPLETE,
+        last_progress=ProgressSnapshot(active_task={"id": "old-task"}),
+        last_status=SessionStatus(status="complete"),
+        pending_blocker_id="old-blocker",
+        notified_terminal=True,
+    )
+    supervisor = MockSupervisor()
+    client = MagicMock()
+    client.execute.return_value = {"sessionId": "new-session"}
+
+    router = GsdCommandRouter(
+        GsdConfig(default_project=str(project_dir)),
+        client,
+        SessionBindStore(),
+        supervisor,  # type: ignore[arg-type]
+        lambda: "session-key",
+        lambda: BindingContext(),
+        lambda: ctx,
+        lambda c: None,
+        lambda: (None, None),
+    )
+
+    result = asyncio.run(router._cmd_auto([]))
+
+    assert result == "Started GSD auto mode (session `new-session`)"
+    assert supervisor.started
+    assert supervisor.calls == ["stop", "start"]
+    assert ctx.session_id == "new-session"
+    assert ctx.project_dir == str(project_dir)
+    assert ctx.state == SupervisorState.RUNNING
+    assert ctx.last_progress is None
+    assert ctx.last_status is None
+    assert ctx.pending_blocker_id is None
+    assert not ctx.notified_terminal
+
+
+def test_status_returns_friendly_message_when_mcp_progress_fails(tmp_path) -> None:
+    client = MagicMock()
+    client.progress.side_effect = McpProtocolError("sidecar unavailable")
+    router, _project_dir, _supervisor, _ctx, _stored = build_router(tmp_path, client)
+
+    result = asyncio.run(router._cmd_status([]))
+
+    assert result == "GSD status unavailable: sidecar unavailable"
+
+
+def test_auto_returns_friendly_message_when_mcp_execute_fails(tmp_path) -> None:
+    supervisor = MockSupervisor()
+    client = MagicMock()
+    client.execute.side_effect = McpProtocolError("sidecar unavailable")
+    router, _project_dir, _supervisor, _ctx, _stored = build_router(
+        tmp_path, client, supervisor=supervisor
+    )
+
+    result = asyncio.run(router._cmd_auto([]))
+
+    assert result == "Could not start GSD auto mode: sidecar unavailable"
+    assert supervisor.calls == []
+
+
+def test_auto_rejects_missing_session_id_in_mcp_response(tmp_path) -> None:
+    supervisor = MockSupervisor()
+    client = MagicMock()
+    client.execute.return_value = {}
+    router, _project_dir, _supervisor, ctx, _stored = build_router(
+        tmp_path, client, supervisor=supervisor
+    )
+
+    result = asyncio.run(router._cmd_auto([]))
+
+    assert result == "Could not start GSD auto mode: missing session ID"
+    assert supervisor.calls == []
+    assert ctx.session_id is None
+    assert ctx.state == SupervisorState.IDLE
+
+
+def test_cancel_stops_supervisor_when_mcp_cancel_fails(tmp_path) -> None:
+    supervisor = MockSupervisor()
+    client = MagicMock()
+    client.cancel_by_project.side_effect = McpProtocolError("sidecar unavailable")
+    router, _project_dir, _supervisor, ctx, stored = build_router(
+        tmp_path, client, supervisor=supervisor
+    )
+
+    result = asyncio.run(router._cmd_cancel([]))
+
+    assert result == "Cancel request failed: sidecar unavailable"
+    assert supervisor.calls == ["stop"]
+    assert ctx.state == SupervisorState.CANCELLED
+    assert stored == [ctx]
+
+
+def test_cancel_sends_terminal_notification_after_successful_mcp_cancel(tmp_path) -> None:
+    supervisor = MockSupervisor()
+    notifications = MagicMock()
+    client = MagicMock()
+    ctx = SupervisorContext(
+        session_id="s1",
+        state=SupervisorState.RUNNING,
+    )
+    router, project_dir, _supervisor, ctx, stored = build_router(
+        tmp_path,
+        client,
+        supervisor=supervisor,
+        ctx=ctx,
+        notifications=notifications,
+    )
+
+    result = asyncio.run(router._cmd_cancel([]))
+
+    assert result == "Cancel requested."
+    client.cancel.assert_called_once_with(
+        session_id="s1",
+        project_dir=str(project_dir),
+    )
+    notifications.notify_terminal.assert_called_once_with("cancelled")
+    assert supervisor.calls == ["stop"]
+    assert ctx.state == SupervisorState.CANCELLED
+    assert ctx.notified_terminal
+    assert stored == [ctx]
+
+
+def test_cancel_prefers_supervisor_project_for_active_session(tmp_path) -> None:
+    current_project = tmp_path / "current"
+    current_project.mkdir()
+    (current_project / ".gsd").mkdir()
+    running_project = tmp_path / "running"
+    running_project.mkdir()
+    (running_project / ".gsd").mkdir()
+    supervisor = MockSupervisor()
+    client = MagicMock()
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir=str(running_project),
+        state=SupervisorState.RUNNING,
+    )
+    stored: list[SupervisorContext] = []
+    router = GsdCommandRouter(
+        GsdConfig(default_project=str(current_project)),
+        client,
+        SessionBindStore(),
+        supervisor,  # type: ignore[arg-type]
+        lambda: "session-key",
+        lambda: BindingContext(),
+        lambda: ctx,
+        stored.append,
+        lambda: (None, None),
+    )
+
+    result = asyncio.run(router._cmd_cancel([]))
+
+    assert result == "Cancel requested."
+    client.cancel.assert_called_once_with(
+        session_id="s1",
+        project_dir=str(running_project),
+    )
+
+
+def test_cancel_stops_supervisor_when_binding_resolution_fails(tmp_path) -> None:
+    supervisor = MockSupervisor()
+    client = MagicMock()
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir=str(tmp_path / "missing"),
+        state=SupervisorState.RUNNING,
+    )
+    bind_store = SessionBindStore()
+    bind_store.set("session-key", str(tmp_path / "missing"))
+    stored: list[SupervisorContext] = []
+    router = GsdCommandRouter(
+        GsdConfig(default_project=None),
+        client,
+        bind_store,
+        supervisor,  # type: ignore[arg-type]
+        lambda: "session-key",
+        lambda: BindingContext(),
+        lambda: ctx,
+        stored.append,
+        lambda: (None, None),
+    )
+
+    result = asyncio.run(router._cmd_cancel([]))
+
+    assert "is not a GSD project" in result
+    client.cancel.assert_not_called()
+    client.cancel_by_project.assert_not_called()
+    assert supervisor.calls == ["stop"]
+    assert ctx.state == SupervisorState.CANCELLED
+    assert stored == [ctx]
+
+
+def test_reply_returns_friendly_message_when_mcp_resolve_fails(tmp_path) -> None:
+    client = MagicMock()
+    client.resolve_blocker.side_effect = McpProtocolError("sidecar unavailable")
+    ctx = SupervisorContext(session_id="s1", project_dir="/tmp/project")
+    router, _project_dir, _supervisor, _ctx, _stored = build_router(
+        tmp_path, client, ctx=ctx
+    )
+
+    result = asyncio.run(router._cmd_reply(["hello"]))
+
+    assert result == "Could not send blocker response: sidecar unavailable"
+    client.invalidate_cache.assert_not_called()
+
+
+def test_supervisor_detects_blocker() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.RUNNING,
+    )
+    client = MockClient()
+    client._status = SessionStatus(
+        status="running",
+        pending_blocker={"id": "b1", "question": "Approve deploy?"},
+    )
+    sent: list[str] = []
+
+    def dispatch(_name: str, args: dict) -> None:
+        sent.append(args.get("text", ""))
+
+    target = DeliveryTarget("slack", "channel", "C123")
+    notifications = NotificationService(
+        MagicMock(),
+        GsdConfig(),
+        lambda: target,
+        dispatch=dispatch,
+    )
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,  # type: ignore[arg-type]
+        notifications,
+        lambda: ctx,
+        lambda c: None,
+    )
+    fsm._tick()
+    assert ctx.state == SupervisorState.BLOCKED
+    assert any("blocker" in t.lower() or "Approve" in t for t in sent)
+
+
+def test_supervisor_terminal_tick_updates_progress_before_stopping() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.RUNNING,
+        last_progress=ProgressSnapshot(
+            active_task={"id": "old-task"},
+            phase="execute",
+        ),
+    )
+    client = MockClient()
+    client._status = SessionStatus(status="complete")
+    client._progress = ProgressSnapshot(
+        active_task={"id": "new-task"},
+        phase="complete",
+    )
+    stored: list[SupervisorContext] = []
+    sent: list[str] = []
+
+    def dispatch(_name: str, args: dict) -> None:
+        sent.append(args.get("text", ""))
+
+    target = DeliveryTarget("slack", "channel", "C123")
+    notifications = NotificationService(
+        MagicMock(),
+        GsdConfig(),
+        lambda: target,
+        dispatch=dispatch,
+    )
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,  # type: ignore[arg-type]
+        notifications,
+        lambda: ctx,
+        stored.append,
+    )
+    fsm._thread = threading.current_thread()
+
+    fsm._tick()
+
+    assert fsm._stop.is_set()
+    assert ctx.notified_terminal
+    assert ctx.last_progress == client._progress
+    assert stored == [ctx]
+    assert any("finished" in t for t in sent)
+    assert any("new-task" in t for t in sent)
+    assert sent == [
+        "📋 GSD: task → new-task",
+        "✅ GSD auto mode finished.",
+    ]
+
+
+def test_supervisor_terminal_status_takes_precedence_over_pending_blocker() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.BLOCKED,
+    )
+    client = MockClient()
+    client._status = SessionStatus(
+        status="Completed",
+        pending_blocker={"id": "b1", "question": "Approve deploy?"},
+    )
+    stored: list[SupervisorContext] = []
+    sent: list[str] = []
+
+    def dispatch(_name: str, args: dict) -> None:
+        sent.append(args.get("text", ""))
+
+    notifications = NotificationService(
+        MagicMock(),
+        GsdConfig(),
+        lambda: DeliveryTarget("slack", "channel", "C123"),
+        dispatch=dispatch,
+    )
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,  # type: ignore[arg-type]
+        notifications,
+        lambda: ctx,
+        stored.append,
+    )
+    fsm._thread = threading.current_thread()
+
+    fsm._tick()
+
+    assert ctx.state == SupervisorState.COMPLETE
+    assert ctx.notified_terminal
+    assert fsm._stop.is_set()
+    assert stored == [ctx]
+    assert sent == ["✅ GSD auto mode finished."]
+
+
+def test_supervisor_notifies_new_blocker_while_already_blocked() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.BLOCKED,
+        pending_blocker_id="b1",
+    )
+    client = MockClient()
+    client._status = SessionStatus(
+        status="running",
+        pending_blocker={"id": "b2", "question": "Choose option?"},
+    )
+    notifications = MagicMock()
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,  # type: ignore[arg-type]
+        notifications,
+        lambda: ctx,
+        lambda c: None,
+    )
+
+    fsm._tick()
+
+    assert ctx.pending_blocker_id == "b2"
+    notifications.notify_blocker.assert_called_once_with(client._status)
+
+
+def test_supervisor_terminal_status_notifies_even_when_progress_fails() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.RUNNING,
+    )
+    client = MagicMock()
+    client.status.return_value = SessionStatus(status="complete")
+    client.progress.side_effect = RuntimeError("read failed")
+    notifications = MagicMock()
+    stored: list[SupervisorContext] = []
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,
+        notifications,
+        lambda: ctx,
+        stored.append,
+    )
+
+    fsm._tick()
+
+    assert fsm._stop.is_set()
+    assert ctx.state == SupervisorState.COMPLETE
+    assert ctx.notified_terminal
+    assert stored == [ctx]
+    notifications.notify_terminal.assert_called_once_with("complete", None)
+
+
+def test_supervisor_terminal_notification_failure_still_stops() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.RUNNING,
+    )
+    client = MockClient()
+    client._status = SessionStatus(status="complete")
+    notifications = MagicMock()
+    notifications.notify_terminal.side_effect = RuntimeError("dispatch failed")
+    stored: list[SupervisorContext] = []
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,  # type: ignore[arg-type]
+        notifications,
+        lambda: ctx,
+        stored.append,
+    )
+
+    with pytest.raises(RuntimeError, match="dispatch failed"):
+        fsm._tick()
+
+    assert fsm._stop.is_set()
+    assert ctx.notified_terminal
+    assert stored == [ctx]
+
+
+def test_supervisor_keeps_cache_when_progress_unchanged() -> None:
+    ctx = SupervisorContext(
+        session_id="s1",
+        project_dir="/tmp/p",
+        state=SupervisorState.RUNNING,
+        last_progress=ProgressSnapshot(
+            active_task={"id": "same-task"},
+            phase="execute",
+        ),
+    )
+    client = MockClient()
+    client._status = SessionStatus(status="running")
+    client._progress = ProgressSnapshot(
+        active_task={"id": "same-task"},
+        phase="execute",
+    )
+
+    notifications = NotificationService(
+        MagicMock(),
+        GsdConfig(),
+        lambda: DeliveryTarget("slack", "channel", "C123"),
+        dispatch=lambda _name, _args: None,
+    )
+    fsm = SupervisorFsm(
+        GsdConfig(),
+        client,  # type: ignore[arg-type]
+        notifications,
+        lambda: ctx,
+        lambda c: None,
+    )
+
+    fsm._tick()
+
+    assert client.invalidated == []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengsd/gsd-pi",
-  "version": "1.2.0",
+  "version": "1.3.0-dev.72e3af2a",
   "description": "GSD Pi local-first coding agent",
   "license": "MIT",
   "repository": {
@@ -19,23 +19,26 @@
   },
   "files": [
     "dist",
-    "dist/web",
     "packages/*/dist/**",
     "packages/*/bin/**",
     "packages/*/package.json",
     "packages/*/README.md",
     "pkg",
     "src/resources",
+    "integrations/hermes",
     "scripts/postinstall.js",
     "scripts/install.js",
     "scripts/install",
     "scripts/link-workspace-packages.cjs",
-    "scripts/ensure-workspace-builds.cjs",
     "scripts/lib/workspace-manifest.cjs",
     "scripts/lib/logo.cjs",
     "package.json",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"
@@ -80,7 +83,7 @@
     "test:packages": "pnpm run test:compile && pnpm run test:packages:compiled",
     "test:packages:compiled": "node scripts/run-package-tests.cjs",
     "verify:workspace-coverage": "node scripts/verify-workspace-coverage.cjs",
-    "verify:pi-boundary": "node scripts/verify-pi-boundary.cjs",
+    "verify:pi-boundary": "node scripts/verify-pi-boundary.cjs && bash scripts/check-mcp-bridge-boundary.sh",
     "verify:pi-patches": "node scripts/verify-pi-patches.cjs",
     "test:pi-claude-schemas": "pnpm exec vitest run packages/pi-ai/test/google-shared-convert-tools.test.ts && node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/claude-tool-schema-golden.test.ts",
     "test:marketplace": "node scripts/with-env.mjs GSD_TEST_CLONE_MARKETPLACES=1 -- node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/claude-import-tui.test.ts src/resources/extensions/gsd/tests/plugin-importer-live.test.ts src/tests/marketplace-discovery.test.ts",
@@ -88,11 +91,9 @@
     "test:integration": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test --test-timeout=180000 \"src/tests/integration/*.test.ts\" \"src/resources/extensions/gsd/tests/integration/*.test.ts\" \"src/resources/extensions/async-jobs/*.test.ts\" \"src/resources/extensions/ollama/**/*.test.ts\" \"src/resources/extensions/ollama/*.test.ts\" \"src/resources/extensions/search-the-web/tests/*.test.ts\" \"src/resources/extensions/bg-shell/tests/*.test.ts\" \"src/resources/extensions/slash-commands/tests/*.test.ts\" \"src/resources/extensions/browser-tools/tests/*.test.mjs\"",
     "pretest": "pnpm run typecheck:extensions",
     "test": "pnpm run test:unit && pnpm run test:integration && pnpm run test:packages",
-    "prototype:tui-design": "pnpm run build:pi-tui && pnpm run build:pi-coding-agent && node packages/pi-coding-agent/scripts/run-design-prototype.mjs",
-    "prototype:tui-density": "pnpm run build:pi-tui && pnpm run build:pi-coding-agent && node packages/pi-coding-agent/scripts/run-density-prototype.mjs",
-    "prototype:tui-widget": "pnpm run build:pi-tui && pnpm run build:pi-coding-agent && node --experimental-strip-types packages/gsd-agent-modes/scripts/run-widget-prototype.mjs",
     "test:smoke": "node --experimental-strip-types tests/smoke/run.ts",
     "test:live": "node scripts/with-env.mjs GSD_LIVE_TESTS=1 -- node --experimental-strip-types tests/live/run.ts",
+    "test:live-workflow": "node --experimental-strip-types tests/live-workflow/run.ts",
     "test:browser-tools": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/browser-tools/tests/browser-tools-unit.test.cjs src/resources/extensions/browser-tools/tests/browser-engine-selection.test.mjs src/resources/extensions/browser-tools/tests/managed-gsd-browser-tools.test.mjs src/resources/extensions/browser-tools/tests/browser-tools-integration.test.mjs",
     "test:native": "pnpm --filter @gsd/native run test",
     "test:secret-scan": "node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/tests/secret-scan.test.ts",
@@ -112,6 +113,7 @@
     "sync-pkg-version": "node scripts/sync-pkg-version.cjs",
     "sync-platform-versions": "node native/scripts/sync-platform-versions.cjs",
     "verify:native-platform-packages": "node scripts/verify-native-platform-packages.mjs",
+    "verify:npm-release": "node scripts/verify-npm-release.mjs",
     "verify:version-sync": "node scripts/verify-version-sync.cjs",
     "validate-pack": "node scripts/validate-pack.js",
     "prepack": "node scripts/prepack-resolve-workspace.cjs",
@@ -134,6 +136,7 @@
     "pipeline:version-stamp": "node scripts/version-stamp.mjs",
     "release:changelog": "node scripts/generate-changelog.mjs",
     "release:bump": "node scripts/bump-version.mjs",
+    "release:update-readme-highlights": "node scripts/update-readme-release-highlights.mjs",
     "release:update-changelog": "node scripts/update-changelog.mjs",
     "docker:build-runtime": "docker build --target runtime -t ghcr.io/open-gsd/gsd-pi .",
     "docker:build-builder": "docker build --target builder -t ghcr.io/open-gsd/gsd-ci-builder .",
@@ -153,7 +156,7 @@
     "@mariozechner/jiti": "^2.6.2",
     "@mistralai/mistralai": "2.2.1",
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@opengsd/gsd-browser": "0.1.27",
+    "@opengsd/gsd-browser": "0.2.2",
     "@silvia-odwyer/photon-node": "^0.3.4",
     "@sinclair/typebox": "^0.34.41",
     "@smithy/node-http-handler": "^4.7.3",
@@ -201,21 +204,23 @@
     "@types/proper-lockfile": "^4.1.4",
     "c8": "^11.0.0",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.25.12",
+    "esbuild": "^0.28.1",
     "jiti": "^2.7.0",
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {
     "@mariozechner/clipboard": "0.3.6",
-    "@opengsd/engine-darwin-arm64": "1.2.0",
-    "@opengsd/engine-darwin-x64": "1.2.0",
-    "@opengsd/engine-linux-arm64-gnu": "1.2.0",
-    "@opengsd/engine-linux-x64-gnu": "1.2.0",
-    "@opengsd/engine-win32-x64-msvc": "1.2.0",
+    "@opengsd/engine-darwin-arm64": "1.3.0",
+    "@opengsd/engine-darwin-x64": "1.3.0",
+    "@opengsd/engine-linux-arm64-gnu": "1.3.0",
+    "@opengsd/engine-linux-x64-gnu": "1.3.0",
+    "@opengsd/engine-win32-x64-msvc": "1.3.0",
     "fsevents": "~2.3.3",
     "koffi": "^2.9.0"
   },
   "overrides": {
+    "uuid": "^11.1.1",
+    "postcss": "^8.5.10",
     "@mistralai/mistralai": "2.2.1",
     "gaxios": "7.1.4",
     "c8": {