muse-code-sdk 1.4.4__tar.gz → 1.4.7__tar.gz

{muse_code_sdk-1.4.4/src/muse_code_sdk.egg-info → muse_code_sdk-1.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.4
+Version: 1.4.7
 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

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "muse-code-sdk"
-version = "1.4.4"
+version = "1.4.7"
 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"

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/src/muse_code/__init__.py

@@ -24,6 +24,7 @@ from .errors import (
     MuseForeignSessionError,
     MuseGapFillError,
     MuseSessionDiscardedError,
+    PermissionProfileNotApplied,
 )
 from .fold import ItemStore, SessionFold, SessionStateStore
 from .pending import PendingCommandSet
@@ -51,6 +52,7 @@ __all__ = [
     "MuseSessionDiscardedError",
     "PendingCommandSet",
     "PendingCommandView",
+    "PermissionProfileNotApplied",
     "ResumeSessionOptions",
     "SendUserTurnOptions",
     "Session",
@@ -78,7 +80,7 @@ __all__ = [
 ]
 
 EXPECTED_SCHEMA_FINGERPRINT: Final[str] = (
-    "sha256:7c94f153c41659cb3f1bd3c3e04438be254644cb2a97d65d48edc7449b74858a"
+    "sha256:6de32db08bbbe0deb478d2bfcaba001e9fb490986bc80db3aceb4d996abf7df9"
 )
 """The stable schema-bundle fingerprint this SDK was built against.
 
@@ -90,7 +92,7 @@ Python SDK reds this lane instead of drifting silently.
 # The lockstep rule: the release train bumps pyproject.toml, the
 # distribution-metadata authority; this constant is aligned at publication
 # time.
-__version__: Final[str] = "1.4.4"
+__version__: Final[str] = "1.4.7"
 
 # 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.4.4 → muse_code_sdk-1.4.7}/src/muse_code/connection/spawn.py

@@ -39,6 +39,13 @@ from .validation import parse_initialize_result, parse_spawn_options
 if TYPE_CHECKING:
     from muse_code_msp import InitializeParams, InitializeResult, RequestId
 
+_CREATE_NO_WINDOW = 0x0800_0000
+"""Win32 ``CREATE_NO_WINDOW`` process-creation flag (``subprocess`` defines it
+only on Windows builds). A spawned ``muse serve`` is never meant to be seen,
+so on Windows the SDK starts it without a console window: a windowless host
+(a GUI app, a service) would otherwise get a stray console on every spawn."""
+
+
 DEFAULT_STDERR_MAX_BYTES = 8 * 1024
 DEFAULT_STDERR_MAX_LINES = 100
 DEFAULT_SHUTDOWN_TIMEOUT_MS = 30_000
@@ -817,6 +824,9 @@ class MuseServeChild:
             env=env,
             shutdown_timeout_ms=shutdown_timeout_ms,
         )
+        # POSIX: the child leads its own process group so the close ladder can
+        # signal the group. Windows: no process group, and no console window
+        # (CPython accepts ``creationflags=0`` on POSIX).
         owns_process_group = sys.platform != "win32"
         child = await asyncio.create_subprocess_exec(
             options.command,
@@ -827,6 +837,7 @@ class MuseServeChild:
             cwd=options.cwd,
             env=options.env,
             start_new_session=owns_process_group,
+            creationflags=0 if owns_process_group else _CREATE_NO_WINDOW,
         )
         return MuseServeChild(
             child,

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/src/muse_code/errors.py

@@ -82,6 +82,39 @@ class MuseGapFillError(Exception):
             self.__cause__ = cause
 
 
+class PermissionProfileNotApplied(Exception):
+    """A required session-start permission-profile selection the client could
+    not prove applied: the start result carried no ``permissionState``, and
+    the ``session/read`` read-back served a different profile — or none at
+    all. Never a silent default: the session stays open and the caller
+    decides (set/retry or close) via ``session_id``, with no auto-close and
+    no auto-set.
+
+    Attributes:
+        requested: The profile id the caller required.
+        served: The committed profile id the read-back served, or None when
+            unknown.
+        session_id: The open session, so the caller can set, retry, or close it.
+    """
+
+    def __init__(self, requested: str, served: str | None, session_id: str) -> None:
+        """Builds the refusal.
+
+        Args:
+            requested: The profile id the caller required.
+            served: The committed profile id served, or None when unknown.
+            session_id: The open session's id.
+        """
+        served_text = "unknown" if served is None else repr(served)
+        super().__init__(
+            f"required permissionProfile {requested!r} was not applied:"
+            f" the committed selection is {served_text} (session {session_id})"
+        )
+        self.requested: str = requested
+        self.served: str | None = served
+        self.session_id: str = session_id
+
+
 ValidationSeam = Literal["initializeResult", "spawnOptions"]
 """Which validating pydantic seam refused its input.
 

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/src/muse_code/facade/client.py

@@ -53,7 +53,7 @@ from ..connection.spawn import (
     SpawnedMspConnection,
     spawn_msp_connection,
 )
-from ..errors import MuseSessionDiscardedError
+from ..errors import MuseSessionDiscardedError, PermissionProfileNotApplied
 from .discarded import DiscardedSessions
 from .host_start import MuseHostStartError, keeps_its_own_error
 from .host_death import (
@@ -93,6 +93,18 @@ class StartSessionOptions:
             ``workspace_root`` is also given the two must agree.
         model_id: The model to serve the session with; omitted = the
             provider's default.
+        permission_profile: The permission profile to start the session
+            under (wire ``permissionProfile``): a profile id the host offers;
+            omitted = the host's configured default. An id the host does not
+            offer refuses the start before the session exists.
+        require_permission_profile: Require the ``permission_profile``
+            selection: when true, the client proves the
+            committed selection equals the requested id — from the start
+            result's ``session.permissionState``, else a ``session/read``
+            read-back — and raises ``PermissionProfileNotApplied`` instead
+            of proceeding on the host default. Client-local: never sent on
+            the wire. Setting it without ``permission_profile`` is a usage
+            error.
     """
 
     approval_mode: str | None = None
@@ -101,6 +113,8 @@ class StartSessionOptions:
     workspace_root: str | None = None
     workspace_roots: List[str] | None = None
     model_id: str | None = None
+    permission_profile: str | None = None
+    require_permission_profile: bool = False
 
 
 @dataclass
@@ -127,12 +141,18 @@ class ResumeSessionOptions:
 # Drift pins — the Python twin of the TS `AssertNever` on START_FORWARDED /
 # RESUME_FORWARDED (client.ts). A schema regen that adds a member to the
 # generated params but not to the options dataclass reds THIS import (and thus
-# every test), so a regenerated member cannot silently fail to reach the wire
-#. The excluded members are the ones the facade owns rather than
-# forwards: `commandId` (the connection is the single minter) and `config`
-# (temporarily withheld until capability-checked forwarding lands).
+# every test), so a regenerated member cannot silently fail to reach the wire.
+# The excluded members are the ones the facade owns rather than forwards:
+# `commandId` (the connection is the single minter) and `config`
+# (temporarily withheld until capability-checked forwarding lands). The owned
+# members are options-only posture the wire never carries (client-local
+# `requirePermissionProfile`, the required-selection check): subtracted from
+# the options side, so a regen that adds a same-named wire member reds here.
 _START_EXCLUDED = {"commandId", "config"}
-assert {_camel(f.name) for f in fields(StartSessionOptions)} | _START_EXCLUDED == set(
+_START_OWNED = {"requirePermissionProfile"}
+assert (
+    {_camel(f.name) for f in fields(StartSessionOptions)} - _START_OWNED
+) | _START_EXCLUDED == set(
     SessionStartParams.__annotations__
 ), "StartSessionOptions drifted from SessionStartParams — forward the new member"
 
@@ -142,6 +162,21 @@ assert {_camel(f.name) for f in fields(ResumeSessionOptions)} | _RESUME_EXCLUDED
 ), "ResumeSessionOptions drifted from SessionResumeParams — forward the new member"
 
 
+def _committed_profile_id(snapshot: Any) -> str | None:
+    """The committed profile id a session snapshot claims, or None when the
+    snapshot is silent (the stable bundle strips the member; absent and null
+    both mean unknown, never applied). Structural on purpose: an unknown wire
+    shape reads as unknown rather than raising.
+    """
+    if not isinstance(snapshot, Mapping):
+        return None
+    state = snapshot.get("permissionState")
+    if not isinstance(state, Mapping):
+        return None
+    profile_id = state.get("profileId")
+    return profile_id if isinstance(profile_id, str) else None
+
+
 @dataclass
 class MuseClientOptions:
     """Options for building a ``MuseClient`` around a connection you own.
@@ -377,10 +412,61 @@ class MuseClient(Generic[_I]):
             params["workspaceRoots"] = options.workspace_roots
         if options.model_id is not None:
             params["modelId"] = options.model_id
+        # The initial permission-profile selection, forwarded verbatim like the
+        # other start members (None stays omitted).
+        if options.permission_profile is not None:
+            params["permissionProfile"] = options.permission_profile
+        # Required selection: a caller that requires its selection proves it,
+        # never assuming the host default. The flag without the member is a
+        # usage error, raised pre-wire.
+        required = options.require_permission_profile is True
+        if required and options.permission_profile is None:
+            raise ValueError(
+                "require_permission_profile needs permission_profile:"
+                " require the selection you pass"
+            )
         # Keyed by the id the SERVER named, never the one the caller asked for:
         # ``sessionId`` is a REQUEST on start, and a session keyed by a hopeful
         # id would reject every one of its own events as foreign.
-        return await self._open("session/start", params, _StartOpening)
+        session = await self._open("session/start", params, _StartOpening)
+        if not required:
+            return session
+        assert options.permission_profile is not None  # the usage guard above
+        return await self._prove_selection(session, options.permission_profile)
+
+    async def _prove_selection(
+        self, session: Session[_I], requested: str
+    ) -> Session[_I]:
+        """Prove a required start selection: the start result's own
+        ``session.permissionState`` first (absent = unknown,
+        never applied); else a point-in-time ``session/read``, which never
+        subscribes. Only ``profileId == requested`` proceeds; anything else
+        raises ``PermissionProfileNotApplied`` BEFORE any turn is sent. The
+        refused session is dropped from the client (no orphan keeps folding
+        for an id the caller can never reach — the SDK has no set/close-by-id
+        verb); the error's ``session_id`` is the caller's handle to resume via
+        ``session_id`` or start again. A failed read-back propagates: the
+        client still never proceeds on the default.
+        """
+        opening = session.opening
+        started = (
+            _committed_profile_id(opening.result["session"])
+            if isinstance(opening, _StartOpening)
+            else None
+        )
+        if started is not None:
+            if started == requested:
+                return session
+            self._sessions.discard(session)
+            raise PermissionProfileNotApplied(requested, started, session.session_id)
+        read = await self._connection.command(
+            "session/read", {"sessionId": session.session_id}
+        )
+        served = _committed_profile_id(read.get("session"))
+        if served == requested:
+            return session
+        self._sessions.discard(session)
+        raise PermissionProfileNotApplied(requested, served, session.session_id)
 
     async def resume_session(self, options: ResumeSessionOptions) -> Session[_I]:
         """Load an existing session and subscribe this connection to its view.

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/src/muse_code/facade/turn_submit.py

@@ -20,6 +20,7 @@ from muse_code_msp import (
     TurnInputPart,
     TurnStartParams,
     TurnStartResult,
+    TurnUserShell,
 )
 
 from ..connection.connection import Connection, MspError, Params
@@ -54,6 +55,8 @@ class SendUserTurnOptions(Generic[_I]):
         workspace_roots: A sticky replacement of the session's runtime
             workspace-root set for this turn and subsequent turns (wire
             ``workspaceRoots``).
+        user_shell: The queued ``!`` shell action this turn carries (wire
+            ``userShell``).
         composer_input: What to hand back to the composer if this submit is
             ever retired — the protocol restores the INPUT, not the wire parts.
             Optional: a consumer rendering nothing optimistically has nothing
@@ -67,6 +70,8 @@ class SendUserTurnOptions(Generic[_I]):
     # No token_budget: the member is experimental-gated (v1 membership
     # unruled), and this SDK serves the stable surface only.
     workspace_roots: List[str] | None = None
+    # v1 stable member, forwarded like any other.
+    user_shell: TurnUserShell | None = None
     composer_input: _I | None = None
 
 
@@ -88,7 +93,7 @@ def _camel(field_name: str) -> str:
 # own field, never a wire member, so it is dropped
 # before the compare; `commandId`/`sessionId` are excluded because the
 # connection mints the first and the session owns the second.
-_TURN_WIRE_FIELDS = {"input", "display_text", "if_busy", "reasoning_effort", "workspace_roots"}
+_TURN_WIRE_FIELDS = {"input", "display_text", "if_busy", "reasoning_effort", "workspace_roots", "user_shell"}
 _TURN_EXCLUDED = {"commandId", "sessionId"}
 assert {
     _camel(f.name) for f in fields(SendUserTurnOptions) if f.name in _TURN_WIRE_FIELDS
@@ -292,4 +297,6 @@ class TurnSubmitter(Generic[_I]):
         # No tokenBudget forward: experimental-gated, stable SDK omits it.
         if options.workspace_roots is not None:
             params["workspaceRoots"] = options.workspace_roots
+        if options.user_shell is not None:
+            params["userShell"] = options.user_shell
         return params

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/src/muse_code/fold/session_fold.py

@@ -102,6 +102,17 @@ LIVE_HOST_STATE_PROJECTIONS: frozenset[str] = frozenset(
         # connection) — no ``viewCursor``, no ``sourceRange``; a row-table
         # consumer applies it out of band and it folds no transcript state.
         "session/listChanged",
+        # The plugin change hints are live host-state projections like
+        # ``skill/changed`` — re-issue hints, never folded items: an
+        # install landing (``plugin/changed``) or a marketplace add,
+        # update, or remove (``plugin/marketplaceChanged``) tells the
+        # client to re-issue ``plugin/list``, and neither carries
+        # foldable view state.
+        "plugin/changed",
+        "plugin/marketplaceChanged",
+        # A session's computer-use setup state moved: a host-state push
+        # with no view cursor, for a Settings consumer.
+        "computerUseSetup/changed",
     )
 )
 """Notifications that are live host-state projections, not view events:
@@ -675,8 +686,12 @@ class SessionFold:
         turn = self._turn_for(turn_id)
         turn.command_id = params.get("commandId")
         # A retract is NOT a TurnTerminal; leaving `terminal` unset is the
-        # whole point. The retracted user message re-arrives via
-        # `item/updated` with `retracted: true`, which the item half folds.
+        # whole point. On accepted, the retracted user message re-arrives via
+        # `item/updated` with `retracted: true`, which the item half folds
+        # (a declined outcome also lands here for now: the entry reads
+        # retracted and the later turn/completed arrives as a stale frame,
+        # so its terminal is dropped too - a known gap in this fold,
+        # behavior unchanged).
         turn.state = "retracted"
         self._clear_active(turn_id)
         return TurnFold(turn_id, turn.state)

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7/src/muse_code_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.4
+Version: 1.4.7
 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

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/src/muse_code_sdk.egg-info/SOURCES.txt

@@ -42,6 +42,7 @@ tests/test_facade_approval.py
 tests/test_facade_gap_fill.py
 tests/test_facade_open_same_chunk.py
 tests/test_facade_persistent_approval.py
+tests/test_facade_required_selection.py
 tests/test_facade_turn.py
 tests/test_host_discovery.py
 tests/test_item_store.py
@@ -50,6 +51,7 @@ tests/test_muse_serve_child.py
 tests/test_pending_command_corpus.py
 tests/test_pending_command_set.py
 tests/test_pending_command_wire_binding.py
+tests/test_permission_state_wire_types.py
 tests/test_public_mirror_text.py
 tests/test_publish_shape.py
 tests/test_session_fold.py

muse_code_sdk-1.4.7/tests/test_facade_required_selection.py

@@ -0,0 +1,305 @@
+"""The required-selection arm of the Python SDK facade: a caller that sets
+``require_permission_profile`` alongside ``permission_profile`` requires its
+selection, and the client proves it instead of proceeding on the host default.
+
+A caller that sets ``require_permission_profile`` alongside
+``permission_profile`` requires its selection: the client proves the
+committed selection equals the requested id -- from the start result's own
+``session.permissionState``, else a ``session/read`` read-back -- and raises
+``PermissionProfileNotApplied`` instead of proceeding on the host default.
+The refused session is dropped (no orphan); the caller resumes via the
+error's ``session_id`` or starts again: no auto-close, no auto-set, never a
+silent default.
+
+The blocking twin (``SyncMuseClient.start_session``) delegates verbatim to
+the async verb, so these async arms cover it; no sync-surface test needed.
+
+Causal, never time-based: every wait is ``wait_for_writes`` / ``pump``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import pytest
+
+from muse_code import (
+    MuseClient,
+    MuseClientOptions,
+    PermissionProfileNotApplied,
+    ResumeSessionOptions,
+    StartSessionOptions,
+    read_session_durability,
+)
+from muse_code.connection import Connection
+
+from helpers_connection import (
+    FakeDuplex,
+    answer,
+    pump,
+    sent_frame,
+    sent_params,
+    wait_for_writes,
+)
+
+Params = dict[str, Any]
+
+REQUIRED = ":unrestricted"
+OTHER = ":ask-me"
+
+
+def _client() -> tuple[MuseClient[Any], FakeDuplex]:
+    transport = FakeDuplex()
+    client: MuseClient[Any] = MuseClient(
+        Connection(transport),
+        MuseClientOptions(
+            durability=read_session_durability({"sessionDurability": "durable"})
+        ),
+    )
+    return client, transport
+
+
+def _start_result(session_id: str, permission_state: Params | None = None) -> Params:
+    session: Params = {"sessionId": session_id, "status": "idle"}
+    if permission_state is not None:
+        session["permissionState"] = permission_state
+    return {"session": session, "viewCursor": "v:1"}
+
+
+def _read_result(session_id: str, permission_state: Params | None = None) -> Params:
+    session: Params = {"sessionId": session_id, "status": "idle"}
+    if permission_state is not None:
+        session["permissionState"] = permission_state
+    return {
+        "history": {"mode": "none", "items": []},
+        "pendingRequests": [],
+        "session": session,
+        "viewCursor": "v:2",
+    }
+
+
+def _triple(profile_id: str | None) -> Params:
+    return {
+        "profileId": profile_id,
+        "reviewerAuthority": "autoReview",
+        "reviewerAttached": True,
+    }
+
+
+@pytest.mark.asyncio
+async def test_required_start_whose_read_back_serves_a_different_profile_refuses() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    assert sent_frame(transport, 0)["method"] == "session/start"
+    assert sent_params(transport, 0)["permissionProfile"] == REQUIRED
+    assert "requirePermissionProfile" not in sent_params(transport, 0), (
+        "the require flag is client-local, never on the wire"
+    )
+    answer(transport, 0, _start_result("s-1"))
+
+    await wait_for_writes(transport, 2)
+    assert sent_frame(transport, 1)["method"] == "session/read"
+    assert sent_params(transport, 1)["sessionId"] == "s-1"
+    answer(transport, 1, _read_result("s-1", _triple(OTHER)))
+
+    with pytest.raises(PermissionProfileNotApplied) as refused:
+        await pending
+    assert refused.value.requested == REQUIRED
+    assert refused.value.served == OTHER
+    assert refused.value.session_id == "s-1"
+    await pump()
+    assert len(transport.writes) == 2, "no turn is sent after the refusal"
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_required_start_whose_read_back_omits_permission_state_refuses_unknown() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1"))
+    await wait_for_writes(transport, 2)
+    answer(transport, 1, _read_result("s-1"))
+
+    with pytest.raises(PermissionProfileNotApplied) as refused:
+        await pending
+    assert refused.value.requested == REQUIRED
+    assert refused.value.served is None
+    assert refused.value.session_id == "s-1"
+    await pump()
+    assert len(transport.writes) == 2
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_required_start_whose_read_back_serves_null_profile_refuses_unknown() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1"))
+    await wait_for_writes(transport, 2)
+    answer(transport, 1, _read_result("s-1", _triple(None)))
+
+    with pytest.raises(PermissionProfileNotApplied) as refused:
+        await pending
+    assert refused.value.requested == REQUIRED
+    assert refused.value.served is None
+    await pump()
+    assert len(transport.writes) == 2
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_require_flag_without_member_is_a_usage_error_before_anything_is_sent() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(StartSessionOptions(require_permission_profile=True))
+    )
+    await pump()
+    if transport.writes:
+        # Pre-fix behavior: it sent -- answer so nothing dangles, then fail loudly.
+        answer(transport, 0, _start_result("s-1"))
+        await pending
+        await client.close()
+        pytest.fail("usage error must fire before anything is sent")
+    with pytest.raises(ValueError):
+        await pending
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_start_without_the_flag_sends_one_frame_and_no_read() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(StartSessionOptions(permission_profile=REQUIRED))
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1"))
+    session = await pending
+    assert session.session_id == "s-1"
+    await pump()
+    assert len(transport.writes) == 1
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_start_result_already_carrying_the_required_profile_proceeds_with_no_read() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1", _triple(REQUIRED)))
+    session = await pending
+    assert session.session_id == "s-1"
+    await pump()
+    assert len(transport.writes) == 1
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_start_result_carrying_a_different_profile_refuses_with_no_read() -> None:
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1", _triple(OTHER)))
+
+    with pytest.raises(PermissionProfileNotApplied) as refused:
+        await pending
+    assert refused.value.requested == REQUIRED
+    assert refused.value.served == OTHER
+    await pump()
+    assert len(transport.writes) == 1
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_refused_session_is_dropped_from_the_client_registry() -> None:
+    # The no-orphan pin: the registry has no public accessor (neither SDK
+    # exposes its sessions), so the single-underscore set is the only
+    # observable for "no unreachable Session keeps folding".
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1", _triple(OTHER)))
+
+    with pytest.raises(PermissionProfileNotApplied):
+        await pending
+    await pump()
+    assert {s.session_id for s in client._sessions} == set()
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_refused_id_stays_resumable_after_the_drop() -> None:
+    # Constitution XIII paired evidence (review 5476188067 follow-up-1): the
+    # refusal drops the orphan while the client stays usable on the same id.
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(
+                permission_profile=REQUIRED, require_permission_profile=True
+            )
+        )
+    )
+    await wait_for_writes(transport, 1)
+    answer(transport, 0, _start_result("s-1", _triple(OTHER)))
+    with pytest.raises(PermissionProfileNotApplied):
+        await pending
+    await pump()
+
+    resumed = asyncio.ensure_future(
+        client.resume_session(ResumeSessionOptions(session_id="s-1"))
+    )
+    await wait_for_writes(transport, 2)
+    assert sent_frame(transport, 1)["method"] == "session/resume"
+    assert sent_params(transport, 1)["sessionId"] == "s-1"
+    answer(
+        transport,
+        1,
+        {
+            "session": {"sessionId": "s-1", "status": "idle"},
+            "history": {"mode": "none", "items": []},
+            "pendingRequests": [],
+            "viewCursor": "v:9",
+        },
+    )
+    session = await resumed
+    assert session.session_id == "s-1"
+    await client.close()

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/tests/test_facade_turn.py

@@ -874,6 +874,9 @@ async def test_start_session_sends_the_verb_and_keys_by_the_servers_id() -> None
     sent = await _read_last_frame(transport, 1)
     assert sent["method"] == "session/start"
     assert sent["params"]["workspaceRoot"] == "/repo"
+    # The initial permission-profile selection is OMITTED when the option is
+    # left None — never sent as null, like every other optional start member.
+    assert "permissionProfile" not in sent["params"]
     # session/start result may omit the redundant commandId echo.
     transport.chunks.push(
         frame(
@@ -889,6 +892,35 @@ async def test_start_session_sends_the_verb_and_keys_by_the_servers_id() -> None
     await client.close()
 
 
+@pytest.mark.asyncio
+async def test_start_session_forwards_the_permission_profile_member() -> None:
+    """``permission_profile`` rides the wire as ``permissionProfile`` verbatim,
+    like the other start members (the TypeScript SDK pins the same forward)."""
+    import asyncio
+
+    client, transport = _client()
+    pending = asyncio.ensure_future(
+        client.start_session(
+            StartSessionOptions(workspace_root="/repo", permission_profile=":read-only")
+        )
+    )
+    sent = await _read_last_frame(transport, 1)
+    assert sent["method"] == "session/start"
+    assert sent["params"]["permissionProfile"] == ":read-only"
+    transport.chunks.push(
+        frame(
+            {
+                "jsonrpc": "2.0",
+                "id": sent["id"],
+                "result": {"session": {"sessionId": SESSION}, "viewCursor": "v:0"},
+            }
+        )
+    )
+    session_obj = await pending
+    assert session_obj.session_id == SESSION
+    await client.close()
+
+
 @pytest.mark.asyncio
 async def test_send_user_turn_then_routed_events_reach_the_turn_handle() -> None:
     import asyncio

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/tests/test_muse_serve_child.py

@@ -1118,3 +1118,43 @@ async def test_a_bare_incoming_attribute_probe_does_not_arm_the_close_penalty()
         )
     finally:
         reap(pid)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("platform", "start_new_session", "creationflags"),
+    [
+        pytest.param("win32", False, 0x0800_0000, id="windows-no-console"),
+        pytest.param("linux", True, 0, id="linux-process-group"),
+        pytest.param("darwin", True, 0, id="darwin-process-group"),
+    ],
+)
+async def test_spawn_passes_the_platform_spawn_keywords(
+    monkeypatch: pytest.MonkeyPatch,
+    platform: str,
+    start_new_session: bool,
+    creationflags: int,
+) -> None:
+    # A spawned ``muse serve`` is never meant to be seen: on Windows it starts
+    # with CREATE_NO_WINDOW and no process group; on POSIX it leads its own
+    # process group and sets no Windows-only flag bit (creationflags=0).
+    # Wiring pin: the stub
+    # records the exact keywords the call site passes and stops before any
+    # process exists.
+    from muse_code.connection import spawn as spawn_module
+
+    class _Stop(Exception):
+        pass
+
+    seen: dict[str, object] = {}
+
+    async def _record(*args: object, **kwargs: object) -> object:
+        seen.update(kwargs)
+        raise _Stop
+
+    monkeypatch.setattr(spawn_module.asyncio, "create_subprocess_exec", _record)
+    monkeypatch.setattr(spawn_module.sys, "platform", platform)
+    with pytest.raises(_Stop):
+        await MuseServeChild.spawn(muse_bin=sys.executable, args=["-c", "pass"])
+    assert seen["start_new_session"] is start_new_session
+    assert seen["creationflags"] == creationflags

muse_code_sdk-1.4.7/tests/test_permission_state_wire_types.py

@@ -0,0 +1,174 @@
+"""The Python SDK's client arms for the served Auto-review active-state contract.
+
+The wire types under ``muse_code_msp`` are GENERATED from the protocol schema
+by the producing repository's code generator, so this suite tests them and
+never edits them: a wire-type change is a server/schema change, outside the
+client arms.
+
+The stable SDK negotiates no ``experimentalApi``: on its connection the
+``permissionState`` member is STRIPPED and the facade renders no Auto-review
+state. Its arms are therefore the compatibility arms — the stripped member is
+unknown evidence, the experimental member arriving anyway (an embedder that
+opted in) is tolerated losslessly, and a mode-only change folds the mode
+while creating no Auto-review claim. First-run receipts: every arm passes on
+the pre-change facade — pins, recorded as such on the owning change.
+"""
+
+from __future__ import annotations
+
+import typing
+from typing import Any
+
+import muse_code_msp as stable
+from muse_code import Session, read_session_durability
+from muse_code.fold.session_fold import IgnoredUnrecognizedMethod, SessionStateFold
+from muse_code_msp import experimental
+
+SESSION = "s-1"
+SOURCE_RANGE: dict[str, Any] = {
+    "first": {"recordIndex": 0, "streamOffset": 0},
+    "last": {"recordIndex": 0, "streamOffset": 0},
+    "stream": {"kind": "run", "runId": "r-1"},
+}
+TRIPLE: experimental.EffectivePermissionState = {
+    "profileId": ":auto-review",
+    "reviewerAttached": True,
+    "reviewerAuthority": "autoReview",
+}
+
+
+def _keys(typed_dict: Any) -> set[str]:
+    return set(typed_dict.__required_keys__) | set(typed_dict.__optional_keys__)
+
+
+def _fold_only() -> Session[str]:
+    return Session(SESSION, read_session_durability({"sessionDurability": "durable"}))
+
+
+def _claim_surface(value: object) -> list[str]:
+    """Every public member name that reads like an Auto-review / permission-state claim.
+
+    ``dir`` lists instance attributes as well as the class surface, so a
+    public field planted on the instance trips it too (the TS twin had to
+    widen its scan for that).
+    """
+    words = ("permission", "reviewer", "auto_review", "autoreview")
+    return sorted(name for name in dir(value) if any(word in name.lower() for word in words))
+
+
+# ---- the experimental bundle types the renders-active triple -----------------
+
+
+def test_the_experimental_bundle_types_the_renders_active_triple() -> None:
+    # Membership, not a freeze: the arm needs these three to be required; a
+    # later required member on this experimental type must not red it.
+    assert {"profileId", "reviewerAttached", "reviewerAuthority"} <= set(
+        experimental.EffectivePermissionState.__required_keys__
+    ), "a snapshot cannot answer the predicate with a member missing"
+    assert "autoReview" in experimental.REVIEWER_AUTHORITY_KNOWN_VALUES
+    # Membership here too: a client that renders nothing off the mode must not
+    # red on a fifth mode word; classifying one is the renderer's concern.
+    assert {"allowAll", "promptUnmatched", "onRequest", "denyUnmatched"} <= set(
+        typing.get_args(experimental.ApprovalMode)
+    )
+    # Both halves of the triple ride the same served snapshot, additive-optional.
+    assert "permissionState" in experimental.Session.__optional_keys__
+    assert "approvalMode" in experimental.Session.__optional_keys__
+    assert "permissionState" in experimental.SessionStatusChangedParams.__optional_keys__
+    assert "permissionState" in experimental.SessionSetPermissionProfileResult.__required_keys__
+    assert "session/permissionProfileChanged" in experimental.NOTIFICATIONS
+
+
+def test_a_stable_connection_sees_the_member_stripped() -> None:
+    assert "permissionState" not in _keys(stable.Session)
+    assert "approvalMode" in _keys(stable.Session), "the mode half stays stable"
+    assert "permissionState" not in _keys(stable.SessionStatusChangedParams)
+    assert "session/permissionProfileChanged" not in stable.NOTIFICATIONS
+    assert not hasattr(stable, "EffectivePermissionState")
+
+
+# ---- the facade tolerates the experimental member and claims nothing ----------
+
+
+def test_status_changed_carrying_the_triple_is_tolerated_and_folds_no_state() -> None:
+    session = _fold_only()
+    outcome = session.apply(
+        {
+            "method": "session/statusChanged",
+            "params": {
+                "sessionId": SESSION,
+                "status": "idle",
+                "viewCursor": None,
+                "permissionState": dict(TRIPLE),
+            },
+        }
+    )
+    assert isinstance(outcome.fold, IgnoredUnrecognizedMethod)
+    assert outcome.fold.method == "session/statusChanged"
+    assert session.fold.session_state.families() == []
+
+
+def test_permission_profile_changed_is_tolerated_as_a_newer_hosts_method() -> None:
+    session = _fold_only()
+    outcome = session.apply(
+        {
+            "method": "session/permissionProfileChanged",
+            "params": {
+                "clientName": "test",
+                "commandId": "cmd-9",
+                "profileId": ":auto-review",
+                "sessionId": SESSION,
+                "source": "client",
+                "sourceRange": SOURCE_RANGE,
+                "viewCursor": "v:2",
+                "permissionState": dict(TRIPLE),
+            },
+        }
+    )
+    assert isinstance(outcome.fold, IgnoredUnrecognizedMethod)
+    assert session.fold.session_state.families() == []
+
+
+def test_a_mode_only_change_folds_the_mode_and_the_facade_claims_no_auto_review() -> None:
+    session = _fold_only()
+    modes = ("onRequest", "promptUnmatched", "allowAll", "denyUnmatched")
+    for index, mode in enumerate(modes, start=1):
+        # A distinct cursor per event: an equal cursor is a replay the store refuses.
+        params = {
+            "clientName": "test",
+            "commandId": "cmd-1",
+            "mode": mode,
+            "sessionId": SESSION,
+            "source": "approvalReconfigure",
+            "sourceRange": SOURCE_RANGE,
+            "viewCursor": f"v:{index}",
+        }
+        outcome = session.apply({"method": "session/approvalModeChanged", "params": params})
+        assert isinstance(outcome.fold, SessionStateFold), f"{mode} folds as session state"
+        assert session.fold.session_state.get("session/approvalModeChanged") == params
+    assert session.fold.session_state.families() == ["session/approvalModeChanged"]
+    # A later triple on the live projection changes nothing the fold holds.
+    session.apply(
+        {
+            "method": "session/statusChanged",
+            "params": {
+                "sessionId": SESSION,
+                "status": "idle",
+                "viewCursor": None,
+                "permissionState": dict(TRIPLE),
+            },
+        }
+    )
+    assert session.fold.session_state.families() == ["session/approvalModeChanged"]
+    # Contract tripwire: a client may report active Auto-review only when the
+    # served mode, reviewer authority, and attachment agree in one snapshot.
+    # The stable facade exposes NO Auto-review / permission state accessor, so
+    # nothing can report "active" off the mode or a label alone; a future
+    # accessor must flip this pin AND satisfy the whole triple.
+    assert _claim_surface(session) == []
+
+
+def test_the_claim_surface_tripwire_sees_a_planted_instance_attribute() -> None:
+    session = _fold_only()
+    setattr(session, "permission_state", {})
+    assert _claim_surface(session) == ["permission_state"]

{muse_code_sdk-1.4.4 → muse_code_sdk-1.4.7}/tests/test_session_fold.py

@@ -1013,10 +1013,14 @@ def test_every_generated_view_notification_is_routed_never_the_default() -> None
     # like the handshake's `initialized`; the client handles it out of band.
     # `userInput/engaged` is client-to-server, like the handshake's
     # `initialized` — the fold never sees it.
+    # `recap/completed` is a command-plane settlement to the requesting
+    # connection only — no `viewCursor`, no `sourceRange`, nothing durable
+    # to fold.
     non_fold_notifications = {
         "initialized",
         "session/viewHealthChanged",
         "userInput/engaged",
+        "recap/completed",
     }
     # Session lifecycle broadcasts (a session was loaded or unloaded on the
     # host) are control-plane notifications, not view events — they carry no