muse-code-sdk 1.4.8__tar.gz → 1.4.10__tar.gz

{muse_code_sdk-1.4.8/src/muse_code_sdk.egg-info → muse_code_sdk-1.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.8
+Version: 1.4.10
 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.8 → muse_code_sdk-1.4.10}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "muse-code-sdk"
-version = "1.4.8"
+version = "1.4.10"
 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.8 → muse_code_sdk-1.4.10}/src/muse_code/__init__.py

@@ -80,7 +80,7 @@ __all__ = [
 ]
 
 EXPECTED_SCHEMA_FINGERPRINT: Final[str] = (
-    "sha256:4e3200c3c9dc0cd7919d11022630d43f9bc1c5cdda375381e90b0183b5665069"
+    "sha256:5d3b43e5ccdb7dc4f5a32c380f5f2cde0f10e3059b93610afb2e73f73b1d914c"
 )
 """The stable schema-bundle fingerprint this SDK was built against.
 
@@ -92,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.8"
+__version__: Final[str] = "1.4.10"
 
 # 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.8 → muse_code_sdk-1.4.10}/src/muse_code/fold/__init__.py

@@ -21,6 +21,7 @@ from .session_fold import (
     LIVE_HOST_STATE_PROJECTIONS,
     VIEW_EVENT_METHODS,
     ApprovalPending,
+    ApprovalReviewingNotice,
     ApprovalResolvedFold,
     DeliveryGap,
     FoldItems,
@@ -48,6 +49,7 @@ __all__ = [
     "VIEW_EVENT_METHODS",
     "Appended",
     "ApprovalPending",
+    "ApprovalReviewingNotice",
     "ApprovalResolvedFold",
     "BufferedForAbsentItem",
     "DeliveryGap",

{muse_code_sdk-1.4.8 → muse_code_sdk-1.4.10}/src/muse_code/fold/session_fold.py

@@ -75,6 +75,9 @@ VIEW_EVENT_METHODS: frozenset[str] = frozenset(
         "turn/modelRetryScheduled",
         "turn/unqueued",
         "approval/requested",
+        # The reviewer-held twin of `approval/requested`: routed to its own
+        # non-storing notice.
+        "approval/reviewing",
         "approval/updated",
         "approval/resolved",
         "userInput/requested",
@@ -281,6 +284,19 @@ class ModelRouteUnservedNotice:
     provider_id: str | None
 
 
+@dataclass(frozen=True)
+class ApprovalReviewingNotice:
+    """The ``approval/reviewing`` typed-activity signal.
+
+    The host's built-in reviewer holds this approval. A notice, never a
+    pending entry: it seeds no store and opens no decision — the approval is
+    absent from ``pending_approvals`` until ``approval/requested`` releases it
+    to the human (or ``approval/resolved`` settles it) on the same id.
+    """
+
+    approval_id: str
+
+
 @dataclass(frozen=True)
 class IgnoredUnrecognizedMethod:
     """A newer host's method this SDK has never heard of."""
@@ -307,9 +323,12 @@ class IgnoredMissingParams:
 class IgnoredStaleFrame:
     """A recognized frame the fold deliberately dropped, state unchanged.
 
-    A ``turn/started`` or ``turn/completed`` for a turn that already left
-    ``running``, an ``approval/updated`` for an approval it never saw
-    requested (or whose entry a resolution already deleted), or a redelivered
+    A ``turn/started``, ``turn/retryScheduled``, ``turn/modelRetryScheduled``
+    or ``turn/foregroundCompleted`` for a turn that already left ``running``;
+    a ``turn/completed`` for a ``retracted`` or ``unqueued`` turn; a declined
+    ``turn/retracted`` for a turn the fold has not seen; an
+    ``approval/updated`` for an approval it never saw requested (or whose
+    entry a resolution already deleted); or a redelivered
     ``approval/requested`` / ``userInput/requested`` for an approval/prompt
     that already has its durable terminal. Truthful by contract: a "pending"
     outcome here would make a renderer show an entry the fold does not hold.
@@ -330,6 +349,7 @@ FoldOutcome = (
     | UserInputSettledFold
     | DeliveryGap
     | ModelRouteUnservedNotice
+    | ApprovalReviewingNotice
     | IgnoredUnrecognizedMethod
     | IgnoredMissingParams
     | IgnoredStaleFrame
@@ -585,6 +605,8 @@ class SessionFold:
             return self._turn_foreground_completed(params)
         if method == "approval/requested":
             return self._approval_requested(params)
+        if method == "approval/reviewing":
+            return ApprovalReviewingNotice(approval_id=str(params["approvalId"]))
         if method == "approval/updated":
             return self._approval_updated(params)
         if method == "approval/resolved":
@@ -695,15 +717,25 @@ class SessionFold:
 
     def _turn_retracted(self, params: Params) -> FoldOutcome:
         turn_id = str(params["turnId"])
+        # A declined retract means the submission stood, so the fold keeps
+        # the turn's prior state: a running turn stays running and its
+        # turn/completed still settles it, and a settled turn stays settled.
+        # The fold records the standing submission's commandId on a turn it
+        # holds. A declined retract carries no lifecycle fact, so for a turn
+        # the fold has not seen it creates no entry. Only an explicit
+        # "declined" counts; an absent or unrecognized outcome reads as
+        # accepted.
+        if params.get("outcome") == "declined":
+            held = self._turns.get(turn_id)
+            if held is None:
+                return IgnoredStaleFrame("turn/retracted", turn_id)
+            held.command_id = params.get("commandId")
+            return TurnFold(turn_id, held.state)
         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. 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).
+        # `item/updated` with `retracted: true`, which the item half folds.
         turn.state = "retracted"
         self._clear_active(turn_id)
         return TurnFold(turn_id, turn.state)

{muse_code_sdk-1.4.8 → muse_code_sdk-1.4.10/src/muse_code_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muse-code-sdk
-Version: 1.4.8
+Version: 1.4.10
 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.8 → muse_code_sdk-1.4.10}/tests/test_external_audience.py

@@ -21,6 +21,7 @@ so this file's own text stays clean under the tree tier.
 from __future__ import annotations
 
 import importlib.util
+import io
 import re
 import subprocess
 import sys
@@ -674,3 +675,190 @@ def test_the_npm_tarball_mode_refuses_a_tarball_missing_its_readme(tmp_path: Pat
     result = _run_checker("--npm-tarball", str(tarball))
     assert result.returncode != 0
     assert "no package/README.md" in result.stderr
+
+
+
+# A Rust source member's name, built at run time so this mirrored file carries
+# no repository source-path token of its own.
+LIB_RS = "src/lib" + ".r" + "s"
+
+def _seeded_crate(
+    tmp_path: Path,
+    *,
+    readme_line: str = "Drive the host from a Tokio runtime.",
+    description: str = "A clean summary.",
+    files: dict[str, str] | None = None,
+) -> Path:
+    # A .crate is a gzip tarball under one <name>-<version>/ root.
+    entries = {
+        "README.md": f"# clean\n\n{readme_line}\n",
+        "Cargo.toml": (
+            '[package]\nname = "muse-code-sdk"\nversion = "1.0.0"\n'
+            f'description = "{description}"\n'
+        ),
+        LIB_RS: "//! A clean crate.\n",
+    }
+    entries.update(files or {})
+    crate = tmp_path / "muse-code-sdk-1.0.0.crate"
+    with tarfile.open(crate, "w:gz") as archive:
+        for name, text in entries.items():
+            data = text.encode("utf-8")
+            info = tarfile.TarInfo(f"muse-code-sdk-1.0.0/{name}")
+            info.size = len(data)
+            archive.addfile(info, io.BytesIO(data))
+    return crate
+
+
+def _vcs_record(path_in_vcs: str) -> str:
+    return (
+        '{"git": {"sha1": "' + "a" * 40 + '", "dirty": false}, '
+        f'"path_in_vcs": "{path_in_vcs}"}}\n'
+    )
+
+
+def test_a_clean_crate_passes(tmp_path: Path) -> None:
+    result = _run_checker("--crate", str(_seeded_crate(tmp_path)))
+    assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.parametrize(
+    ("site", "overrides"),
+    [
+        # A metadata-only class: the tree tier allows a closure path, the README
+        # (registry metadata) does not.
+        ("README.md", {"readme_line": LEAKS["client-path"]}),
+        ("Cargo.toml [package] description", {"description": LEAKS["client-path"]}),
+        (
+            LIB_RS + ": adr-citation",
+            {"files": {LIB_RS: "//! A clean crate.\n// Checked per " + LEAKS["adr-citation"] + ".\n"}},
+        ),
+    ],
+    ids=["crate-readme", "crate-description", "crate-source"],
+)
+def test_each_crate_site_is_refused(tmp_path: Path, site: str, overrides: dict) -> None:
+    result = _run_checker("--crate", str(_seeded_crate(tmp_path, **overrides)))
+    assert result.returncode != 0, f"a leak in the {site} site passed the crate gate"
+    assert site in result.stderr, f"the refusal must name the {site} site:\n{result.stderr}"
+
+
+def test_the_crate_mode_passes_the_mirrors_commit_record_and_refuses_the_producers(
+    tmp_path: Path,
+) -> None:
+    # Cargo writes .cargo_vcs_info.json into every crate packaged from git: a
+    # commit SHA (no class here) and the crate's path in the repository. The
+    # tree tier allows the mirror's rust/clients/sdk-rs; the producing
+    # checkout's path is a dev-loop path, so a crate packaged there refuses.
+    mirror = _seeded_crate(
+        tmp_path, files={".cargo_vcs_info.json": _vcs_record("rust/clients/sdk-rs")}
+    )
+    result = _run_checker("--crate", str(mirror))
+    assert result.returncode == 0, result.stderr
+    producer_dir = tmp_path / "producer"
+    producer_dir.mkdir()
+    producer = _seeded_crate(
+        producer_dir,
+        files={".cargo_vcs_info.json": _vcs_record("projects/" + "tb" + "h/clients/sdk-rs")},
+    )
+    result = _run_checker("--crate", str(producer))
+    assert result.returncode != 0
+    assert ".cargo_vcs_info.json: dev-loop-path" in result.stderr, result.stderr
+
+
+def test_the_crate_mode_refuses_a_crate_missing_its_readme(tmp_path: Path) -> None:
+    crate = tmp_path / "muse-code-sdk-1.0.0.crate"
+    data = b'[package]\nname = "muse-code-sdk"\nversion = "1.0.0"\n'
+    with tarfile.open(crate, "w:gz") as archive:
+        info = tarfile.TarInfo("muse-code-sdk-1.0.0/Cargo.toml")
+        info.size = len(data)
+        archive.addfile(info, io.BytesIO(data))
+    result = _run_checker("--crate", str(crate))
+    assert result.returncode != 0
+    assert "no muse-code-sdk-1.0.0/README.md" in result.stderr
+
+
+def test_the_crate_mode_holds_module_docs_to_the_full_table(tmp_path: Path) -> None:
+    # The crate's documentation pages show each module's inner docs, so a
+    # metadata-only class refuses there; the same text in an ordinary comment
+    # is tree-tier and passes.
+    in_docs = _seeded_crate(tmp_path, files={LIB_RS: "//! See " + LEAKS["client-path"] + ".\n"})
+    result = _run_checker("--crate", str(in_docs))
+    assert result.returncode != 0
+    assert LIB_RS + " module docs: client-path" in result.stderr, result.stderr
+    comment_dir = tmp_path / "comment"
+    comment_dir.mkdir()
+    in_comment = _seeded_crate(
+        comment_dir, files={LIB_RS: "//! A clean crate.\n// See " + LEAKS["client-path"] + ".\n"}
+    )
+    result = _run_checker("--crate", str(in_comment))
+    assert result.returncode == 0, result.stderr
+
+
+def test_the_crate_mode_holds_example_headers_to_the_full_table(tmp_path: Path) -> None:
+    # Examples ship in the crate too, so their headers get the same table.
+    example = "examples/hello" + ".r" + "s"
+    crate = _seeded_crate(tmp_path, files={example: "//! See " + LEAKS["client-path"] + ".\nfn main() {}\n"})
+    result = _run_checker("--crate", str(crate))
+    assert result.returncode != 0
+    assert example + " module docs: client-path" in result.stderr, result.stderr
+
+
+def _crate_with(tmp_path: Path, members: dict[str, bytes]) -> Path:
+    crate = tmp_path / "muse-code-sdk-1.0.0.crate"
+    with tarfile.open(crate, "w:gz") as archive:
+        for name, data in members.items():
+            info = tarfile.TarInfo(name)
+            info.size = len(data)
+            archive.addfile(info, io.BytesIO(data))
+    return crate
+
+
+_CLEAN_MANIFEST = b'[package]\nname = "muse-code-sdk"\nversion = "1.0.0"\n'
+
+
+@pytest.mark.parametrize(
+    ("members", "message"),
+    [
+        (
+            {"a-1.0.0/README.md": b"# a\n", "b-1.0.0/README.md": b"# b\n"},
+            "has no single package root",
+        ),
+        (
+            {
+                "muse-code-sdk-1.0.0/README.md": b"# clean\n",
+                "muse-code-sdk-1.0.0/Cargo.toml": _CLEAN_MANIFEST,
+                "muse-code-sdk-1.0.0/src/data.bin": b"\xff\xfe",
+            },
+            "not UTF-8 text",
+        ),
+        (
+            {
+                "muse-code-sdk-1.0.0/README.md": b"# clean\n",
+                "muse-code-sdk-1.0.0/Cargo.toml": b"[package\nname = 1\n",
+            },
+            "not parseable TOML",
+        ),
+    ],
+    ids=["two-roots", "binary-member", "bad-manifest"],
+)
+def test_the_crate_mode_refuses_a_malformed_crate(
+    tmp_path: Path, members: dict[str, bytes], message: str
+) -> None:
+    result = _run_checker("--crate", str(_crate_with(tmp_path, members)))
+    assert result.returncode != 0
+    assert message in result.stderr, result.stderr
+
+
+def test_the_crate_mode_refuses_a_file_that_is_no_crate_archive(tmp_path: Path) -> None:
+    not_a_crate = tmp_path / "muse-code-sdk-1.0.0.crate"
+    not_a_crate.write_text("not a tarball\n")
+    result = _run_checker("--crate", str(not_a_crate))
+    assert result.returncode != 0
+    assert "is not a readable crate archive" in result.stderr, result.stderr
+
+
+def test_the_crate_mode_refuses_a_crate_that_is_missing(tmp_path: Path) -> None:
+    # The publish script relies on this: it has no check of its own for the
+    # file `cargo package` writes.
+    result = _run_checker("--crate", str(tmp_path / "muse-code-sdk-1.0.0.crate"))
+    assert result.returncode != 0
+    assert "is not a readable crate archive" in result.stderr, result.stderr

{muse_code_sdk-1.4.8 → muse_code_sdk-1.4.10}/tests/test_public_mirror_text.py

@@ -433,6 +433,33 @@ def test_digest_tree_matches_across_layouts(tmp_path: Path) -> None:
     assert digest_of(producer) == digest_of(mirror)
 
 
+def test_digest_tree_matches_across_layouts_for_rust(tmp_path: Path) -> None:
+    # "Rust closure" entries map under rust/ the same way: the producer's
+    # verbatim crate and the mirror's rust/ copy digest identically.
+    producer = tmp_path / "producer"
+    mirror = tmp_path / "mirror"
+    notes = {
+        "clients/crate": "Rust closure. Marked for the mapping test.",
+        "scripts/publish.sh": "Rust closure. Marked for the mapping test.",
+    }
+    write_mirror_tree(
+        producer,
+        {"clients/crate/a.txt": "one\n", "scripts/publish.sh": "two\n"},
+        entries=["clients/crate", "scripts/publish.sh"],
+        notes=notes,
+    )
+    write_mirror_tree(
+        mirror,
+        {
+            "rust/clients/crate/a.txt": "one\n",
+            "rust/scripts/publish.sh": "two\n",
+        },
+        entries=["clients/crate", "scripts/publish.sh"],
+        notes=notes,
+    )
+    assert digest_of(producer) == digest_of(mirror)
+
+
 def test_digest_tree_refuses_symlink_inside_directory(tmp_path: Path) -> None:
     # A symlink anywhere under a walked entry refuses instead of
     # resolving: link following could escape the closure.
@@ -573,6 +600,16 @@ def test_closure_python_marked_set_is_frozen() -> None:
     }
 
 
+def test_closure_rust_marked_set_is_frozen() -> None:
+    # LOAD-BEARING FREEZE, like the Python one: "Rust closure" notes map
+    # entries under rust/. None exist until the Rust SDK joins the mirror
+    # closure; that change updates this pin deliberately.
+    manifest = json.loads(CLOSURE_MANIFEST.read_text(encoding="utf-8"))
+    notes = manifest["path_notes"]
+    marked = {path for path, note in notes.items() if note.startswith("Rust closure")}
+    assert marked == set()
+
+
 def test_scan_text_refuses_undecodable_file(tmp_path: Path) -> None:
     binary = tmp_path / "bytes.bin"
     binary.write_bytes(b"\xff\xfe\x00bad")

{muse_code_sdk-1.4.8 → muse_code_sdk-1.4.10}/tests/test_session_fold.py

@@ -15,6 +15,8 @@ from typing import Any
 from muse_code.fold import (
     LIVE_HOST_STATE_PROJECTIONS,
     VIEW_EVENT_METHODS,
+    ApprovalPending,
+    ApprovalReviewingNotice,
     ApprovalResolvedFold,
     DeliveryGap,
     FoldItems,
@@ -67,17 +69,19 @@ def turn_completed(
     return {"method": "turn/completed", "params": params}
 
 
-def turn_retracted(turn_id: str, command_id: str, view_cursor: str) -> dict[str, Any]:
-    return {
-        "method": "turn/retracted",
-        "params": {
-            "commandId": command_id,
-            "sessionId": SESSION,
-            "sourceRange": SOURCE,
-            "turnId": turn_id,
-            "viewCursor": view_cursor,
-        },
+def turn_retracted(
+    turn_id: str, command_id: str, view_cursor: str, outcome: str | None = None
+) -> dict[str, Any]:
+    params: dict[str, Any] = {
+        "commandId": command_id,
+        "sessionId": SESSION,
+        "sourceRange": SOURCE,
+        "turnId": turn_id,
+        "viewCursor": view_cursor,
     }
+    if outcome is not None:
+        params["outcome"] = outcome
+    return {"method": "turn/retracted", "params": params}
 
 
 def turn_unqueued(turn_id: str, command_id: str, view_cursor: str) -> dict[str, Any]:
@@ -178,6 +182,13 @@ def approval_requested(
     }
 
 
+def approval_reviewing(approval_id: str, view_cursor: str) -> dict[str, Any]:
+    # The reviewer-held twin of `approval/requested`: same params shape,
+    # different method.
+    event = approval_requested(approval_id, view_cursor)
+    return {"method": "approval/reviewing", "params": event["params"]}
+
+
 def approval_updated(
     approval_id: str, view_cursor: str, source_index: int = 1, command: str | None = None
 ) -> dict[str, Any]:
@@ -434,6 +445,79 @@ def test_a_reclaimed_turn_stays_unqueued_no_turn_completed_ever_settles_it() ->
     assert held.terminal is None, "a reclaim is not a terminal"
 
 
+# A declined retract means the submission stood: the fold keeps a turn's prior
+# state, so turn/completed settles a running turn in either order. On a turn
+# the fold holds it records the retract's commandId (the standing
+# submission's).
+def test_a_declined_retract_after_turn_completed_leaves_the_turn_settled_and_records_its_command_id() -> None:
+    fold = SessionFold()
+    # First seen through its completion, so only the retract names the command.
+    fold.apply(turn_completed("turn-1", "completed", "v:s:1"))
+    outcome = fold.apply(turn_retracted("turn-1", "cmd-c", "v:s:2", "declined"))
+
+    assert outcome == TurnFold("turn-1", "settled")
+    turn = fold.turn("turn-1")
+    assert turn is not None
+    assert turn.state == "settled", "the submission stood"
+    assert turn.terminal == "completed"
+    assert turn.command_id == "cmd-c"
+
+
+def test_a_declined_retract_while_the_turn_runs_leaves_it_running_and_turn_completed_settles_it() -> None:
+    fold = SessionFold()
+    fold.apply(turn_started("turn-1", "cmd-1", "v:s:1"))
+    outcome = fold.apply(turn_retracted("turn-1", "cmd-1", "v:s:2", "declined"))
+
+    assert outcome == TurnFold("turn-1", "running")
+    turn = fold.turn("turn-1")
+    assert turn is not None and turn.state == "running", "the submission stood"
+    assert fold.active_turn_id == "turn-1", "the turn is still the active one"
+
+    completed = fold.apply(turn_completed("turn-1", "completed", "v:s:3"))
+    assert completed == TurnFold("turn-1", "settled")
+    turn = fold.turn("turn-1")
+    assert turn is not None and turn.terminal == "completed", "the terminal is not dropped"
+    assert fold.active_turn_id is None
+
+
+def test_a_declined_retract_leaves_a_reclaimed_turn_unqueued_and_records_its_command_id() -> None:
+    # The protocol never pairs these frames. The test pins the commandId rule
+    # for a held turn in any state, with a distinct id so the record shows.
+    fold = SessionFold()
+    fold.apply(turn_unqueued("turn-2", "cmd-2", "v:s:1"))
+    fold.apply(turn_retracted("turn-2", "cmd-c", "v:s:2", "declined"))
+
+    turn = fold.turn("turn-2")
+    assert turn is not None
+    assert turn.state == "unqueued"
+    assert turn.command_id == "cmd-c"
+
+
+def test_a_declined_retract_for_a_turn_the_fold_has_not_seen_creates_no_entry() -> None:
+    fold = SessionFold()
+    # A client that joined after this turn's completion: the declined retract
+    # carries no lifecycle fact, so the fold must not invent a running turn.
+    outcome = fold.apply(turn_retracted("turn-9", "cmd-9", "v:s:1", "declined"))
+
+    assert outcome == IgnoredStaleFrame("turn/retracted", "turn-9")
+    assert fold.turn("turn-9") is None
+    assert fold.active_turn_id is None
+
+    fold.apply(turn_completed("turn-9", "completed", "v:s:2"))
+    turn = fold.turn("turn-9")
+    assert turn is not None and turn.state == "settled", "a later completion still settles it"
+
+
+def test_an_unrecognized_retract_outcome_reads_as_accepted() -> None:
+    fold = SessionFold()
+    fold.apply(turn_started("turn-1", "cmd-1", "v:s:1"))
+    fold.apply(turn_retracted("turn-1", "cmd-1", "v:s:2", "future-outcome"))
+
+    turn = fold.turn("turn-1")
+    assert turn is not None and turn.state == "retracted"
+    assert fold.active_turn_id is None
+
+
 def test_turn_retracted_carries_the_command_id_when_the_retract_is_the_first_frame() -> None:
     fold = SessionFold()
     # A client joining mid-session can see `turn/retracted` as its first
@@ -1072,6 +1156,19 @@ def test_the_items_surface_is_an_allowlist_pinned_by_member_set() -> None:
     assert state_public == {"families", "get", "has"}
 
 
+def test_approval_reviewing_is_a_notice_that_opens_no_pending_approval() -> None:
+    # The host's built-in reviewer holds the approval; opening a pending
+    # entry here would defeat the presentation hold. The release arrives as
+    # `approval/requested` on the same id.
+    fold = SessionFold()
+    outcome = fold.apply(approval_reviewing("a-1", "v:s:1"))
+    assert outcome == ApprovalReviewingNotice(approval_id="a-1")
+    assert fold.pending_approvals() == []
+    released = fold.apply(approval_requested("a-1", "v:s:2"))
+    assert isinstance(released, ApprovalPending)
+    assert len(fold.pending_approvals()) == 1
+
+
 def test_every_generated_view_notification_is_routed_never_the_default() -> None:
     # The runtime twin of the TS AssertNever coverage pins, PLUS the routing
     # table: every generated notification except the handshake's
@@ -1156,6 +1253,7 @@ def test_every_generated_view_notification_is_routed_never_the_default() -> None
         "turn/foregroundCompleted": foreground_completed("turn-t5", "v:t:23"),
         "turn/unqueued": turn_unqueued("turn-t4", "cmd-t4", "v:t:9"),
         "approval/requested": approval_requested("a-t", "v:t:10"),
+        "approval/reviewing": approval_reviewing("a-r", "v:t:23"),
         "approval/updated": approval_updated("a-t", "v:t:10b"),
         "approval/resolved": approval_resolved("a-t", "approved", "v:t:11"),
         "userInput/requested": user_input_requested("u-t", "v:t:12"),