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

{muse_code_sdk-1.4.9/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.9
+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.9 → 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.9"
+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.9 → muse_code_sdk-1.4.10}/src/muse_code/__init__.py

@@ -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.9"
+__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.9 → muse_code_sdk-1.4.10}/src/muse_code/fold/session_fold.py

@@ -323,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.
@@ -714,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.9 → 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.9
+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.9 → 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.9 → 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.9 → muse_code_sdk-1.4.10}/tests/test_session_fold.py

@@ -69,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]:
@@ -443,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