@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/test_verification_stats.py

@@ -1,32 +0,0 @@
-"""Tests for readback verification stats + the resolve_control verification_stats action."""
-import unittest
-
-import src.server as s
-from src.utils import readback
-from src.utils.readback import verify_by_readback, reset_verification_stats
-
-
-class VerificationStatsTest(unittest.TestCase):
-    def setUp(self):
-        reset_verification_stats()
-
-    def test_counts_outcomes(self):
-        verify_by_readback(mutate=lambda: True, observe=lambda: "ok")      # verified
-        verify_by_readback(mutate=lambda: True, observe=lambda: None)      # contradicted
-        verify_by_readback(mutate=lambda: False, observe=lambda: None)     # unverified
-        st = readback.verification_stats()
-        self.assertEqual(st["total"], 3)
-        self.assertEqual(st["verified"], 1)
-        self.assertEqual(st["contradicted"], 1)
-        self.assertEqual(st["unverified"], 1)
-
-    def test_action_no_connection(self):
-        reset_verification_stats()
-        verify_by_readback(mutate=lambda: True, observe=lambda: "ok")
-        out = s.resolve_control("verification_stats", {})
-        self.assertEqual(out["stats"]["verified"], 1)
-        self.assertIn("note", out)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_waveb_p2_p3.py

@@ -1,65 +0,0 @@
-"""Tests for the final batch: Wave B (EX11 track-index), P2 read-back
-(delete_timelines count), P3 (raw set_cdl validation)."""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class AudioTrackProbeEX11Test(unittest.TestCase):
-    def _tl(self, count):
-        tl = mock.Mock()
-        tl.GetTrackCount.return_value = count
-        # getters return benign values
-        for m in ("GetTrackSubType", "GetTrackName", "GetIsTrackEnabled", "GetIsTrackLocked"):
-            getattr(tl, m).return_value = "x"
-        tl.GetVoiceIsolationState.return_value = {"isEnabled": False, "amount": 0}
-        return tl
-
-    def test_index_zero_is_unavailable(self):
-        out = s._audio_track_probe(self._tl(3), {"track_index": 0})
-        self.assertFalse(out["available"])  # was True under the old <= check
-
-    def test_negative_index_unavailable(self):
-        out = s._audio_track_probe(self._tl(3), {"track_index": -1})
-        self.assertFalse(out["available"])
-
-    def test_valid_index_available(self):
-        out = s._audio_track_probe(self._tl(3), {"track_index": 2})
-        self.assertTrue(out["available"])
-
-
-class DeleteTimelinesReadbackTest(unittest.TestCase):
-    def test_verified_true_when_count_drops(self):
-        fake_tl = mock.Mock()
-        fake_tl.GetUniqueId.return_value = "tid"
-        fake_tl.GetName.return_value = "T"
-        fake_proj = mock.Mock()
-        fake_proj.GetTimelineByIndex.return_value = fake_tl
-        fake_mp = mock.Mock()
-        fake_mp.DeleteTimelines.return_value = True
-        # GetTimelineCount: once to build the list (1), then before(2), then after(1).
-        fake_proj.GetTimelineCount.side_effect = [1, 2, 1]
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)), \
-             mock.patch.object(s, "_get_mp", return_value=(mock.Mock(), fake_proj, fake_mp, None)), \
-             mock.patch.object(s, "_confirm_token_required", return_value=False):
-            fake_mp.GetRootFolder.return_value = mock.Mock()
-            out = s.media_pool("delete_timelines", {"timeline_ids": ["tid"]})
-        self.assertTrue(out["success"])
-        self.assertTrue(out["verified"])
-        self.assertLess(out["timelines_after"], out["timelines_before"])
-
-
-class RawSetCdlValidationTest(unittest.TestCase):
-    def test_malformed_cdl_rejected(self):
-        fake_item = mock.Mock()
-        # _validate_cdl_payload should reject a non-dict / malformed cdl.
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), mock.Mock(), None)), \
-             mock.patch.object(s, "_get_item", return_value=(mock.Mock(), fake_item, None)):
-            out = s.timeline_item_color("set_cdl", {"cdl": "not-a-cdl"})
-        self.assertIn("error", out)
-        fake_item.SetCDL.assert_not_called()
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/golem-rhino-mcp/docs/ARCHITECTURE.md

@@ -1,277 +0,0 @@
-# GOLEM-3DMCP — System Architecture
-
-## Overview
-
-GOLEM-3DMCP is a two-part system. One part runs in the standard Python environment managed by Claude Code; the other runs inside Rhino 3D's embedded Python interpreter. They communicate over a local TCP socket using a length-prefixed JSON protocol.
-
-```
-+---------------------+         stdio          +---------------------+
-|   Claude Code       | <--------------------> |   MCP Server        |
-|   (claude.ai/code)  |      MCP protocol      |   mcp_server/       |
-+---------------------+                        +---------------------+
-                                                         |
-                                                         | TCP 127.0.0.1:9876
-                                                         | length-prefixed JSON
-                                                         v
-                                                +---------------------+
-                                                |   Rhino Plugin      |
-                                                |   rhino_plugin/     |
-                                                |   (Python 3.9,      |
-                                                |    inside Rhino)    |
-                                                +---------------------+
-                                                         |
-                                               RhinoCommon API calls
-                                                         |
-                                                         v
-                                                +---------------------+
-                                                |   Rhinoceros 3D     |
-                                                |   UI Thread         |
-                                                |   Document Model    |
-                                                +---------------------+
-                                                         |
-                                            Optional GH sub-connection
-                                                         |
-                                                         v
-                                                +---------------------+
-                                                |   Grasshopper       |
-                                                |   TCP 127.0.0.1:9877|
-                                                +---------------------+
-```
-
----
-
-## Part 1 — MCP Server (`mcp_server/`)
-
-The MCP server runs as a subprocess spawned by Claude Code. It speaks the Model Context Protocol over stdio and translates each tool call into a TCP command sent to the Rhino plugin.
-
-### Entry Point
-
-`mcp_server/server.py` creates a single `FastMCP` instance named `GOLEM-3DMCP`. Tool modules are imported inside `main()` rather than at module scope to avoid circular imports — the tool modules import the `mcp` singleton from `server.py`, so they must not be imported until after `mcp` is constructed.
-
-```python
-# mcp_server/server.py (simplified)
-mcp = FastMCP("GOLEM-3DMCP", description="...")
-
-def main() -> None:
-    from mcp_server.tools import scene, creation, operations, ...
-    mcp.run(transport="stdio")
-```
-
-### TCP Client (`mcp_server/connection.py`)
-
-`RhinoConnection` manages the persistent TCP socket to the Rhino plugin. Key design decisions:
-
-**Singleton pattern.** Only one `RhinoConnection` exists per MCP server process. `get_connection()` creates and connects it on first call; subsequent calls return the same instance. This avoids port exhaustion and matches Rhino's single-client model.
-
-**Thread safety.** A `threading.Lock` serialises every send/receive cycle. The FastMCP framework may call tool functions from multiple threads concurrently; the lock ensures commands are not interleaved on the socket.
-
-**Auto-reconnect.** On `BrokenPipeError` or `ConnectionResetError`, the client automatically attempts up to three reconnections before propagating the error. Timeout errors and application-level errors (`RhinoCommandError`) are not retried.
-
-**Request IDs.** Every outbound message carries a UUID4 as `id`. This enables correlation in logs and debugging, and matches the wire format that Rhino expects.
-
-### Protocol (`mcp_server/protocol.py`)
-
-Wire format: a 4-byte big-endian unsigned 32-bit integer (the payload length in bytes) followed by the UTF-8-encoded JSON payload. Maximum payload: 64 MB.
-
-The same format is implemented identically in `rhino_plugin/protocol.py` for byte-level compatibility. The only difference between the two copies is that the MCP server side uses Python 3.10+ type annotation syntax (`X | Y`) while the Rhino side uses Python 3.9 compatible `Optional[X]`.
-
-### Tool Modules (`mcp_server/tools/`)
-
-Each tool module imports the `mcp` singleton and registers functions with `@mcp.tool()`. The function signatures declare typed parameters and docstrings that become the tool descriptions exposed to Claude Code. The function bodies call `get_connection().send_command(method, params)` and return the result dict.
-
----
-
-## Part 2 — Rhino Plugin (`rhino_plugin/`)
-
-The plugin runs entirely inside Rhino's embedded Python 3.9 interpreter. It binds a TCP server socket, accepts connections from the MCP server, dispatches commands to handler functions, and executes those functions on Rhino's UI thread.
-
-### TCP Server (`rhino_plugin/server.py`)
-
-The server runs in a background daemon thread (the "accept loop") so it does not block Rhino's main thread. One client is served at a time — the accept loop calls `handle_client()` synchronously for each accepted connection. This is intentional: the Rhino document object model is single-threaded, and parallel client sessions would race on shared geometry state.
-
-**Accept loop:**
-```
-Background thread:
-  while running:
-    conn = srv.accept()          # blocks up to 1 second
-    handle_client(conn, addr)    # blocks until client disconnects
-```
-
-**Client handler:**
-```
-For each message:
-  request  = recv_message(conn)   # blocking read
-  response = _dispatch(method, params, id)
-  send_message(conn, response)    # blocking write
-```
-
-### UI Thread Dispatch (`run_on_ui_thread`)
-
-All Rhino document operations must happen on Rhino's main (UI) thread. The background thread cannot safely call RhinoCommon geometry methods directly.
-
-`run_on_ui_thread(func)` solves this by:
-
-1. Wrapping `func` in a closure that captures return value and any exception.
-2. Posting the closure to the UI thread via `Rhino.RhinoApp.InvokeOnUiThread`.
-3. Blocking on a `threading.Event` with a 30-second timeout.
-4. Re-raising any exception that occurred on the UI thread.
-
-Every handler invocation goes through `run_on_ui_thread`, including built-in methods like `ping`. The overhead is negligible and the safety guarantee is absolute.
-
-### Dispatcher (`rhino_plugin/dispatcher.py`)
-
-The dispatcher maintains a `dict` mapping method name strings to handler callables. Registration uses the `@handler("namespace.method_name")` decorator, which stores the function both in the dict and as a `_handler_name` attribute for bulk discovery.
-
-**Error codes defined in `ErrorCode`:**
-
-| Code | Meaning |
-|------|---------|
-| `OK` | Success (not used directly in errors) |
-| `INVALID_PARAMS` | Missing or wrong-type parameter |
-| `OBJECT_NOT_FOUND` | GUID not found in Rhino document |
-| `OPERATION_FAILED` | Rhino returned an error or null result |
-| `TIMEOUT` | UI thread did not respond in time |
-| `INTERNAL_ERROR` | Unhandled exception in handler |
-| `NOT_FOUND` | Method name not registered |
-| `NOT_IMPLEMENTED` | Handler raises `NotImplementedError` |
-
-`dispatch()` always returns a response dict (never raises), mapping Python exceptions to appropriate error codes.
-
-### Handler Registration
-
-`rhino_plugin/handlers/__init__.py` exports `register_all_handlers()`, which imports each handler module and calls `register_handlers_from_module()` on it. This is called once during `start_server()`. The server registers the three built-in methods (`ping`, `shutdown`, `list_methods`) first, then bulk-registers all domain handlers.
-
-The two-step registration (decorator at import + `register_handlers_from_module` scan) is belt-and-suspenders: decorators fire at import time, but the scan catches any function defined before its decorator ran (which can happen during hot-reload or unusual import orderings).
-
-### Handler Modules
-
-Each handler module is a self-contained unit covering one domain:
-
-| Module | Methods | Domain |
-|--------|---------|--------|
-| `scene.py` | 10 | Document info, layers, objects, groups, blocks |
-| `creation.py` | 12 | Primitive solids, curves, text, points |
-| `operations.py` | 19 | Boolean ops, trim/split, offset, fillet, intersect, mesh, rebuild |
-| `surfaces.py` | 12 | Loft, sweep1/2, revolve, extrude, patch, unroll, edge_surface |
-| `manipulation.py` | 21 | Move, copy, rotate, scale, mirror, arrays, join, group, properties |
-| `grasshopper.py` | 9 | Definition control, params, recompute, bake |
-| `viewport.py` | 11 | Capture, camera, display mode, named views |
-| `files.py` | 7 | Save, open, import, export |
-| `scripting.py` | 4 | Python execution, RhinoScript, Rhino commands |
-
-All handlers are Python 3.9 compatible (no `match`/`case`, no `X | Y` union syntax, no lowercase generic annotations at runtime) because they execute in Rhino's embedded interpreter.
-
-### Grasshopper Sub-Server
-
-Grasshopper integration uses a separate internal communication channel on port 9877. The `rhino_plugin/grasshopper/` package contains helpers for serializing Grasshopper components, getting and setting parameter values, and baking geometry. The Grasshopper handlers guard every call with `_GH_AVAILABLE` — if Grasshopper is not loaded in the current Rhino session, the handlers return a clear error rather than crashing.
-
----
-
-## Connection Lifecycle
-
-```
-MCP Server starts
-  └─ get_connection() called on first tool use
-       └─ RhinoConnection.connect(host, port, timeout=10)
-            └─ TCP SYN/ACK (127.0.0.1:9876)
-            └─ send_command("ping", {})   ← verify server alive
-            └─ returns or raises RhinoConnectionError
-
-Per command:
-  └─ send_command(method, params, timeout=30)
-       └─ acquire threading.Lock
-       └─ send_message(sock, request)     ← 4-byte header + JSON
-       └─ recv_message(sock)              ← blocks up to timeout seconds
-       └─ release lock
-       └─ parse response: result or error
-
-On BrokenPipe / ConnectionReset:
-  └─ reconnect() up to 3 times
-  └─ if all fail: raise RhinoConnectionError
-
-Claude Code session ends:
-  └─ MCP server process exits
-  └─ TCP connection closed
-  └─ Rhino plugin accept loop continues (ready for next session)
-```
-
----
-
-## Data Flow: A Single Tool Call
-
-Using `create_box` as an example:
-
-```
-1. User: "Create a 10x20x30 box at the origin."
-   Claude Code → calls MCP tool create_box(width=10, depth=20, height=30)
-
-2. mcp_server/tools/creation.py:create_box()
-   → get_connection().send_command("creation.create_box", {
-       "corner_x": 0, "corner_y": 0, "corner_z": 0,
-       "width": 10, "depth": 20, "height": 30
-     })
-
-3. mcp_server/connection.py:send_command()
-   → assigns request_id = uuid4()
-   → mcp_server/protocol.py:send_message(sock, {
-       "id": "abc-123", "method": "creation.create_box", "params": {...}
-     })
-   → [4 bytes: payload length][JSON bytes] → TCP socket
-
-4. rhino_plugin/server.py:handle_client()
-   → rhino_plugin/protocol.py:recv_message(sock)
-   → _dispatch("creation.create_box", params, "abc-123")
-   → run_on_ui_thread(lambda: handler_func(params))
-
-5. rhino_plugin/handlers/creation.py:create_box()
-   → RhinoCommon: Rhino.Geometry.Box(...)
-   → sc.doc.Objects.AddBrep(box_brep)
-   → returns {"guid": "def-456", "bounding_box": {...}}
-
-6. rhino_plugin/server.py
-   → send_message(conn, {
-       "id": "abc-123", "result": {"guid": "def-456", ...}, "error": null
-     })
-
-7. mcp_server/connection.py:_send_and_recv()
-   → receives response, checks error is null
-   → returns {"guid": "def-456", "bounding_box": {...}}
-
-8. Claude Code receives the result dict.
-   → "I created a box. Its GUID is def-456."
-```
-
----
-
-## Utility Modules
-
-### `rhino_plugin/utils/geometry_serializer.py`
-
-Converts RhinoCommon geometry objects to JSON-serialisable dicts. Functions include:
-
-- `serialize_object(obj)` — general RhinoObject serialiser (type, GUID, name, layer, bounding box)
-- `serialize_brep(brep)` — Brep details (face/edge/vertex counts, is_solid, volume, area)
-- `serialize_curve(curve)` — Curve details (length, is_closed, domain, start/end points)
-- `serialize_mesh(mesh)` — Mesh details (vertex/face counts, is_closed)
-- `serialize_surface(srf)` — Surface details (domain, is_closed in U/V)
-- `serialize_point3d(pt)` — `{"x": float, "y": float, "z": float}`
-- `serialize_bounding_box(bbox)` — min/max corners
-- `serialize_any(geom)` — dispatch to the appropriate serialiser by type
-
-### `rhino_plugin/utils/guid_registry.py`
-
-A `GuidRegistry` singleton that tracks GUIDs of objects created by GOLEM-3DMCP. `validate_guid(guid_str)` raises `KeyError` (containing "not found") if the GUID is not registered, which the dispatcher maps to `OBJECT_NOT_FOUND`. This provides fast existence checks without a Rhino document lookup.
-
-### `rhino_plugin/utils/error_handler.py`
-
-`wrap_handler` is a decorator that wraps handler functions in uniform exception handling. It maps:
-
-- `ValueError` / `TypeError` / `KeyError` with "not found" → `INVALID_PARAMS` / `OBJECT_NOT_FOUND`
-- `GolemError` → its own error code
-- All other exceptions → `INTERNAL_ERROR` with traceback in `details`
-
-`make_error(code, message)` builds an error result dict in the format the dispatcher expects.
-
-### `rhino_plugin/utils/screenshot.py`
-
-`capture_viewport_to_base64(view, width, height, format)` renders the specified Rhino view to a bitmap and encodes it as a base64 string for transmission over the JSON protocol.

package/mcps/golem-rhino-mcp/docs/PROTOCOL.md

@@ -1,247 +0,0 @@
-# GOLEM-3DMCP — TCP Protocol Specification
-
-## Overview
-
-The MCP server and the Rhino plugin communicate over a TCP socket using a simple length-prefixed JSON protocol. Both sides implement the same wire format, defined identically in:
-
-- `mcp_server/protocol.py` (Python 3.10+, MCP server side)
-- `rhino_plugin/protocol.py` (Python 3.9, Rhino plugin side)
-
-The two files are kept in sync manually. Any change to the wire format must be applied to both.
-
----
-
-## Wire Format
-
-Every message — request or response — is framed as:
-
-```
-+------------------+----------------------+
-| 4-byte header    | N-byte payload       |
-| big-endian uint32| UTF-8 JSON bytes     |
-+------------------+----------------------+
-```
-
-**Header:** A 4-byte unsigned 32-bit integer in big-endian byte order (network byte order, `struct` format `!I`). Its value is the exact byte length of the payload that follows.
-
-**Payload:** The UTF-8 encoding of a JSON object. `ensure_ascii=False` is used, so all Unicode characters are preserved as-is rather than escaped.
-
-**Maximum payload size:** 64 MB (67,108,864 bytes). Messages exceeding this limit are rejected with a `ValueError` on both sides to prevent memory exhaustion.
-
-**Minimum payload size:** 0 bytes (empty payload) is technically valid wire-format but will fail JSON parsing.
-
-### Python implementation
-
-```python
-# Sending
-payload = json.dumps(data, ensure_ascii=False).encode("utf-8")
-header = struct.pack("!I", len(payload))
-sock.sendall(header + payload)
-
-# Receiving
-raw_header = _recv_exactly(sock, 4)
-(payload_length,) = struct.unpack("!I", raw_header)
-raw_payload = _recv_exactly(sock, payload_length)
-data = json.loads(raw_payload.decode("utf-8"))
-```
-
-`_recv_exactly(sock, n)` reads exactly `n` bytes, looping across TCP segment boundaries. It raises `ConnectionError` if the remote peer closes the connection before all bytes arrive.
-
----
-
-## Message Format
-
-### Request (MCP server → Rhino plugin)
-
-```json
-{
-  "id": "550e8400-e29b-41d4-a716-446655440000",
-  "method": "creation.create_box",
-  "params": {
-    "corner_x": 0.0,
-    "corner_y": 0.0,
-    "corner_z": 0.0,
-    "width": 100.0,
-    "depth": 50.0,
-    "height": 30.0
-  }
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `id` | string | UUID4 request identifier. Echoed in the response for correlation. |
-| `method` | string | Dot-namespaced method name, e.g. `"scene.list_objects"`. |
-| `params` | object | Key/value parameters for the method. May be an empty object `{}`. |
-
-If `params` is absent or not an object, the Rhino plugin treats it as `{}`.
-
-### Response — Success (Rhino plugin → MCP server)
-
-```json
-{
-  "id": "550e8400-e29b-41d4-a716-446655440000",
-  "result": {
-    "guid": "a1b2c3d4-...",
-    "bounding_box": {
-      "min": [0.0, 0.0, 0.0],
-      "max": [100.0, 50.0, 30.0]
-    }
-  },
-  "error": null
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `id` | string | Echoed from the request. |
-| `result` | object | The handler's return value. Never absent on success; at minimum `{}`. |
-| `error` | null | Explicitly `null` on success. |
-
-### Response — Error (Rhino plugin → MCP server)
-
-```json
-{
-  "id": "550e8400-e29b-41d4-a716-446655440000",
-  "result": null,
-  "error": {
-    "code": -32601,
-    "message": "Method not found: creation.create_hexagon"
-  }
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `id` | string | Echoed from the request. May be `null` if the request could not be parsed. |
-| `result` | null | Explicitly `null` on error. |
-| `error` | object | Error descriptor with `code` (integer) and `message` (string). |
-
----
-
-## Error Codes
-
-The Rhino plugin uses two sets of error codes:
-
-### JSON-RPC Standard Codes (used by `rhino_plugin/server.py`)
-
-These are returned for transport-level or routing errors before a handler is invoked.
-
-| Code | Meaning |
-|------|---------|
-| `-32601` | Method not found (not in any registry) |
-| `-32603` | Internal server error (unhandled exception in dispatch logic) |
-| `-32000` | Application error from external dispatcher |
-
-### GOLEM Domain Codes (used by `rhino_plugin/dispatcher.py`)
-
-These are returned when a registered handler encounters an application-level problem.
-
-| Code | Meaning |
-|------|---------|
-| `"OK"` | Success (not used in error responses) |
-| `"INVALID_PARAMS"` | Missing, wrong-type, or out-of-range parameter |
-| `"OBJECT_NOT_FOUND"` | GUID not found in the Rhino document |
-| `"OPERATION_FAILED"` | Rhino returned `null` or `false` for a geometry operation |
-| `"TIMEOUT"` | UI thread did not execute the handler within 30 seconds |
-| `"INTERNAL_ERROR"` | Unhandled Python exception in the handler; `details.traceback` is included |
-| `"NOT_FOUND"` | Method name not in the dispatcher registry |
-| `"NOT_IMPLEMENTED"` | Handler raises `NotImplementedError` |
-
-GOLEM domain errors may include an optional `details` field:
-```json
-{
-  "code": "INVALID_PARAMS",
-  "message": "Required parameter 'guids' is missing.",
-  "details": {"method": "operations.boolean_union"}
-}
-```
-
-On the MCP server side, GOLEM domain codes are translated to `RhinoCommandError(code, message)`. The numeric code passed to `RhinoCommandError` is `-32000` for all GOLEM errors (the string code appears in the message).
-
----
-
-## Timeout Behaviour
-
-### Connection timeout
-
-`RhinoConnection.connect()` has a `timeout` parameter (default 10 seconds). If the TCP handshake or the initial `ping` command does not complete within this window, `RhinoConnectionError` is raised.
-
-### Command timeout
-
-`RhinoConnection.send_command()` has a `timeout` parameter (default 30 seconds). This is applied via `socket.settimeout()` on the receive phase. If no response arrives within the timeout, `RhinoTimeoutError` is raised. Timeouts are not retried.
-
-The 30-second default covers even slow Grasshopper recomputes. For long-running scripts (`scripting.execute_python`), pass a larger `timeout` value:
-```python
-conn.send_command("scripting.execute_python", {"code": "..."}, timeout=120)
-```
-
-### UI thread timeout
-
-On the Rhino plugin side, `run_on_ui_thread()` waits up to 30 seconds for the UI thread to execute the handler. If the UI thread is busy (modal dialog open, file import in progress, etc.), the handler returns a `TIMEOUT` error.
-
----
-
-## Ping / Liveness Check
-
-The built-in `ping` method is a liveness check. It is called automatically during `connect()` to verify that the Rhino plugin is alive and responding.
-
-Request:
-```json
-{"id": "any-id", "method": "ping", "params": {}}
-```
-
-Response:
-```json
-{"id": "any-id", "result": {"alive": true}, "error": null}
-```
-
-To perform a manual liveness check from code:
-```python
-conn = get_connection()
-result = conn.send_command("ping", {})
-assert result["alive"] is True
-```
-
----
-
-## Built-in Methods
-
-Three methods are always registered, regardless of which handler modules are loaded:
-
-| Method | Description |
-|--------|-------------|
-| `ping` | Liveness check. Returns `{"alive": true}`. |
-| `shutdown` | Gracefully stop the Rhino plugin server. Returns `{"shutdown": "initiated"}` and then closes the socket. |
-| `list_methods` | Return all registered method names. Returns `{"methods": ["creation.create_box", ...]}`. |
-
----
-
-## Reconnection Logic
-
-The MCP server (`mcp_server/connection.py`) handles transient connection failures automatically:
-
-1. On `BrokenPipeError` or `ConnectionResetError` during `send_command()`, the client calls `reconnect()`.
-2. `reconnect()` closes the socket and calls `connect()` with the same host/port.
-3. This is retried up to `_MAX_AUTO_RECONNECT_ATTEMPTS = 3` times.
-4. If all reconnection attempts fail, `RhinoConnectionError` is raised to the caller.
-
-Rhino application-level errors (`RhinoCommandError`) and timeouts (`RhinoTimeoutError`) are not retried — they indicate a problem with the command itself, not the connection.
-
-The singleton `get_connection()` function detects a disconnected socket via `is_connected()` and creates a fresh `RhinoConnection` if needed. Note that `is_connected()` is a lightweight check (the socket object exists and was not explicitly closed); it does not perform a round-trip. Use `send_command("ping", {})` for a hard liveness check.
-
----
-
-## Grasshopper Sub-Server
-
-The Grasshopper integration uses port 9877 (configurable via `GOLEM_GH_PORT`). The protocol is identical to the main server. The Grasshopper sub-server is an optional component — if it is not running, the `grasshopper.*` tools return `OPERATION_FAILED` errors rather than hanging.
-
----
-
-## Wire Compatibility Notes
-
-- **Byte order:** Big-endian (network byte order) for the 4-byte header. This is consistent across all platforms.
-- **JSON encoding:** UTF-8, `ensure_ascii=False`. Rhino's Python runtime handles UTF-8 correctly.
-- **Null values:** JSON `null` is used explicitly for `error: null` on success and `result: null` on error. Do not omit these fields.
-- **Number types:** JSON does not distinguish int from float. All numbers arrive as Python `float` unless explicitly cast in handler code. Handler parameters are always validated and cast before use.
-- **Large geometry:** The 64 MB payload cap is generous for typical geometry responses. If you need to transfer very large meshes, consider using `files.export_objects` + a local file path instead.