muse-code-sdk 1.3.0__tar.gz → 1.3.1__tar.gz

muse_code_sdk-1.3.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: muse-code-sdk
+Version: 1.3.1
+Summary: Muse Code SDK for MSP: asyncio-first facade over the generated wire types (muse-code-msp), with a thin sync wrapper.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/meta-models/muse-code-sdk
+Project-URL: Repository, https://github.com/meta-models/muse-code-sdk
+Project-URL: Issues, https://github.com/meta-models/muse-code-sdk/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic==2.13.5
+Dynamic: license-file
+
+# `muse-code-sdk`
+
+The Python SDK for Muse Code: an asyncio-first client for driving a Muse
+Code agent over the Muse Session Protocol (MSP), with a thin synchronous
+wrapper for scripts and notebooks.
+
+- Open and resume sessions against a spawned `muse serve` host, or attach to
+  one you already run.
+- Stream a turn's items and text deltas as async iterators; await the turn's
+  server-authored outcome.
+- Answer tool-approval requests with a handler you register.
+- A client-side fold keeps a live, typed view of the session — items, session
+  state, pending commands — with gap recovery after reconnects, and safe
+  same-command retry that can never double-submit.
+- `SyncMuseClient` mirrors the same surface with blocking verbs.
+
+Status: developer preview. Experimental protocol surfaces may change.
+
+The generated MSP wire types live in the companion package
+[`muse-code-msp`](https://pypi.org/project/muse-code-msp/) and are never
+restated here. One runtime dependency: `pydantic`, exact-pinned.
+Python 3.10+. Fully typed (`py.typed`).
+
+## Install
+
+```sh
+pip install muse-code-sdk muse-code-msp
+```
+
+You also need the Muse Code CLI: a `muse` binary on `PATH`, or an explicit
+path passed at spawn time.
+
+## Use
+
+```python
+import asyncio
+
+from muse_code import (
+    MuseClient, MuseClientSpawnOptions, SendUserTurnOptions, StartSessionOptions,
+)
+
+async def main() -> None:
+    client = await MuseClient.spawn(MuseClientSpawnOptions(
+        muse_bin="muse",
+        args=["serve"],
+        client_info={"name": "my-app", "version": "1.0.0"},
+    ))
+    session = await client.start_session(StartSessionOptions(workspace_root="."))
+    turn = await session.send_user_turn(SendUserTurnOptions(
+        input=[{"type": "text", "text": "Summarize this repository."}],
+        composer_input="Summarize this repository.",
+    ))
+    async for item in turn.items():
+        print(item)
+    await turn.completed
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Documentation
+
+- Guides, cookbook recipes, and the protocol reference:
+  <https://meta-models.github.io/muse-code-sdk/>
+- Python API reference:
+  <https://meta-models.github.io/muse-code-sdk/next/generated/python/>
+- Source and issues: <https://github.com/meta-models/muse-code-sdk>

muse_code_sdk-1.3.1/README.md

@@ -0,0 +1,67 @@
+# `muse-code-sdk`
+
+The Python SDK for Muse Code: an asyncio-first client for driving a Muse
+Code agent over the Muse Session Protocol (MSP), with a thin synchronous
+wrapper for scripts and notebooks.
+
+- Open and resume sessions against a spawned `muse serve` host, or attach to
+  one you already run.
+- Stream a turn's items and text deltas as async iterators; await the turn's
+  server-authored outcome.
+- Answer tool-approval requests with a handler you register.
+- A client-side fold keeps a live, typed view of the session — items, session
+  state, pending commands — with gap recovery after reconnects, and safe
+  same-command retry that can never double-submit.
+- `SyncMuseClient` mirrors the same surface with blocking verbs.
+
+Status: developer preview. Experimental protocol surfaces may change.
+
+The generated MSP wire types live in the companion package
+[`muse-code-msp`](https://pypi.org/project/muse-code-msp/) and are never
+restated here. One runtime dependency: `pydantic`, exact-pinned.
+Python 3.10+. Fully typed (`py.typed`).
+
+## Install
+
+```sh
+pip install muse-code-sdk muse-code-msp
+```
+
+You also need the Muse Code CLI: a `muse` binary on `PATH`, or an explicit
+path passed at spawn time.
+
+## Use
+
+```python
+import asyncio
+
+from muse_code import (
+    MuseClient, MuseClientSpawnOptions, SendUserTurnOptions, StartSessionOptions,
+)
+
+async def main() -> None:
+    client = await MuseClient.spawn(MuseClientSpawnOptions(
+        muse_bin="muse",
+        args=["serve"],
+        client_info={"name": "my-app", "version": "1.0.0"},
+    ))
+    session = await client.start_session(StartSessionOptions(workspace_root="."))
+    turn = await session.send_user_turn(SendUserTurnOptions(
+        input=[{"type": "text", "text": "Summarize this repository."}],
+        composer_input="Summarize this repository.",
+    ))
+    async for item in turn.items():
+        print(item)
+    await turn.completed
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Documentation
+
+- Guides, cookbook recipes, and the protocol reference:
+  <https://meta-models.github.io/muse-code-sdk/>
+- Python API reference:
+  <https://meta-models.github.io/muse-code-sdk/next/generated/python/>
+- Source and issues: <https://github.com/meta-models/muse-code-sdk>

{muse_code_sdk-1.3.0 → muse_code_sdk-1.3.1}/pyproject.toml

@@ -5,23 +5,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "muse-code-sdk"
-version = "1.3.0"
+version = "1.3.1"
 description = "Muse Code SDK for MSP: asyncio-first facade over the generated wire types (muse-code-msp), with a thin sync wrapper."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
-# Exactly ONE runtime dependency, exact-pinned: the ADR 638 D2 supply-chain
-# exception (#211 O-3 form). Any second dependency is an owner escalation;
-# bumps are deliberate reviewed PRs (see the ADR's review policy).
+# Exactly ONE runtime dependency, exact-pinned: a deliberate, ruled
+# supply-chain exception. Any second dependency is an owner escalation;
+# bumps are deliberate reviewed PRs.
 # muse-code-msp is deliberately NOT declared: it is not on the registry yet,
 # and promoting it is the owner escalation decided with the first publish
 # (the @muse-code/msp devDependency precedent; test_publish_shape pins this).
 dependencies = ["pydantic==2.13.5"]
 classifiers = [
-    # Alpha states the withheld promise: D-065 (ADR 29534 D1) permits the
-    # publish, but D-013's stability promise and conformance claim stay
-    # withheld — experimental surfaces may change (ADR 25304 D3).
+    # Alpha states the withheld promise: publication is permitted, but the
+    # stability promise and conformance claim stay withheld — experimental
+    # surfaces may change.
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
@@ -30,7 +30,7 @@ classifiers = [
 ]
 
 [project.urls]
-# The mirror is the one public venue (ADR 638 D6); a published manifest never
+# The mirror is the one public venue; a published manifest never
 # names the private producer repository.
 Homepage = "https://github.com/meta-models/muse-code-sdk"
 Repository = "https://github.com/meta-models/muse-code-sdk"

{muse_code_sdk-1.3.0 → muse_code_sdk-1.3.1}/src/muse_code/__init__.py

@@ -1,18 +1,18 @@
 """Muse Code SDK for MSP: the asyncio-first Python facade.
 
-Owning spec: ``specs/638-muse-sdk-python`` (governing ADR
-``docs/adr/638-muse-sdk-python.md``). Wire shapes are imported from the
-generated ``muse_code_msp`` package, never restated here (INV-638-01/02).
+Wire shapes are imported from the generated ``muse_code_msp`` package,
+never restated here.
 
-S1 (the transport-less core) is in: the SS4 fold (``muse_code.fold``), the
-SS4.13 pending set (``muse_code.pending``), the transcript replay runner
+The transport-less core: the client fold (``muse_code.fold``), the pending
+command set (``muse_code.pending``), the transcript replay runner
 (``muse_code.replay``), and the typed error family (``muse_code.errors``).
-S2 is in: the NDJSON connection machine, the owned-process spawn path, host
-discovery, and the strict fingerprint gate (``muse_code.connection``). S3 is in:
-the asyncio facade (``muse_code.facade`` — ``MuseClient``, ``Session``,
-``Turn``) with the host-death discharge, the approval/user-input round trip,
-the SS4.8 gap splice-fill, and the sync loop-runner wrapper
-(``muse_code.sync_facade`` — ``SyncMuseClient``).
+The connection plane: the NDJSON connection machine, the owned-process spawn
+path, host discovery, and the strict fingerprint gate
+(``muse_code.connection``). The surface: the asyncio facade
+(``muse_code.facade`` — ``MuseClient``, ``Session``, ``Turn``) with the
+host-death discharge, the approval/user-input round trip, the gap
+splice-fill, and the sync loop-runner wrapper (``muse_code.sync_facade`` —
+``SyncMuseClient``).
 """
 
 from __future__ import annotations
@@ -77,20 +77,19 @@ __all__ = [
 ]
 
 EXPECTED_SCHEMA_FINGERPRINT: Final[str] = (
-    "sha256:ab69549a7ebb423fce94068762da0b5ff3cdec1f8fc263dcc17248eda117f852"
+    "sha256:b1e6676d624e116e2c1b150fec3192200d2cbca8ed79898e44f8921759c7872f"
 )
 """The stable schema-bundle fingerprint this SDK was built against.
 
-The one deliberately duplicated fact (spec 638 FR-638-006, the 14990 FR-006
-pattern): ``clients/sdk-py/tests/test_manifests.py`` binds it to
+The one deliberately duplicated fact: ``clients/sdk-py/tests/test_manifests.py`` binds it to
 ``schema/msp/stable/manifest.json``, so a schema advance that forgets the
 Python SDK reds this lane instead of drifting silently.
 """
 
-# D-063 lockstep (ADR 25304 D4): the release train bumps pyproject.toml, the
+# The lockstep rule: the release train bumps pyproject.toml, the
 # distribution-metadata authority; this constant is aligned at publication
-# time (the publish itself is owner-run, permitted by D-065, ADR 29534 D1).
-__version__: Final[str] = "1.3.0"
+# time.
+__version__: Final[str] = "1.3.1"
 
 # The facade is imported last so the constants above are already bound: the
 # spawn path reads ``EXPECTED_SCHEMA_FINGERPRINT`` (lazily, at initialize

{muse_code_sdk-1.3.0 → muse_code_sdk-1.3.1}/src/muse_code/connection/__init__.py

@@ -1,5 +1,5 @@
-"""The MSP connection plane (spec 638 FR-638-011..018): the transport-less
-NDJSON connection machine, the owned-process spawn path, and host discovery.
+"""The MSP connection plane: the transport-less NDJSON connection machine,
+the owned-process spawn path, and host discovery.
 """
 
 from __future__ import annotations

{muse_code_sdk-1.3.0 → muse_code_sdk-1.3.1}/src/muse_code/connection/connection.py

@@ -1,11 +1,10 @@
-"""Duplex-agnostic MSP NDJSON connection (spec 638 FR-638-011..015).
+"""Duplex-agnostic MSP NDJSON connection.
 
-Faithful asyncio port of ``clients/sdk-ts/src/connection/connection.ts``
-(spec 14990 FR-012/014/015/016). The transport supplies decoded UTF-8 text
-chunks; chunks may be empty and may split anywhere — Python strings are
-whole code points, so the TS surrogate-pair byte reconciliation has no twin
-here (spec 638 Edge Cases): the running byte count is exact by construction
-and stays O(bytes) per chunk.
+Faithful asyncio port of the TypeScript SDK's connection module. The
+transport supplies decoded UTF-8 text chunks; chunks may be empty and may
+split anywhere — Python strings are whole code points, so the TS
+surrogate-pair byte reconciliation has no twin here: the running byte count
+is exact by construction and stays O(bytes) per chunk.
 
 One deliberate adaptation, noted per the port rules: in TS "invoking
 ``write()`` IS submission" because the transport's synchronous prefix runs
@@ -74,7 +73,7 @@ RetryDelay = Callable[[int, "MspError"], Awaitable[None]]
 
 
 class MspError(Exception):
-    """The one typed error family consumers branch on (INV-012).
+    """The one typed error family consumers branch on.
 
     Attributes:
         code: The JSON-RPC error code.
@@ -104,7 +103,7 @@ class ProtocolError(Exception):
 
     Attributes:
         line: The offending inbound line, preserved as evidence and bounded
-            in UTF-8 bytes (FM-007), when one exists.
+            in UTF-8 bytes, when one exists.
     """
 
     def __init__(self, message: str, line: str | None = None) -> None:
@@ -122,7 +121,7 @@ class _UnencodableFrameError(ProtocolError):
 
     A caller defect, never transport death: it rejects only that frame's
     outcome, so ``notify()``'s finish-on-write-failure rule must not treat
-    it as the pipe dying (PR #30094 review).
+    it as the pipe dying.
     """
 
 
@@ -147,12 +146,11 @@ def _utf8_len(text: str) -> int:
 
 
 def _truncate_to_utf8_bytes(text: str, limit_bytes: int) -> str:
-    """FM-007: error evidence is bounded in UTF-8 BYTES, never characters.
+    """The evidence bound: error evidence is measured in UTF-8 BYTES, never characters.
 
     Encode once and back the cut up over continuation bytes (the
     ``StderrTail._trim_bytes`` pattern): a per-scalar walk re-encoded every
-    character and blocked the event loop for seconds at the frame limit
-    (PR #30094 review).
+    character and blocked the event loop for seconds at the frame limit.
     """
     data = text.encode("utf-8", "surrogatepass")
     if len(data) <= limit_bytes:
@@ -179,7 +177,7 @@ def _canonical(value: Any) -> str:
 
 
 def create_uuid_v7_mint() -> Callable[[], str]:
-    """Creates the SDK-owned UUIDv7 command-id source (INV-013).
+    """Creates the SDK-owned UUIDv7 command-id source.
 
     Returns:
         A zero-argument callable minting RFC 9562 v7-shaped ids, strictly
@@ -216,7 +214,7 @@ def create_uuid_v7_mint() -> Callable[[], str]:
 
 
 async def _default_retry_delay(attempt: int, _error: MspError) -> None:
-    """FM-006's full-jitter budget: uniform in 0..ceiling, 50 ms doubling, 2 s cap."""
+    """The retry backoff's full-jitter budget: uniform in 0..ceiling, 50 ms doubling, 2 s cap."""
     ceiling_ms = min(2_000, 50 * 2 ** max(0, attempt - 1))
     await asyncio.sleep(secrets.randbelow(ceiling_ms + 1) / 1000)
 
@@ -272,9 +270,8 @@ class Connection:
 
         Args:
             transport: The duplex text channel.
-            frame_limit_bytes: Inbound frame-size sanity bound (SS1.1
-                default when omitted).
-            mint_command_id: Injectable command-id source (INV-013);
+            frame_limit_bytes: Inbound frame-size sanity bound.
+            mint_command_id: Injectable command-id source;
                 defaults to the UUIDv7 mint.
             mint_request_id: Injectable for deterministic transcript
                 clients; values must be unique in flight.
@@ -313,15 +310,14 @@ class Connection:
 
         A fresh shield per access: a consumer's ``wait_for`` timeout must
         cancel only its own wait, never the connection's one real future —
-        a cancelled ``_closed`` would break ``close()`` for everyone
-        (PR #30094 review; a TS Promise cannot be cancelled).
+        a cancelled ``_closed`` would break ``close()`` for everyone.
         """
         return asyncio.shield(self._closed)
 
     def _submission_tail(self) -> asyncio.Future[None]:
         """The friend seam a process-owning transport adopts as ``flushed``.
 
-        Module-private, like the TS twin's Symbol fence (PR #30094 review):
+        Module-private, like the TS twin's Symbol fence:
         it lets a close routed around this class — the public
         ``child.close()`` — wait for accepted frames' SUBMISSION the same
         way :meth:`close` does.
@@ -332,8 +328,8 @@ class Connection:
         """Takes one id from THIS connection's single command-id minter.
 
         Exposed for callers that need the id BEFORE the ack: the facade's
-        ``send_user_turn`` records its optimistic SS4.13 entry under it. A
-        second facade-side minter is exactly what INV-013 forbids. Pair with
+        ``send_user_turn`` records its optimistic pending entry under it. A
+        second facade-side minter is exactly what the single-minter rule forbids. Pair with
         ``command(..., command_id=...)``, which reuses the id.
 
         Returns:
@@ -344,7 +340,7 @@ class Connection:
     def request(
         self, method: str, params: Params | None = None
     ) -> asyncio.Future[Params]:
-        """Sends one request and correlates its response (SS1.3).
+        """Sends one request and correlates its response.
 
         Args:
             method: The MSP method name.
@@ -352,7 +348,7 @@ class Connection:
 
         Returns:
             A future resolving with the result object, or rejecting with an
-            :class:`MspError` (typed, INV-012) or :class:`ProtocolError`.
+            :class:`MspError` or :class:`ProtocolError`.
         """
         outcome: asyncio.Future[Params] = self._loop.create_future()
         if self._finished:
@@ -393,7 +389,7 @@ class Connection:
         value, a lone surrogate) is the caller's defect, detected before
         anything reaches the transport — it raises :class:`ProtocolError`
         synchronously instead of being dropped or finishing a healthy
-        connection (spec 638 FM-638-7).
+        connection.
 
         Raises:
             ProtocolError: The frame is not JSON/UTF-8 encodable.
@@ -441,9 +437,9 @@ class Connection:
         max_attempts: int | None = None,
         retry_delay: RetryDelay | None = None,
     ) -> asyncio.Future[Params]:
-        """Sends one logical command with the INV-013 ``commandId`` contract.
+        """Sends one logical command with the same-``commandId`` retry contract.
 
-        Same-id retries on the FM-006 retryable pair (``backpressured`` /
+        Same-id retries on the retryable pair (``backpressured`` /
         ``overloaded``) with the bounded full-jitter budget; a value-identical
         ack settles a replay; ``inputTooLarge`` (and every other error) is
         never auto-retried.
@@ -460,13 +456,12 @@ class Connection:
             A future for the ack object (eager: the first attempt is in
             flight when this returns) — or one already rejected, with NO
             attempt in flight, when the params are not JSON-serializable
-            (:class:`ProtocolError`, FM-638-7 — the same settle-on-the-future
-            posture as :meth:`request`) or the ``commandId`` is reused with a
+             or the ``commandId`` is reused with a
             different payload.
         """
         # The prelude and the FIRST attempt run synchronously so the frame
         # joins the submit tail NOW: a command() immediately followed by
-        # close() must still write it (PR #30094 review — a deferred task
+        # close() must still write it (a prior review — a deferred task
         # enqueued nothing until the loop's next yield, silently dropping
         # the frame; request()/notify() already enqueue synchronously).
         cid = command_id if command_id is not None else self._mint_command_id()
@@ -475,11 +470,11 @@ class Connection:
             signature = _canonical({"method": method, "params": command_params})
         except (TypeError, ValueError):
             # A param json.dumps cannot serialize is the caller's defect
-            # (FM-638-7), surfaced on the future this method promises — never
+            #, surfaced on the future this method promises — never
             # a raw synchronous TypeError. request() with the same params
             # rejects through _enqueue_write; the two surfaces must agree.
             # Nothing is stranded: no _commands entry, no request in flight
-            # (PR #30094 review, round 18).
+            #.
             rejected: asyncio.Future[Params] = self._loop.create_future()
             rejected.set_exception(
                 _UnencodableFrameError("outbound frame is not JSON/UTF-8 encodable")
@@ -519,7 +514,7 @@ class Connection:
                 ack = await pending
                 # session/start and session/resume results omit the redundant
                 # commandId echo (contracts/sdk-surface.md); one that carries
-                # it must echo exactly (TEST-018).
+                # it must echo exactly.
                 if "commandId" in ack and ack["commandId"] != cid:
                     raise ProtocolError(
                         f"{method} ack commandId {ack['commandId']} did not echo {cid}"
@@ -547,7 +542,7 @@ class Connection:
         """Closes the connection without gating teardown on the peer.
 
         COMPLETION must not gate teardown — a peer that stopped reading
-        never completes a write (#15943). SUBMISSION must: the submission
+        never completes a write. SUBMISSION must: the submission
         tail goes TO the transport's optional ``close``, which waits for it
         inside its own shutdown budget; this class knows nothing about
         processes, signals, or timeouts. A close-less transport supplies no
@@ -575,7 +570,7 @@ class Connection:
             # allow_nan=False so a NaN/Infinity float raises ValueError here
             # rather than emitting a bare `NaN`/`Infinity` token — invalid
             # JSON the Rust host cannot parse, which would leave the caller's
-            # request hanging until EOF (FR-638-013; the TS twin coerces to
+            # request hanging until EOF (the governing rule; the TS twin coerces to
             # null). It joins the caller-defect settle below.
             line = json.dumps(
                 frame, separators=(",", ":"), ensure_ascii=False, allow_nan=False
@@ -588,7 +583,7 @@ class Connection:
             # reject just this frame and leave the connection (and every
             # sibling in flight) alive. Detected here, the one outbound
             # boundary, so all three writers — request(), notify(), and the
-            # server-request reply — get it (PR #30094 review; the TS twin
+            # server-request reply — get it (a prior review; the TS twin
             # survives the same input).
             outcome.set_exception(
                 _UnencodableFrameError("outbound frame is not JSON/UTF-8 encodable")
@@ -655,7 +650,7 @@ class Connection:
             return
         self._segments.append(remaining)
         self._buffer_bytes += _utf8_len(remaining)
-        # FR-638-011: the retained buffer is newline-free on entry (the drain
+        # The rule: the retained buffer is newline-free on entry (the drain
         # below runs to exhaustion), so only the fresh chunk can carry a
         # newline — ingest stays O(bytes), never a full-buffer rescan.
         if "\n" in remaining:
@@ -722,7 +717,7 @@ class Connection:
                     # A Ctrl-C that cancels the run cancels this handler task;
                     # `Future.exception()` would then raise CancelledError back
                     # into the callback and log a spurious traceback in the
-                    # consumer's shutdown (PR #30094 review).
+                    # consumer's shutdown.
                     if done.cancelled():
                         return
                     error = done.exception()
@@ -749,9 +744,9 @@ class Connection:
         if pending.future.done():
             # The caller cancelled its await (or an asyncio.wait_for timed
             # out): the request is abandoned, not unknown — the late reply is
-            # dropped and the CONNECTION stays healthy (spec 638 Edge Cases:
+            # dropped and the CONNECTION stays healthy (the owning spec Edge Cases:
             # cancellation is a consumer-side act and must not corrupt the
-            # connection; PR #30094 review, thread 2 — settling a done future
+            # connection; a prior review — settling a done future
             # raised InvalidStateError inside the read loop and tore
             # everything down).
             del self._pending[_request_key(frame_id)]
@@ -759,8 +754,8 @@ class Connection:
         has_result = "result" in frame
         has_error = "error" in frame
         if has_result == has_error:
-            # FR-638-013: the MATCHED caller must settle — with no local
-            # timeout (INV-006) an unrejected caller would hang until EOF.
+            # The rule: the MATCHED caller must settle — with no local
+            # timeout an unrejected caller would hang until EOF.
             violation = ProtocolError(
                 "response must carry exactly one of result or error", line
             )
@@ -809,7 +804,7 @@ class Connection:
                     }
                 )
             result = await self._server_request_handler(request)
-            # FM-009: a failed reply write finishes the connection; it must
+            # The rule: a failed reply write finishes the connection; it must
             # not escape this fire-and-forget task as an unhandled exception.
             reply = self._enqueue_write(
                 {"jsonrpc": "2.0", "id": request_id, "result": result}
@@ -845,10 +840,9 @@ class Connection:
         )
         reply.add_done_callback(
             lambda done: self._reply_done(request_id, done)
-        )  # FM-009
-
+        )
     def _reply_done(self, request_id: object, done: asyncio.Future[None]) -> None:
-        """FM-638-7 for reply writes, minus the caller-defect arm.
+        """The reply-write rule, minus the caller-defect arm.
 
         A reply frame that cannot serialize/encode (a handler returned or
         raised a non-JSON value — a set, a lone surrogate) is the HANDLER's
@@ -857,7 +851,7 @@ class Connection:
         connection (the third writer after request()/notify()). The fallback
         frame cannot re-enter this arm because ``_line`` admits a server
         request only with a positive-INTEGER id, so ``request_id`` is always
-        an int and the fallback is ASCII by construction (spec 638 FM-638-7).
+        an int and the fallback is ASCII by construction.
         """
         error = done.exception()
         if error is None:

{muse_code_sdk-1.3.0 → muse_code_sdk-1.3.1}/src/muse_code/connection/discovery.py

@@ -1,13 +1,13 @@
-"""Host discovery for the UNBUNDLED wheel (spec 638 FR-638-020, INV-638-08).
-
-The wheel carries no host binary and no code path assumes one (#29216 fence).
-Exactly the two ruled tiers, first hit wins: an explicit ``muse_bin``
-argument, then a ``muse`` on ``PATH``. The LIBRARY reads no environment
-variable (TS parity: ``spawn.ts`` takes a required command; ``MUSE_BIN`` is
-a knob of the quickstart/cookbook HARNESSES, which read it themselves and
-pass the explicit parameter down — PR #29277 review, thread 6). No
-discoverable host fails BEFORE any process is spawned, with an exact error
-naming the parameter and the compatibility page.
+"""Host discovery for the UNBUNDLED wheel.
+
+The wheel carries no host binary and no code path assumes one. Exactly the
+two ruled tiers, first hit wins: an explicit ``muse_bin`` argument, then a
+``muse`` on ``PATH``. The LIBRARY reads no environment variable (TS parity:
+the TS spawn module takes a required command; ``MUSE_BIN`` is a knob of the
+quickstart/cookbook HARNESSES, which read it themselves and pass the
+explicit parameter down). No discoverable host fails BEFORE any process is
+spawned, with an exact error naming the parameter and the compatibility
+page.
 """
 
 from __future__ import annotations
@@ -21,13 +21,13 @@ HOST_BINARY_NAME = "muse"
 
 
 def discover_muse_bin(muse_bin: str | None = None) -> str:
-    """Resolves the MSP host binary to spawn (spec 638 FR-638-020).
+    """Resolves the MSP host binary to spawn.
 
-    Exactly two ruled inputs (FR-638-020 / INV-638-08): an explicit
+    Exactly two ruled inputs: an explicit
     ``muse_bin``, else the process ``PATH``. There is deliberately no ``env``
     knob — no production caller passes one, the TS twin has none, and a
     harness wanting hermetic discovery exports ``PATH`` itself; a future S3
-    consumer that needs the child's own env adds it there (PR #30094 review).
+    consumer that needs the child's own env adds it there.
 
     Args:
         muse_bin: An explicit host path; when given it wins outright and is