simplicio-loop 3.43.4__tar.gz → 3.43.6__tar.gz

{simplicio_loop-3.43.4/simplicio_loop.egg-info → simplicio_loop-3.43.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.43.4
+Version: 3.43.6
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License-Expression: MIT
@@ -27,6 +27,7 @@ Requires-Dist: simplicio-fast<3,>=2.0.28
 Requires-Dist: simplicio-prompt<1.15,>=1.14.3
 Requires-Dist: tiktoken<1,>=0.12.0
 Provides-Extra: dev
+Requires-Dist: setuptools>=77; extra == "dev"
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-cov>=4; extra == "dev"
 Requires-Dist: cryptography<50,>=42; extra == "dev"

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.43.4"
+version = "3.43.6"
 description = "The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime."
 readme = "PYPI.md"
 requires-python = ">=3.11"
@@ -43,7 +43,7 @@ dependencies = [
 # meaning retrieval. `pip install "simplicio-loop[ml]"`.
 [project.optional-dependencies]
 # Dev/test dependencies used by the local quality gate and secure-transport fixtures.
-dev = ["pytest>=7", "pytest-cov>=4", "cryptography>=42,<50", "jsonschema>=4,<5"]
+dev = ["setuptools>=77", "pytest>=7", "pytest-cov>=4", "cryptography>=42,<50", "jsonschema>=4,<5"]
 ml = ["model2vec>=0.3", "numpy>=1.21"]
 uvloop = ["uvloop>=0.19; platform_system != 'Windows'"]
 

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/simplicio_loop/__init__.py

@@ -13,6 +13,6 @@ try:
     try:
         __version__ = _v("simplicio-loop")
     except PackageNotFoundError:
-        __version__ = "3.43.4"
+        __version__ = "3.43.6"
 except Exception:  # pragma: no cover
-    __version__ = "3.43.4"
+    __version__ = "3.43.6"

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/simplicio_loop/stack_manifest.py

@@ -7,10 +7,12 @@ lower bounds when available so stack health does not drift from dependency pins.
 from __future__ import annotations
 
 import argparse
+import hashlib
 import importlib.metadata as metadata
 import json
 import re
 import shutil
+import subprocess
 import sys
 from pathlib import Path
 from typing import Any
@@ -30,7 +32,7 @@ _FALLBACK_FLOORS = {
     "simplicio-mapper": "0.26.26",
     "simplicio-fast": "2.0.28",
     "simplicio-cli": "0.18.10",
-    "simplicio-loop": "3.43.4",
+    "simplicio-loop": "3.43.6",
 }
 
 # These are operator identities, not distribution names.  ``simplicio-dev-cli``
@@ -42,6 +44,20 @@ REQUIRED_OPERATOR_BINDINGS = (
     ("simplicio-dev-cli", "simplicio-cli", "simplicio-dev-cli"),
 )
 
+MAPPER_VERSION_SCHEMA = "simplicio.mapper-version/v1"
+REQUIRED_MAPPER_CAPABILITIES = (
+    "simplicio.mapper-artifacts/v1",
+    "simplicio.precedent-index/v1",
+    "simplicio.context-snapshot/v1",
+    "simplicio.plugin.context-handle/v2",
+)
+REQUIRED_MAPPER_PROTOCOLS = (
+    "simplicio.component-release/v1",
+    "simplicio.execution-context/v1",
+    "simplicio.canonical-map/v1",
+)
+MAX_MAPPER_VERSION_OUTPUT_BYTES = 131_072
+
 _REQUIREMENT_NAME = re.compile(r"^\s*([A-Za-z0-9_.-]+)")
 
 
@@ -152,6 +168,114 @@ def operator_bindings() -> list[dict[str, Any]]:
     return bindings
 
 
+def _sha256_file(path: str | Path) -> str | None:
+    candidate = Path(path)
+    if not candidate.is_file():
+        return None
+    digest = hashlib.sha256()
+    try:
+        with candidate.open("rb") as handle:
+            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                digest.update(chunk)
+    except OSError:
+        return None
+    return "sha256:" + digest.hexdigest()
+
+
+def _mapper_identity(binding: dict[str, Any], *, timeout_seconds: float = 10.0) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "status": "blocked",
+        "reason_code": "mapper-entrypoint-not-ready",
+        "requested": binding.get("dependency_spec", ""),
+        "selected": binding.get("installed"),
+        "distribution": binding.get("distribution", "simplicio-mapper"),
+        "entrypoint": binding.get("entrypoint", "simplicio-mapper"),
+        "entrypoint_owner_verified": bool(binding.get("entrypoint_declared")),
+        "executable": binding.get("resolved", ""),
+        "executable_sha256": None,
+        "artifact_digest": None,
+        "version_receipt_schema": None,
+        "capabilities": [],
+        "protocols": [],
+        "capability_result": "unverified",
+        "source": "installed distribution metadata plus simplicio-mapper version --json",
+    }
+    if binding.get("status") != "ok":
+        result["reason_code"] = "mapper-" + str(binding.get("status") or "entrypoint-not-ready")
+        return result
+
+    executable = str(binding.get("resolved") or "")
+    expected_executable = Path(sys.argv[0]).absolute().parent / str(result["entrypoint"])
+    result["expected_executable"] = str(expected_executable) if expected_executable.is_file() else None
+    if expected_executable.is_file() and Path(executable).resolve() != expected_executable.resolve():
+        result["reason_code"] = "mapper-entrypoint-stale-path"
+        return result
+    result["executable_sha256"] = _sha256_file(executable)
+    if result["executable_sha256"] is None:
+        result["reason_code"] = "mapper-executable-unreadable"
+        return result
+
+    try:
+        completed = subprocess.run(
+            [executable, "version", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=timeout_seconds,
+            check=False,
+        )
+    except subprocess.TimeoutExpired:
+        result["reason_code"] = "mapper-version-timeout"
+        return result
+    except OSError:
+        result["reason_code"] = "mapper-version-exec-failed"
+        return result
+
+    stdout = completed.stdout or ""
+    if len(stdout.encode("utf-8")) > MAX_MAPPER_VERSION_OUTPUT_BYTES:
+        result["reason_code"] = "mapper-version-output-too-large"
+        return result
+    if completed.returncode != 0:
+        result["reason_code"] = "mapper-version-nonzero-exit"
+        return result
+    try:
+        receipt = json.loads(stdout)
+    except (TypeError, ValueError):
+        result["reason_code"] = "mapper-version-invalid-json"
+        return result
+    if not isinstance(receipt, dict) or receipt.get("schema") != MAPPER_VERSION_SCHEMA:
+        result["reason_code"] = "mapper-version-schema-invalid"
+        return result
+
+    result["version_receipt_schema"] = receipt.get("schema")
+    result["artifact_digest"] = receipt.get("artifact_digest")
+    result["capabilities"] = sorted(str(item) for item in receipt.get("capabilities", []) if item)
+    result["protocols"] = sorted(str(item) for item in receipt.get("protocols", []) if item)
+    if receipt.get("component") != "simplicio-mapper":
+        result["reason_code"] = "mapper-component-mismatch"
+        return result
+    if receipt.get("version") != binding.get("installed"):
+        result["reason_code"] = "mapper-version-mismatch"
+        return result
+    if not isinstance(result["artifact_digest"], str) or not result["artifact_digest"].startswith("sha256:"):
+        result["reason_code"] = "mapper-artifact-digest-missing"
+        return result
+    missing = sorted(set(REQUIRED_MAPPER_CAPABILITIES) - set(result["capabilities"]))
+    if missing:
+        result["missing_capabilities"] = missing
+        result["reason_code"] = "mapper-capabilities-missing"
+        return result
+    missing_protocols = sorted(set(REQUIRED_MAPPER_PROTOCOLS) - set(result["protocols"]))
+    if missing_protocols:
+        result["missing_protocols"] = missing_protocols
+        result["reason_code"] = "mapper-protocols-missing"
+        return result
+
+    result["status"] = "ok"
+    result["reason_code"] = "mapper-identity-verified"
+    result["capability_result"] = "compatible"
+    return result
+
+
 def _installed_version(distribution: str) -> str | None:
     try:
         return metadata.version(distribution)
@@ -223,34 +347,48 @@ def stack_manifest() -> dict[str, Any]:
     drifted = []
     for distribution, role, expected in _train_components():
         installed = _installed_version(distribution)
-        # Healthy when installed meets the train floor (at floor or newer patch/minor).
         status = "ok"
+        reason_code = "component-version-compatible"
         if installed is None:
             status = "missing-or-drifted"
+            reason_code = "component-distribution-missing"
         elif installed != expected:
             inst_t = _version_tuple(installed)
             exp_t = _version_tuple(expected)
             if inst_t is None or exp_t is None or inst_t < exp_t:
                 status = "missing-or-drifted"
+                reason_code = "component-version-below-floor"
         components.append({
             "distribution": distribution,
             "role": role,
             "expected": expected,
             "installed": installed,
             "status": status,
+            "reason_code": reason_code,
         })
         if status != "ok":
             drifted.append(distribution)
     bindings = operator_bindings()
     binding_drift = [item["operator"] for item in bindings if item["status"] != "ok"]
-    missing_or_drifted = list(dict.fromkeys([*drifted, *binding_drift]))
+    mapper_binding = next(
+        (item for item in bindings if item["operator"] == "simplicio-mapper"),
+        {"operator": "simplicio-mapper", "status": "entrypoint-not-declared"},
+    )
+    mapper_identity = _mapper_identity(mapper_binding)
+    identity_drift = (
+        ["simplicio-mapper-identity"]
+        if mapper_binding.get("status") == "ok" and mapper_identity["status"] != "ok"
+        else []
+    )
+    missing_or_drifted = list(dict.fromkeys([*drifted, *binding_drift, *identity_drift]))
     return {
         "schema": STACK_SCHEMA,
         "version": 1,
         "package": "simplicio-loop",
         "components": components,
         "operator_bindings": bindings,
-        "operator_contract_healthy": not binding_drift,
+        "mapper_identity": mapper_identity,
+        "operator_contract_healthy": not binding_drift and not identity_drift,
         "healthy": not missing_or_drifted,
         "missing_or_drifted": missing_or_drifted,
         "source": "pyproject.toml or installed Requires-Dist metadata",

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6/simplicio_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.43.4
+Version: 3.43.6
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (7 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License-Expression: MIT
@@ -27,6 +27,7 @@ Requires-Dist: simplicio-fast<3,>=2.0.28
 Requires-Dist: simplicio-prompt<1.15,>=1.14.3
 Requires-Dist: tiktoken<1,>=0.12.0
 Provides-Extra: dev
+Requires-Dist: setuptools>=77; extra == "dev"
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-cov>=4; extra == "dev"
 Requires-Dist: cryptography<50,>=42; extra == "dev"

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/simplicio_loop.egg-info/SOURCES.txt

@@ -800,6 +800,7 @@ tests/test_recovery_unit.py
 tests/test_release_check_unit.py
 tests/test_release_manifest_unit.py
 tests/test_release_rehearsal_integration.py
+tests/test_release_train_contract_metadata.py
 tests/test_release_train_doctor_558.py
 tests/test_release_train_engine.py
 tests/test_release_train_reconciler_558.py

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/simplicio_loop.egg-info/requires.txt

@@ -5,6 +5,7 @@ simplicio-prompt<1.15,>=1.14.3
 tiktoken<1,>=0.12.0
 
 [dev]
+setuptools>=77
 pytest>=7
 pytest-cov>=4
 cryptography<50,>=42

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/tests/test_prism_integrity_851.py

@@ -72,7 +72,7 @@ def test_version_fallback_drift_is_blocked(tmp_path):
     repo = fixture_repo(tmp_path)
     package = repo / "simplicio_loop" / "__init__.py"
     package.write_text(
-        package.read_text(encoding="utf-8").replace("3.43.4", "9.9.9"),
+        package.read_text(encoding="utf-8").replace("3.43.5", "9.9.9"),
         encoding="utf-8",
     )
     report = evaluate(repo)

simplicio_loop-3.43.6/tests/test_release_train_contract_metadata.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import json
+import tomllib
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_active_release_train_contract_matches_project_version() -> None:
+    contract = json.loads(
+        (ROOT / "docs" / "release-train" / "compatibility-contract.json").read_text(encoding="utf-8")
+    )
+    project = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))
+    version = project["project"]["version"]
+    assert contract["schema"] == "simplicio.release-train.compatibility/v1"
+    assert contract["release_train_version"] == f"v{version}"
+    assert contract["evidence_policy"] == "measured manifests only; missing or invalid is blocked/unverified"
+
+
+def test_active_contract_names_the_loop_train_components() -> None:
+    contract = json.loads(
+        (ROOT / "docs" / "release-train" / "compatibility-contract.json").read_text(encoding="utf-8")
+    )
+    assert {"loop", "mapper", "dev-cli", "fast"} <= set(contract["components"])
+    assert set(contract["allowed_states"]) == {"MEASURED", "BLOCKED", "UNVERIFIED"}

simplicio_loop-3.43.6/tests/test_stack_manifest.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import subprocess
+import tomllib
+from pathlib import Path
+
+from simplicio_loop import stack_manifest as manifest
+
+
+ROOT = Path(__file__).parents[1]
+
+
+def test_loop_declares_both_required_operator_distributions_directly() -> None:
+    project = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))["project"]
+    dependencies = manifest._dependency_specs_from_pyproject(
+        (ROOT / "pyproject.toml").read_text(encoding="utf-8")
+    )
+    assert "simplicio-mapper" in dependencies
+    assert "simplicio-cli" in dependencies
+    assert "simplicio-dev-cli" not in {
+        str(spec).split(";", 1)[0].split(">", 1)[0].split("<", 1)[0].strip()
+        for spec in project["dependencies"]
+    }
+
+
+def test_stack_manifest_proves_operator_distribution_and_entrypoint_ownership(monkeypatch) -> None:
+    monkeypatch.setattr(
+        manifest,
+        "_declared_dependency_specs",
+        lambda: {"simplicio-mapper": "simplicio-mapper>=1.0", "simplicio-cli": "simplicio-cli>=1.0"},
+    )
+    monkeypatch.setattr(manifest, "_installed_version", lambda _name: "1.0.0")
+    monkeypatch.setattr(
+        manifest,
+        "_console_entrypoint_owners",
+        lambda: {
+            "simplicio-mapper": {"simplicio-mapper"},
+            "simplicio-cli": {"simplicio-dev-cli"},
+        },
+    )
+    monkeypatch.setattr(manifest.shutil, "which", lambda name: "/bin/" + name)
+    monkeypatch.setattr(manifest, "_train_components", lambda: [("simplicio-loop", "run", "1.0.0")])
+    monkeypatch.setattr(
+        manifest,
+        "_mapper_identity",
+        lambda _binding: {"status": "ok", "reason_code": "mapper-identity-verified"},
+    )
+
+    report = manifest.stack_manifest()
+
+    assert report["healthy"] is True
+    assert report["operator_contract_healthy"] is True
+    bindings = {item["operator"]: item for item in report["operator_bindings"]}
+    assert bindings["simplicio-mapper"]["status"] == "ok"
+    assert bindings["simplicio-dev-cli"]["distribution"] == "simplicio-cli"
+    assert bindings["simplicio-dev-cli"]["entrypoint_declared"] is True
+
+
+def test_stack_manifest_fails_when_mapper_dependency_or_dev_cli_entrypoint_is_missing(monkeypatch) -> None:
+    monkeypatch.setattr(manifest, "_declared_dependency_specs", lambda: {"simplicio-cli": "simplicio-cli>=1.0"})
+    monkeypatch.setattr(manifest, "_installed_version", lambda _name: "1.0.0")
+    monkeypatch.setattr(
+        manifest,
+        "_console_entrypoint_owners",
+        lambda: {"simplicio-cli": set()},
+    )
+    monkeypatch.setattr(manifest.shutil, "which", lambda _name: None)
+    monkeypatch.setattr(manifest, "_train_components", lambda: [("simplicio-loop", "run", "1.0.0")])
+
+    report = manifest.stack_manifest()
+
+    bindings = {item["operator"]: item for item in report["operator_bindings"]}
+    assert report["healthy"] is False
+    assert report["operator_contract_healthy"] is False
+    assert bindings["simplicio-mapper"]["status"] == "dependency-not-declared"
+    assert bindings["simplicio-dev-cli"]["status"] == "entrypoint-not-declared"
+    assert set(report["missing_or_drifted"]) == {"simplicio-mapper", "simplicio-dev-cli"}
+
+
+def _mapper_binding(executable: Path) -> dict[str, object]:
+    return {
+        "status": "ok",
+        "dependency_spec": "simplicio-mapper>=0.26.26,<0.27",
+        "installed": "0.26.26",
+        "distribution": "simplicio-mapper",
+        "entrypoint": "simplicio-mapper",
+        "entrypoint_declared": True,
+        "resolved": str(executable),
+    }
+
+
+def _mapper_receipt(**updates: object) -> dict[str, object]:
+    receipt: dict[str, object] = {
+        "schema": manifest.MAPPER_VERSION_SCHEMA,
+        "component": "simplicio-mapper",
+        "version": "0.26.26",
+        "artifact_digest": "sha256:" + "a" * 64,
+        "capabilities": list(manifest.REQUIRED_MAPPER_CAPABILITIES),
+        "protocols": list(manifest.REQUIRED_MAPPER_PROTOCOLS),
+    }
+    receipt.update(updates)
+    return receipt
+
+
+def test_mapper_identity_proves_selected_artifact_executable_and_capabilities(
+    monkeypatch, tmp_path: Path
+) -> None:
+    executable = tmp_path / "simplicio-mapper"
+    executable.write_bytes(b"mapper executable")
+    completed = subprocess.CompletedProcess(
+        args=[str(executable), "version", "--json"],
+        returncode=0,
+        stdout=json.dumps(_mapper_receipt()),
+        stderr="",
+    )
+    monkeypatch.setattr(manifest.subprocess, "run", lambda *args, **kwargs: completed)
+
+    identity = manifest._mapper_identity(_mapper_binding(executable))
+
+    assert identity["status"] == "ok"
+    assert identity["reason_code"] == "mapper-identity-verified"
+    assert identity["requested"] == "simplicio-mapper>=0.26.26,<0.27"
+    assert identity["selected"] == "0.26.26"
+    assert identity["artifact_digest"] == "sha256:" + "a" * 64
+    assert identity["executable_sha256"] == "sha256:" + hashlib.sha256(
+        b"mapper executable"
+    ).hexdigest()
+    assert identity["capability_result"] == "compatible"
+
+
+def test_mapper_identity_fails_closed_on_invalid_json(monkeypatch, tmp_path: Path) -> None:
+    executable = tmp_path / "simplicio-mapper"
+    executable.write_bytes(b"mapper executable")
+    completed = subprocess.CompletedProcess(
+        args=[str(executable), "version", "--json"],
+        returncode=0,
+        stdout="not-json",
+        stderr="sensitive detail is not returned",
+    )
+    monkeypatch.setattr(manifest.subprocess, "run", lambda *args, **kwargs: completed)
+
+    identity = manifest._mapper_identity(_mapper_binding(executable))
+
+    assert identity["status"] == "blocked"
+    assert identity["reason_code"] == "mapper-version-invalid-json"
+    assert "stderr" not in identity
+
+
+def test_mapper_identity_fails_closed_on_missing_capability(monkeypatch, tmp_path: Path) -> None:
+    executable = tmp_path / "simplicio-mapper"
+    executable.write_bytes(b"mapper executable")
+    capabilities = list(manifest.REQUIRED_MAPPER_CAPABILITIES[:-1])
+    completed = subprocess.CompletedProcess(
+        args=[str(executable), "version", "--json"],
+        returncode=0,
+        stdout=json.dumps(_mapper_receipt(capabilities=capabilities)),
+        stderr="",
+    )
+    monkeypatch.setattr(manifest.subprocess, "run", lambda *args, **kwargs: completed)
+
+    identity = manifest._mapper_identity(_mapper_binding(executable))
+
+    assert identity["status"] == "blocked"
+    assert identity["reason_code"] == "mapper-capabilities-missing"
+    assert identity["missing_capabilities"] == [manifest.REQUIRED_MAPPER_CAPABILITIES[-1]]
+
+
+def test_mapper_identity_bounds_output_and_timeout(monkeypatch, tmp_path: Path) -> None:
+    executable = tmp_path / "simplicio-mapper"
+    executable.write_bytes(b"mapper executable")
+    oversized = subprocess.CompletedProcess(
+        args=[str(executable), "version", "--json"],
+        returncode=0,
+        stdout="x" * (manifest.MAX_MAPPER_VERSION_OUTPUT_BYTES + 1),
+        stderr="",
+    )
+    monkeypatch.setattr(manifest.subprocess, "run", lambda *args, **kwargs: oversized)
+    identity = manifest._mapper_identity(_mapper_binding(executable))
+    assert identity["reason_code"] == "mapper-version-output-too-large"
+
+    def raise_timeout(*args, **kwargs):
+        raise subprocess.TimeoutExpired(cmd=args[0], timeout=kwargs["timeout"])
+
+    monkeypatch.setattr(manifest.subprocess, "run", raise_timeout)
+    identity = manifest._mapper_identity(_mapper_binding(executable))
+    assert identity["reason_code"] == "mapper-version-timeout"

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/tests/test_submodules.py

@@ -90,6 +90,29 @@ class SubmoduleContracts(unittest.TestCase):
                 subprocess.run(["git", "-C", str(component), "commit", "--allow-empty", "-qm", "divergence"], check=True)
                 self.assertEqual(submodules.inspect()["components"]["simplicio-fast"]["state"], "diverged")
 
+    def test_uninitialized_and_foreign_checkouts_never_use_parent_head(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            subprocess.run(["git", "init", "-q", str(root)], check=True)
+            uninitialized = root / "components" / "simplicio-mapper"
+            uninitialized.mkdir(parents=True)
+            with mock.patch.object(submodules, "REPO", root):
+                report = submodules._path_status(uninitialized, "0" * 40)
+            self.assertEqual(report["state"], "uninitialized")
+            self.assertIsNone(report["observed_sha"])
+
+            foreign_repo = root / "foreign"
+            subprocess.run(["git", "init", "-q", str(foreign_repo)], check=True)
+            foreign_checkout = root / "components" / "simplicio-fast"
+            foreign_checkout.mkdir(parents=True)
+            (foreign_checkout / ".git").write_text(
+                f"gitdir: {foreign_repo / '.git'}\n", encoding="utf-8"
+            )
+            with mock.patch.object(submodules, "REPO", root):
+                report = submodules._path_status(foreign_checkout, "0" * 40)
+            self.assertEqual(report["state"], "wrong_repository")
+            self.assertIsNone(report["observed_sha"])
+
     def test_run_manifest_requires_verified_checkout(self):
         with tempfile.TemporaryDirectory() as directory:
             destination = Path(directory) / "run.json"

{simplicio_loop-3.43.4 → simplicio_loop-3.43.6}/tests/test_version_sync_unit.py

@@ -55,6 +55,16 @@ def _make_repo(tmp_path, version="1.2.3", npm_version="1.2.3", plugin_version="1
         f'    __version__ = "{fallback_version}"\n',
         encoding="utf-8",
     )
+    (pkg_dir / "stack_manifest.py").write_text(
+        '_FALLBACK_FLOORS = {\n    "simplicio-loop": "' + fallback_version + '",\n}\n',
+        encoding="utf-8",
+    )
+    release_train = repo / "docs" / "release-train"
+    release_train.mkdir(parents=True)
+    (release_train / "compatibility-contract.json").write_text(
+        json.dumps({"release_train_version": f"v{version}"}, indent=2) + "\n",
+        encoding="utf-8",
+    )
     return repo
 
 
@@ -92,11 +102,20 @@ def test_apply_rewrites_every_surface_and_leaves_manifest_ready(tmp_path):
         os.path.join("packaging", "npm", "package.json"),
         os.path.join(".cursor-plugin", "plugin.json"),
         os.path.join("simplicio_loop", "__init__.py"),
+        os.path.join("simplicio_loop", "stack_manifest.py"),
+        os.path.join("docs", "release-train", "compatibility-contract.json"),
     }
     assert 'version = "9.9.9"' in (repo / "pyproject.toml").read_text(encoding="utf-8")
     assert json.loads((repo / "packaging" / "npm" / "package.json").read_text())["version"] == "9.9.9"
     assert json.loads((repo / ".cursor-plugin" / "plugin.json").read_text())["version"] == "9.9.9"
     assert '__version__ = "9.9.9"' in (repo / "simplicio_loop" / "__init__.py").read_text(encoding="utf-8")
+    assert '"simplicio-loop": "9.9.9"' in (
+        repo / "simplicio_loop" / "stack_manifest.py"
+    ).read_text(encoding="utf-8")
+    release_train = json.loads(
+        (repo / "docs" / "release-train" / "compatibility-contract.json").read_text()
+    )
+    assert release_train["release_train_version"] == "v9.9.9"
 
 
 def test_apply_preserves_unrelated_json_formatting_and_unicode_escapes(tmp_path):

simplicio_loop-3.43.4/tests/test_stack_manifest.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-import tomllib
-from pathlib import Path
-
-from simplicio_loop import stack_manifest as manifest
-
-
-ROOT = Path(__file__).parents[1]
-
-
-def test_loop_declares_both_required_operator_distributions_directly() -> None:
-    project = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))["project"]
-    dependencies = manifest._dependency_specs_from_pyproject(
-        (ROOT / "pyproject.toml").read_text(encoding="utf-8")
-    )
-    assert "simplicio-mapper" in dependencies
-    assert "simplicio-cli" in dependencies
-    assert "simplicio-dev-cli" not in {
-        str(spec).split(";", 1)[0].split(">", 1)[0].split("<", 1)[0].strip()
-        for spec in project["dependencies"]
-    }
-
-
-def test_stack_manifest_proves_operator_distribution_and_entrypoint_ownership(monkeypatch) -> None:
-    monkeypatch.setattr(
-        manifest,
-        "_declared_dependency_specs",
-        lambda: {"simplicio-mapper": "simplicio-mapper>=1.0", "simplicio-cli": "simplicio-cli>=1.0"},
-    )
-    monkeypatch.setattr(manifest, "_installed_version", lambda _name: "1.0.0")
-    monkeypatch.setattr(
-        manifest,
-        "_console_entrypoint_owners",
-        lambda: {
-            "simplicio-mapper": {"simplicio-mapper"},
-            "simplicio-cli": {"simplicio-dev-cli"},
-        },
-    )
-    monkeypatch.setattr(manifest.shutil, "which", lambda name: "/bin/" + name)
-    monkeypatch.setattr(manifest, "_train_components", lambda: [("simplicio-loop", "run", "1.0.0")])
-
-    report = manifest.stack_manifest()
-
-    assert report["healthy"] is True
-    assert report["operator_contract_healthy"] is True
-    bindings = {item["operator"]: item for item in report["operator_bindings"]}
-    assert bindings["simplicio-mapper"]["status"] == "ok"
-    assert bindings["simplicio-dev-cli"]["distribution"] == "simplicio-cli"
-    assert bindings["simplicio-dev-cli"]["entrypoint_declared"] is True
-
-
-def test_stack_manifest_fails_when_mapper_dependency_or_dev_cli_entrypoint_is_missing(monkeypatch) -> None:
-    monkeypatch.setattr(manifest, "_declared_dependency_specs", lambda: {"simplicio-cli": "simplicio-cli>=1.0"})
-    monkeypatch.setattr(manifest, "_installed_version", lambda _name: "1.0.0")
-    monkeypatch.setattr(
-        manifest,
-        "_console_entrypoint_owners",
-        lambda: {"simplicio-cli": set()},
-    )
-    monkeypatch.setattr(manifest.shutil, "which", lambda _name: None)
-    monkeypatch.setattr(manifest, "_train_components", lambda: [("simplicio-loop", "run", "1.0.0")])
-
-    report = manifest.stack_manifest()
-
-    bindings = {item["operator"]: item for item in report["operator_bindings"]}
-    assert report["healthy"] is False
-    assert report["operator_contract_healthy"] is False
-    assert bindings["simplicio-mapper"]["status"] == "dependency-not-declared"
-    assert bindings["simplicio-dev-cli"]["status"] == "entrypoint-not-declared"
-    assert set(report["missing_or_drifted"]) == {"simplicio-mapper", "simplicio-dev-cli"}