sysml2kit 0.3.0__tar.gz → 0.4.0__tar.gz

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 0.4.0 — 2026-08-21
+
+The multi-fidelity release: one analysis, several engines, honest error
+bars, and budgeted escalation — from JSON or from the textual notation.
+
+- **Fidelity ladders.** An analysis may carry sibling
+  `verificationBinding` annotations labeled by two new reserved keys,
+  `fidelity` (rung name) and `costSeconds` (declared wall-clock, which
+  orders the ladder). Sibling bindings are named metadata usages typed
+  by a `metadata def verificationBinding` (`builder.metadata_def` +
+  `builder.metadata(..., definition=...)`), since distinct names are
+  what stable-id hashing needs; a single binding may still just be named
+  `verificationBinding`. Validation rule S2K010 rejects duplicate rung
+  labels and warns on mixed labeled/unlabeled siblings.
+- **Runner policies.** `run_verification(..., policy=...)`: `all`
+  (default) runs every rung and reports the cross-rung `spread` per
+  requirement; `cheapest` runs one; `escalate` runs the cheapest rungs,
+  ranks must-requirements by margin thinness, and escalates within
+  `budget_s` against declared costs (verdicts carry `escalated_from`).
+  Every run records measured `seconds_by_fidelity`; write-back uses the
+  highest-fidelity verdict and names the rung in its provenance. CLI:
+  `verify --policy/--budget-s/--fidelity`; MCP `requirements_verify`
+  gains `policy`/`budget_s` and returns `seconds_by_fidelity`.
+- **Text notation carries the whole loop.** A guarded runtime shim
+  (`backends/_sysmlpy_patches.py`, mirroring upstream mycr0ft/sysmlpy
+  #6, #7, and #9) fixes three visitor defects, and the writer emits
+  named dependencies (`dependency verify_1 from A to B;`), typed
+  bindings, and package-level metadata — so satisfy, verify, derive,
+  allocate, and bindings all round-trip through `.sysml` text.
+  `sysml2kit verify` accepts several text files parsed as one model
+  (the file declaring the `metadata def` rides along) and warns instead
+  of passing vacuously when no bindings are found.
+- **Ownership survives the pilot server.** `push_model` runs in two
+  phases (elements with `aliasIds`, then `OwningMembership` records
+  mapped through server-minted ids); the interchange reader folds
+  membership records back into the owner map. New `api branches` and
+  `api commits` subcommands.
+- Pins: sysmlpy floor 0.36.3; the hatchling `<1.32` cap is lifted
+  (Metadata-Version 2.5 passes current twine); the 2026-05 spec pin was
+  re-confirmed as newest on 2026-08-21.
+
+## 0.3.1 — 2026-08-21
+
+Hotfix release; upgrade recommended.
+
+- **`fmt` could silently delete verification bindings and verify links.**
+  The loss gate's grammar signature missed MetadataFeature nodes, and
+  dependency statements leave no grammar node at all, so a format pass on a
+  binding-bearing file removed both without triggering the refusal. The
+  signature now covers metadata/annotation/dependency nodes and a textual
+  keyword guard catches statements the parser drops entirely; `fmt` on such
+  files now refuses unless `--lossy` is passed.
+- Metadata values in textual output were rendered with Python repr
+  (single-quoted strings, `True`/`False`); they now render as SysML text
+  (double-quoted strings, `true`/`false`).
+- With multiple verificationBinding annotations on one analysis, requirement
+  checking used the last binding while write-back provenance named the
+  first. Both now use the first binding, extra bindings execute with a
+  logged warning, and full multi-binding support is planned.
+
 ## 0.3.0 — 2026-08-21
 
 - **Verification execution** (`sysml2kit.verify`): `verificationBinding`

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/CLAUDE.md

@@ -50,8 +50,7 @@ never edit `_version.py` or add a version literal.
 - `interop/` — `RequirementSpec` extraction; the `metricKey` attribute
   convention bridges to phased-array-systems and aedl (adapters live in those
   repos, not here).
-- `cli.py` — typer app. MCP is deferred to v0.2; when added it goes in
-  `src/sysml2kit/mcp/` following apab's `docs/mcp-conventions.md`.
+- `cli.py` — typer app; `mcp/` follows apab's `docs/mcp-conventions.md`.
 
 ## Constraints
 

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysml2kit
-Version: 0.3.0
+Version: 0.4.0
 Summary: API-first Python tooling for building, querying, validating, and automating SysML v2 models
 Project-URL: Homepage, https://github.com/jman4162/sysml2kit
 Project-URL: Source, https://github.com/jman4162/sysml2kit
@@ -33,7 +33,7 @@ Requires-Dist: networkx>=3.2; extra == 'graph'
 Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1.26; extra == 'mcp'
 Provides-Extra: parse
-Requires-Dist: sysmlpy<0.37,>=0.36.2; extra == 'parse'
+Requires-Dist: sysmlpy<0.37,>=0.36.3; extra == 'parse'
 Provides-Extra: verify
 Requires-Dist: pyyaml>=6.0; extra == 'verify'
 Description-Content-Type: text/markdown
@@ -49,11 +49,11 @@ Description-Content-Type: text/markdown
 API-first Python tooling for building, querying, validating, and automating
 SysML v2 models.
 
-> **Status: pre-alpha.** The 0.3.x line covers the full loop: model, writer,
+> **Status: pre-alpha.** The 0.4.x line covers the full loop: model, writer,
 > interchange, queries, validation, diff, mermaid views, parse backend, MCP
-> server, API client with a live-server harness, and verification execution.
-> The API may still move between minor versions; pin an exact version if you
-> depend on it. Changes: [CHANGELOG.md](CHANGELOG.md).
+> server, API client with a live-server harness, and multi-fidelity
+> verification execution. The API may still move between minor versions; pin
+> an exact version if you depend on it. Changes: [CHANGELOG.md](CHANGELOG.md).
 
 `sysml2kit` is the requirements/architecture/traceability layer for
 engineering automation stacks: build a system model in Python, emit standard
@@ -82,7 +82,12 @@ https://jman4162.github.io/sysml2kit/
 - **Verification execution**: `verificationBinding` metadata binds an
   analysis case to an engine from the `sysml2kit.engines` entry-point group;
   `sysml2kit verify` runs it and checks each requirement with margins, and
-  can write results back into the model with provenance.
+  can write results back into the model with provenance. Sibling bindings
+  labeled with `fidelity`/`costSeconds` form a fidelity ladder: `--policy
+  all` reports the cross-rung spread as an error bar, `--policy escalate
+  --budget-s N` spends a compute budget on the thinnest margins first, and
+  every run records measured seconds per rung. The whole loop — bindings,
+  verify links, policies — works from `.sysml` text as well as JSON.
 - **Mermaid views**: ownership-tree and requirement-trace diagrams.
 - **MCP server**: nine tools for agents (`sysml2kit mcp serve`).
 - **API client**: a thin HTTP client for the OMG Systems Modeling API and

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/README.md

@@ -9,11 +9,11 @@
 API-first Python tooling for building, querying, validating, and automating
 SysML v2 models.
 
-> **Status: pre-alpha.** The 0.3.x line covers the full loop: model, writer,
+> **Status: pre-alpha.** The 0.4.x line covers the full loop: model, writer,
 > interchange, queries, validation, diff, mermaid views, parse backend, MCP
-> server, API client with a live-server harness, and verification execution.
-> The API may still move between minor versions; pin an exact version if you
-> depend on it. Changes: [CHANGELOG.md](CHANGELOG.md).
+> server, API client with a live-server harness, and multi-fidelity
+> verification execution. The API may still move between minor versions; pin
+> an exact version if you depend on it. Changes: [CHANGELOG.md](CHANGELOG.md).
 
 `sysml2kit` is the requirements/architecture/traceability layer for
 engineering automation stacks: build a system model in Python, emit standard
@@ -42,7 +42,12 @@ https://jman4162.github.io/sysml2kit/
 - **Verification execution**: `verificationBinding` metadata binds an
   analysis case to an engine from the `sysml2kit.engines` entry-point group;
   `sysml2kit verify` runs it and checks each requirement with margins, and
-  can write results back into the model with provenance.
+  can write results back into the model with provenance. Sibling bindings
+  labeled with `fidelity`/`costSeconds` form a fidelity ladder: `--policy
+  all` reports the cross-rung spread as an error bar, `--policy escalate
+  --budget-s N` spends a compute budget on the thinnest margins first, and
+  every run records measured seconds per rung. The whole loop — bindings,
+  verify links, policies — works from `.sysml` text as well as JSON.
 - **Mermaid views**: ownership-tree and requirement-trace diagrams.
 - **MCP server**: nine tools for agents (`sysml2kit mcp serve`).
 - **API client**: a thin HTTP client for the OMG Systems Modeling API and

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/SPEC.md

@@ -3,7 +3,8 @@
 ## Reference spec release
 
 This package targets the OMG SysML v2 standard as published in the
-`Systems-Modeling/SysML-v2-Release` repository, tag **`2026-05`**.
+`Systems-Modeling/SysML-v2-Release` repository, tag **`2026-05`** (still the
+newest release tag as of 2026-08-21).
 
 Policy: the pin moves at most quarterly, in a minor release, with the change
 noted in the changelog. `src/sysml2kit/interchange/typemap.py` is the single
@@ -50,22 +51,34 @@ not drop elements the profile lacks classes for.
 
 The backend parses via ``sysmlpy.load_grammar_antlr`` and walks the raw
 ANTLR dict (the wrapper-object loader rebuilds usage bodies lossily and is
-not used). What survives a text round trip:
+not used). The backend also applies guarded runtime patches to sysmlpy's visitor
+(``backends/_sysmlpy_patches.py``; upstream: mycr0ft/sysmlpy #6 and #7 plus
+the metadata-body issue filed with them). Patches activate only for sysmlpy
+0.3x with the expected visitor surface; otherwise the pre-patch losses
+apply and their tests document them.
 
-| Round-trips | Lost upstream (sysmlpy visitor discards it) |
+| Round-trips (with patches active) | Still lost |
 |---|---|
-| names, short names | `dependency A to B;` statements (how the writer emits verify/derive) |
-| docs (package/part/requirement scope) | `allocate X to Y;` endpoints |
-| feature typing, incl. cross-package | `connect a.pa to b.pb;` endpoints |
-| multiplicity | `verification` case usages (dropped entirely) |
+| names, short names | unnamed `dependency A to B;` statements (the writer emits named `verify_N`/`derive_N` dependencies, which reify) |
+| docs (package/part/requirement scope) | `connect a.pa to b.pb;` endpoints |
+| feature typing, incl. cross-package | `verification` case usages (dropped entirely) |
+| multiplicity | metadata inside definition/case bodies (hence the package-level placement convention below) |
 | attribute values with units | value provenance (`source`/`confidence` have no textual slot) |
 | requirement subject and text | |
-| satisfy (package level and inside part bodies) | |
+| satisfy, verify, derive, allocate | |
+| package-level metadata with scalar values (verificationBinding included) | |
 
-Consequence: **satisfy traceability survives text; verify/derive/allocate
-require the JSON interchange.** The losses are pinned by tests in
-`tests/test_backend_fidelity.py` so an upstream sysmlpy fix surfaces as a
-test failure.
+Verify/derive encode as **named dependencies**: ``dependency verify_1 from
+ana to R1;`` — the ``verify_``/``derive_`` name prefix is the round-trip
+convention. Metadata annotations are placed at package level (the ``about``
+reference carries the attachment); ``builder.metadata`` defaults to this.
+Endpoint resolution prefers candidates under the same root package, so
+multi-package files with repeated short names resolve correctly.
+
+Consequence: **a `.sysml` file is a complete verification artifact** —
+`sysml2kit verify` on text produces the same verdicts as on interchange
+JSON. Remaining losses are pinned by tests in
+`tests/test_backend_fidelity.py`.
 
 ## Identity and ownership
 
@@ -79,15 +92,28 @@ test failure.
 
 ## Verification binding convention
 
-A ``MetadataUsage`` named ``verificationBinding`` annotating an
-``AnalysisCaseUsage`` binds that analysis to an executable engine. Values
-(flat scalars, per the metadata model):
+A ``MetadataUsage`` annotating an ``AnalysisCaseUsage`` binds that
+analysis to an executable engine when it is recognizable as a
+``verificationBinding`` in either of two forms:
+
+- the usage itself is named ``verificationBinding``
+  (``metadata verificationBinding about study {...}``), or
+- the usage is a *named* usage typed by a
+  ``metadata def verificationBinding``
+  (``metadata analyticBinding : verificationBinding about study {...}``).
+
+The typed form is required for a fidelity ladder: sibling usages must
+carry distinct names for stable-id hashing, so they share the annotation
+kind through the definition instead of the name. Values (flat scalars,
+per the metadata model):
 
 | key | type | meaning |
 |---|---|---|
 | ``engine`` | str, required | registry name, e.g. ``"phased-array-systems"`` |
 | ``configRef`` | str, optional | ``.yaml``/``.yml``/``.json`` payload file next to the model file (resolved relative to its directory, containment-checked; no ``..``) |
 | ``payload.<dotted>`` | scalar, optional | override deep-merged over the loaded config; dotted keys expand to nested dicts |
+| ``fidelity`` | str, optional | rung label; sibling bindings on one analysis form a fidelity ladder (labels must be distinct, rule S2K010) |
+| ``costSeconds`` | number, optional | declared wall-clock estimate; orders the ladder and gates the escalate policy's budget |
 
 Engines resolve **by name** against a registry populated from the
 ``sysml2kit.engines`` entry-point group and explicit caller registration.
@@ -101,8 +127,8 @@ the analysis (``source`` starts with ``sysml2kit.verify``) and a
 ``verificationVerdict`` metadata on each requirement; both replace prior
 same-named results, so reruns do not accumulate.
 
-Bindings are an interchange-JSON feature: metadata values round-trip through
-JSON, while textual-notation fidelity for metadata is not yet pinned.
+Bindings round-trip through interchange JSON and, at package level, through
+the textual notation (see the fidelity table above).
 
 ## Provenance on values
 

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/docs/rf-library.md

@@ -21,12 +21,13 @@ for spec in extract_requirements(model):
 It ships four library packages (RFVocabulary quantity kinds with units,
 RFParts part/port definitions, RFRequirements requirement definitions using
 the metricKey convention, RFAnalyses analysis case definitions) plus
-**SatcomTerminal28GHz** — a worked example mirroring the aedl `t3-001`
-benchmark: a 28 GHz LEO uplink phased-array terminal with eight
-machine-checkable requirements (worst-case link margin, sidelobe level,
-independent link crosscheck, clear-sky and gain agreement, prime-power and
-unit-cost ceilings, grating-lobe margin), each satisfied by a part and
-verified by an analysis.
+two worked examples. **SatcomTerminal28GHz** mirrors the aedl `t3-001`
+benchmark: eight machine-checkable requirements, each satisfied by a part
+and verified by an analysis. **SatcomTerminalPAS** is executable: its
+`pasStudy` analysis carries a `verificationBinding` for the
+`phased-array-systems` engine, so `sysml2kit verify` runs a real study and
+all five requirements pass with margin (see
+[verification](verification.md)).
 
 The library demonstrates the intended division of labor: domain vocabulary
 as SysML v2 model content, generic mechanics in the kit, physics engines

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/docs/verification.md

@@ -70,8 +70,57 @@ a provenance `source` (`sysml2kit.verify <engine>==<version> <timestamp>`)
 and a `verificationVerdict` metadata on each requirement, replacing prior
 results so reruns do not accumulate.
 
+## Fidelity ladders and allocation
+
+An analysis may carry several bindings at different fidelities. Two more
+reserved metadata keys describe the ladder: `fidelity` (a rung label such
+as `analytic` or `pattern`) and `costSeconds` (the declared wall-clock
+estimate that orders the rungs):
+
+```python
+builder.metadata(
+    model,
+    analysis,
+    {
+        "engine": "phased-array-systems",
+        "configRef": "study.yaml",
+        "fidelity": "analytic",
+        "costSeconds": 0.001,
+    },
+    name="verificationBinding",
+)
+builder.metadata(
+    model,
+    analysis,
+    {
+        "engine": "phased-array-systems-pattern",
+        "configRef": "study.yaml",
+        "fidelity": "pattern",
+        "costSeconds": 1.0,
+    },
+    name="verificationBinding",
+)
+```
+
+The runner's `policy` decides which rungs execute. `all` (default) runs
+every rung and reports a verdict per rung, with the cross-rung `spread` as
+an honest error bar. `cheapest` runs only the lowest-cost rung per
+analysis. `escalate` runs the cheapest rungs, ranks must-requirements by
+margin thinness (`|margin| / |threshold|`), and spends the remaining
+`budget_s` escalating the thinnest to the next rung; those verdicts carry
+`escalated_from`. Every run records `seconds_by_fidelity`, so allocation
+claims are auditable.
+
+```bash
+sysml2kit verify model.json --policy escalate --budget-s 5 --report run.json
+```
+
+Validation rule S2K010 rejects two bindings on one analysis that share a
+fidelity label and warns when only some sibling bindings declare one.
+
 Over MCP, the `requirements_verify` tool runs the same flow with
-entry-point engines only, returning `passed`, must-failures, and the report
+entry-point engines only (plus `policy` and `budget_s` parameters),
+returning `passed`, must-failures, `seconds_by_fidelity`, and the report
 path.
 
 ## End to end with the RF library

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/pyproject.toml

@@ -1,6 +1,7 @@
 [build-system]
-# hatchling 1.32 emits Metadata-Version 2.5, which twine (and the release
-# pipeline's checks) do not accept yet; cap until the toolchain catches up.
+# hatchling 1.32 emits Metadata-Version 2.5. Current twine accepts it, but
+# the release pipeline's build-and-inspect action vendors an older twine
+# that rejects it (seen failing 2026-08-21); keep the cap until it updates.
 requires = ["hatchling>=1.27,<1.32", "hatch-vcs>=0.4"]
 build-backend = "hatchling.build"
 
@@ -48,7 +49,7 @@ dependencies = [
 [project.optional-dependencies]
 # sysmlpy has a single maintainer; cap the minor version and bump deliberately
 # after checking the release notes.
-parse = ["sysmlpy>=0.36.2,<0.37"]
+parse = ["sysmlpy>=0.36.3,<0.37"]
 graph = ["networkx>=3.2"]
 # mcp 2.0.0 removed mcp.server.fastmcp; stay on 1.x until the surface is ported.
 mcp = ["mcp>=1.26,<2"]
@@ -73,7 +74,7 @@ test = [
   "respx>=0.22",
 ]
 lint = ["mypy>=1.15", "ruff>=0.16", "types-PyYAML>=6.0"]
-parse-test = ["sysmlpy>=0.36.2,<0.37"]
+parse-test = ["sysmlpy>=0.36.3,<0.37"]
 mcp-test = ["mcp>=1.26,<2"]
 verify-test = ["pyyaml>=6.0"]
 docs = ["mkdocs-material>=9.5", "mkdocstrings[python]>=0.27"]

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/src/sysml2kit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/src/sysml2kit/api/client.py

@@ -9,6 +9,7 @@ hundred lines against the REST/JSON binding and returns sysml2kit models.
 from __future__ import annotations
 
 import types
+import uuid
 from typing import Any, Self
 
 import httpx
@@ -19,6 +20,9 @@ from sysml2kit.model.container import Model
 from .errors import ApiError
 from .models import Branch, Commit, Project
 
+#: Deterministic ids for pushed OwningMembership records.
+_MEMBERSHIP_NAMESPACE = uuid.UUID("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+
 
 class SysMLApiClient:
     """Synchronous client; use as a context manager to reuse one connection."""
@@ -140,18 +144,67 @@ class SysMLApiClient:
         branch: str | None = None,
         message: str | None = None,
     ) -> Commit:
-        """Create a commit whose change set inserts every element of the model."""
-        change = [
-            {"@type": "DataVersion", "payload": self._to_server_record(record)}
-            for record in model_to_json(model)
-        ]
+        """Push a model as one or two commits (elements, then ownership).
+
+        The pilot re-mints element ids and resolves references only against
+        already-committed rows, so ownership cannot ride along with the
+        elements. Each element therefore carries its local id in
+        ``aliasIds``; after the element commit, the aliases map local ids to
+        server-minted ids and a second commit adds one ``OwningMembership``
+        per ownership pair. A model without ownership pushes as a single
+        commit. The returned commit is the head (the membership commit when
+        one was needed).
+        """
+        change = []
+        for record in model_to_json(model):
+            adapted = self._to_server_record(record)
+            adapted["aliasIds"] = [record["@id"]]
+            change.append({"@type": "DataVersion", "payload": adapted})
         payload: dict[str, Any] = {"@type": "Commit", "change": change}
         if message:
             payload["description"] = message
         path = f"/projects/{project_id}/commits"
         if branch:
             path += f"?branchId={branch}"
-        return Commit.model_validate(self._post(path, payload))
+        element_commit = Commit.model_validate(self._post(path, payload))
+        if not model.owner:
+            return element_commit
+
+        minted: dict[str, str] = {}
+        listing = self._get(f"/projects/{project_id}/commits/{element_commit.id}/elements")
+        for summary in listing:
+            record = summary
+            if "aliasIds" not in record:
+                record = self.get_element(project_id, element_commit.id, summary["@id"])
+            for alias in record.get("aliasIds") or []:
+                minted[str(alias)] = record["@id"]
+
+        memberships = []
+        for member, owner in model.owner.items():
+            member_id, owner_id = minted.get(str(member)), minted.get(str(owner))
+            if member_id is None or owner_id is None:
+                continue  # e.g. an element the server rejected
+            memberships.append(
+                {
+                    "@type": "DataVersion",
+                    "payload": {
+                        "@type": "OwningMembership",
+                        "@id": str(uuid.uuid5(_MEMBERSHIP_NAMESPACE, f"{owner}->{member}")),
+                        "memberElement": {"@id": member_id},
+                        "membershipOwningNamespace": {"@id": owner_id},
+                    },
+                }
+            )
+        if not memberships:
+            return element_commit
+        ownership_payload: dict[str, Any] = {
+            "@type": "Commit",
+            "previousCommit": {"@id": element_commit.id},
+            "change": memberships,
+        }
+        if message:
+            ownership_payload["description"] = f"{message} (ownership)"
+        return Commit.model_validate(self._post(path, ownership_payload))
 
     def head_commit(self, project_id: str) -> Commit:
         """Return the newest commit of a project; raises ApiError when empty."""

{sysml2kit-0.3.0 → sysml2kit-0.4.0}/src/sysml2kit/api/models.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 
 class Project(BaseModel):
@@ -24,6 +24,14 @@ class Branch(BaseModel):
     name: str | None = None
     head: str | None = None
 
+    @field_validator("head", mode="before")
+    @classmethod
+    def _head_ref_to_id(cls, value: object) -> object:
+        # The pilot sends head as an identified ref: {"@id": "..."}.
+        if isinstance(value, dict):
+            return value.get("@id")
+        return value
+
 
 class Commit(BaseModel):
     """A commit within a project."""

sysml2kit-0.4.0/src/sysml2kit/backends/_sysmlpy_patches.py

@@ -0,0 +1,156 @@
+"""Runtime patches for sysmlpy's ANTLR visitor, applied under a version guard.
+
+Three upstream defects lose data before the raw dict exists; fixes are
+open upstream (mycr0ft/sysmlpy #6, #7, and #9, filed as issue #8). Until a
+release ships them, this module applies equivalent patches to
+``sysmlpy.antlr_visitor`` at backend import:
+
+- ``allocate X to Y`` endpoints reach the dict (a ``part`` connector, the
+  same key ``ConnectionUsage`` uses),
+- ``dependency [name] [from] A to B;`` statements are dispatched instead of
+  silently dropped,
+- braced metadata bodies surface their feature texts (``bodyFeatures``).
+
+Guards: only sysmlpy < 0.37, only when every patched attribute still looks
+as expected; any mismatch logs a warning and leaves sysmlpy untouched, in
+which case the documented pinned-loss behavior applies.
+"""
+
+from __future__ import annotations
+
+import logging
+from importlib import metadata
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_APPLIED_MARKER = "_sysml2kit_patched"
+
+
+def _dependency_dict(visitor: Any, ctx: Any, prefix: Any) -> dict[str, Any]:
+    decl = ctx
+    if hasattr(ctx, "dependencyDeclaration") and ctx.dependencyDeclaration():
+        decl = ctx.dependencyDeclaration()
+    identification = None
+    if hasattr(decl, "identification") and decl.identification():
+        identification = visitor._build_identification_dict(decl.identification())
+    clients: list[dict[str, Any]] = []
+    suppliers: list[dict[str, Any]] = []
+    after_to = False
+    for child in decl.getChildren():
+        class_name = child.__class__.__name__
+        if class_name == "QualifiedNameContext":
+            names = child.getText().split("::")
+            (suppliers if after_to else clients).append({"name": "QualifiedName", "names": names})
+        elif not after_to and hasattr(child, "getText") and child.getText() == "to":
+            after_to = True
+    return {
+        "name": "PackageMember",
+        "prefix": prefix,
+        "ownedRelatedElement": {
+            "name": "DefinitionElement",
+            "ownedRelatedElement": {
+                "name": "Dependency",
+                "identification": identification,
+                "client": clients,
+                "supplier": suppliers,
+                "body": {"name": "RelationshipBody", "ownedRelatedElement": []},
+            },
+        },
+    }
+
+
+def _find_node(tree: Any, name: str) -> dict[str, Any] | None:
+    if isinstance(tree, dict):
+        if tree.get("name") == name:
+            return tree
+        for key, value in tree.items():
+            if key != "name":
+                found = _find_node(value, name)
+                if found is not None:
+                    return found
+    elif isinstance(tree, list):
+        for item in tree:
+            found = _find_node(item, name)
+            if found is not None:
+                return found
+    return None
+
+
+def apply_patches() -> bool:
+    """Patch sysmlpy's visitor in place; returns whether patches are active."""
+    try:
+        import sysmlpy.antlr_visitor as visitor
+    except ImportError:
+        return False
+    if getattr(visitor, _APPLIED_MARKER, False):
+        return True
+    try:
+        version = metadata.version("sysmlpy")
+    except metadata.PackageNotFoundError:
+        version = "0"
+    if not version.startswith("0.3"):
+        logger.warning("sysmlpy %s outside the patch guard; pinned-loss behavior applies", version)
+        return False
+    required = (
+        "_make_allocation_usage_dict",
+        "_visit_definition_element_dict",
+        "_visit_metadata_feature_dict",
+        "_build_connector_part_dict",
+        "_build_identification_dict",
+    )
+    if not all(hasattr(visitor, attr) for attr in required):
+        logger.warning("sysmlpy visitor surface changed; skipping fidelity patches")
+        return False
+
+    original_allocation = visitor._make_allocation_usage_dict
+    original_definition_element = visitor._visit_definition_element_dict
+    original_metadata = visitor._visit_metadata_feature_dict
+
+    def patched_allocation(ctx: Any, prefix: Any = None) -> dict[str, Any]:
+        result: dict[str, Any] = original_allocation(ctx, prefix)
+        try:
+            aud = None
+            if (
+                ctx is not None
+                and hasattr(ctx, "allocationUsageDeclaration")
+                and ctx.allocationUsageDeclaration()
+            ):
+                aud = ctx.allocationUsageDeclaration()
+            if aud is not None and hasattr(aud, "connectorPart") and aud.connectorPart():
+                node = _find_node(result, "AllocationUsage")
+                if node is not None:
+                    node["part"] = visitor._build_connector_part_dict(aud.connectorPart())
+        except Exception:
+            logger.exception("allocate endpoint patch failed; endpoints dropped")
+        return result
+
+    def patched_definition_element(def_elem_ctx: Any, prefix: Any = None) -> Any:
+        try:
+            if hasattr(def_elem_ctx, "dependency") and def_elem_ctx.dependency():
+                return _dependency_dict(visitor, def_elem_ctx.dependency(), prefix)
+        except Exception:
+            logger.exception("dependency patch failed; statement dropped")
+        return original_definition_element(def_elem_ctx, prefix)
+
+    def patched_metadata(ctx: Any) -> dict[str, Any]:
+        result: dict[str, Any] = original_metadata(ctx)
+        try:
+            body = ctx.metadataBody() if hasattr(ctx, "metadataBody") else None
+            if body is not None and getattr(body, "LBRACE", lambda: None)():
+                texts = []
+                elements = body.metadataBodyElement()
+                for element in elements or []:
+                    texts.append(element.getText())
+                if texts:
+                    result["bodyFeatures"] = texts
+        except Exception:
+            logger.exception("metadata body patch failed; values dropped")
+        return result
+
+    visitor._make_allocation_usage_dict = patched_allocation
+    visitor._visit_definition_element_dict = patched_definition_element
+    visitor._visit_metadata_feature_dict = patched_metadata
+    setattr(visitor, _APPLIED_MARKER, True)
+    logger.info("sysmlpy %s fidelity patches active (upstream: mycr0ft/sysmlpy#6, #7, #9)", version)
+    return True