ssot-conformance 0.2.15__tar.gz

ssot_conformance-0.2.15/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: ssot-conformance
+Version: 0.2.15
+Summary: Reusable SSOT conformance harness, pytest plugin, and scaffold helpers.
+Author-email: Jacob Stewart <jacob@swarmauri.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/groupsum/ssot-registry/tree/main/pkgs/ssot-conformance
+Project-URL: Repository, https://github.com/groupsum/ssot-registry/tree/main/pkgs/ssot-conformance
+Project-URL: Issues, https://github.com/groupsum/ssot-registry/issues
+Keywords: ssot,conformance,pytest,governance,validation,scaffold
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Plugins
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ssot-core==0.2.15
+Requires-Dist: ssot-contracts==0.2.15
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
+
+<div align="center">
+  <h1>🔷 ssot-conformance</h1>
+  <p><strong>Reusable SSOT conformance harness for downstream repositories.</strong></p>
+</div>
+
+<div align="center">
+  <a href="https://pypi.org/project/ssot-conformance/"><img src="https://img.shields.io/pypi/v/ssot-conformance?label=PyPI%20version" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/ssot-conformance/"><img src="https://img.shields.io/pypi/pyversions/ssot-conformance?label=Python" alt="Supported Python versions" /></a>
+  <a href="https://pepy.tech/project/ssot-conformance"><img src="https://static.pepy.tech/badge/ssot-conformance" alt="Downloads" /></a>
+  <a href="https://hits.sh/github.com/groupsum/ssot-registry/"><img src="https://hits.sh/github.com/groupsum/ssot-registry.svg?style=flat-square" alt="Repository hits" /></a>
+</div>
+
+Reusable SSOT conformance harness for downstream repositories.
+
+This package provides:
+
+- portable conformance case families grouped by registry, document, id, SPEC-to-ADR, feature-to-SPEC, proof-chain, and boundary/release concerns
+- a `pytest` plugin entry point for repo-root selection, case-family filtering, and evidence-output emission
+- scaffold helpers that can compute and optionally create missing conformance SSOT rows
+- machine-readable evidence output suitable for later SSOT evidence ingestion and status synchronization
+
+The package is intentionally repo-agnostic. It evaluates a target repository through `.ssot` artifacts and registry semantics rather than assuming a specific implementation language for the target system.
+
+## Install
+
+```bash
+python -m pip install ssot-conformance
+```
+
+For local development from this repository:
+
+```bash
+python -m pip install -e pkgs/ssot-conformance
+```
+
+## Execution model
+
+Packaged `ssot-core` conformance remains pytest-based, but the operator-facing execution model is registry-driven:
+
+- packaged conformance rows store executable `tests[].execution` metadata
+- `ssot conformance run` resolves governed conformance tests and runs those stored commands
+- downstream repos can use the same `tests[].execution` contract for arbitrary command-backed suites
+
+For direct SSOT entity execution, prefer:
+
+```text
+ssot test run . --id tst:pytest.conformance.registry-contract
+ssot spec run-tests . --id spc:0525
+ssot boundary run-tests . --id bnd:full-cert
+```
+
+## Package relationships
+
+- Package type: reusable conformance and pytest plugin package
+- Depends on: [ssot-core](https://pypi.org/project/ssot-core/), [ssot-contracts](https://pypi.org/project/ssot-contracts/)
+- Consumed by: [ssot-cli](https://pypi.org/project/ssot-cli/) and downstream repositories that run packaged SSOT conformance checks
+
+If you need the CLI wrapper for these checks, install [ssot-cli](https://pypi.org/project/ssot-cli/). If you need to embed or run the reusable conformance cases directly, this is the package to install.

ssot_conformance-0.2.15/README.md

@@ -0,0 +1,58 @@
+<div align="center">
+  <h1>🔷 ssot-conformance</h1>
+  <p><strong>Reusable SSOT conformance harness for downstream repositories.</strong></p>
+</div>
+
+<div align="center">
+  <a href="https://pypi.org/project/ssot-conformance/"><img src="https://img.shields.io/pypi/v/ssot-conformance?label=PyPI%20version" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/ssot-conformance/"><img src="https://img.shields.io/pypi/pyversions/ssot-conformance?label=Python" alt="Supported Python versions" /></a>
+  <a href="https://pepy.tech/project/ssot-conformance"><img src="https://static.pepy.tech/badge/ssot-conformance" alt="Downloads" /></a>
+  <a href="https://hits.sh/github.com/groupsum/ssot-registry/"><img src="https://hits.sh/github.com/groupsum/ssot-registry.svg?style=flat-square" alt="Repository hits" /></a>
+</div>
+
+Reusable SSOT conformance harness for downstream repositories.
+
+This package provides:
+
+- portable conformance case families grouped by registry, document, id, SPEC-to-ADR, feature-to-SPEC, proof-chain, and boundary/release concerns
+- a `pytest` plugin entry point for repo-root selection, case-family filtering, and evidence-output emission
+- scaffold helpers that can compute and optionally create missing conformance SSOT rows
+- machine-readable evidence output suitable for later SSOT evidence ingestion and status synchronization
+
+The package is intentionally repo-agnostic. It evaluates a target repository through `.ssot` artifacts and registry semantics rather than assuming a specific implementation language for the target system.
+
+## Install
+
+```bash
+python -m pip install ssot-conformance
+```
+
+For local development from this repository:
+
+```bash
+python -m pip install -e pkgs/ssot-conformance
+```
+
+## Execution model
+
+Packaged `ssot-core` conformance remains pytest-based, but the operator-facing execution model is registry-driven:
+
+- packaged conformance rows store executable `tests[].execution` metadata
+- `ssot conformance run` resolves governed conformance tests and runs those stored commands
+- downstream repos can use the same `tests[].execution` contract for arbitrary command-backed suites
+
+For direct SSOT entity execution, prefer:
+
+```text
+ssot test run . --id tst:pytest.conformance.registry-contract
+ssot spec run-tests . --id spc:0525
+ssot boundary run-tests . --id bnd:full-cert
+```
+
+## Package relationships
+
+- Package type: reusable conformance and pytest plugin package
+- Depends on: [ssot-core](https://pypi.org/project/ssot-core/), [ssot-contracts](https://pypi.org/project/ssot-contracts/)
+- Consumed by: [ssot-cli](https://pypi.org/project/ssot-cli/) and downstream repositories that run packaged SSOT conformance checks
+
+If you need the CLI wrapper for these checks, install [ssot-cli](https://pypi.org/project/ssot-cli/). If you need to embed or run the reusable conformance cases directly, this is the package to install.

ssot_conformance-0.2.15/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ssot-conformance"
+version = "0.2.15"
+description = "Reusable SSOT conformance harness, pytest plugin, and scaffold helpers."
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+license = "Apache-2.0"
+authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+dependencies = [
+  "ssot-core==0.2.15",
+  "ssot-contracts==0.2.15",
+  "tomli>=2.0.1; python_version < '3.11'",
+]
+keywords = ["ssot", "conformance", "pytest", "governance", "validation", "scaffold"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Plugins",
+  "Framework :: Pytest",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Information Technology",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Quality Assurance",
+  "Topic :: Software Development :: Testing",
+  "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/groupsum/ssot-registry/tree/main/pkgs/ssot-conformance"
+Repository = "https://github.com/groupsum/ssot-registry/tree/main/pkgs/ssot-conformance"
+Issues = "https://github.com/groupsum/ssot-registry/issues"
+
+[project.entry-points.pytest11]
+ssot-conformance = "ssot_conformance.plugin"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

ssot_conformance-0.2.15/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ssot_conformance-0.2.15/src/ssot_conformance/__init__.py

@@ -0,0 +1,27 @@
+from .catalog import CATALOG_VERSION, build_catalog_slice, list_profiles, resolve_selected_families
+from .discovery import discover_cases
+from .evidence import build_evidence_output, write_evidence_output
+
+
+def plan_scaffold(*args, **kwargs):
+    from .scaffold import plan_scaffold as _plan_scaffold
+
+    return _plan_scaffold(*args, **kwargs)
+
+
+def apply_scaffold(*args, **kwargs):
+    from .scaffold import apply_scaffold as _apply_scaffold
+
+    return _apply_scaffold(*args, **kwargs)
+
+__all__ = [
+    "CATALOG_VERSION",
+    "build_catalog_slice",
+    "list_profiles",
+    "resolve_selected_families",
+    "discover_cases",
+    "build_evidence_output",
+    "write_evidence_output",
+    "plan_scaffold",
+    "apply_scaffold",
+]

ssot_conformance-0.2.15/src/ssot_conformance/cases/__init__.py

@@ -0,0 +1 @@
+"""Portable SSOT conformance case families."""

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_boundary_release_contract.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+CONFORMANCE_FAMILY = "boundary-release"
+
+
+def test_boundary_release_contract(ssot_registry) -> None:
+    features = {row["id"] for row in ssot_registry["features"]}
+    claims = {row["id"] for row in ssot_registry["claims"]}
+    evidence = {row["id"] for row in ssot_registry["evidence"]}
+    boundaries = {row["id"]: row for row in ssot_registry["boundaries"]}
+    for boundary in boundaries.values():
+        for feature_id in boundary.get("feature_ids", []):
+            assert feature_id in features, (boundary["id"], feature_id)
+    for release in ssot_registry["releases"]:
+        assert release["boundary_id"] in boundaries, release["id"]
+        for boundary_id in release.get("boundary_ids", [release["boundary_id"]]):
+            assert boundary_id in boundaries, (release["id"], boundary_id)
+        for claim_id in release.get("claim_ids", []):
+            assert claim_id in claims, (release["id"], claim_id)
+        for evidence_id in release.get("evidence_ids", []):
+            assert evidence_id in evidence, (release["id"], evidence_id)

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_document_contract.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+CONFORMANCE_FAMILY = "document"
+
+
+def test_document_contract(ssot_repo_root, ssot_registry) -> None:
+    for section in ("adrs", "specs"):
+        for row in ssot_registry[section]:
+            path = Path(ssot_repo_root) / row["path"]
+            assert path.exists(), row["id"]
+            if row["origin"] == "repo-local":
+                assert row["number"] >= 1000, row["id"]
+            else:
+                assert row["number"] < 1000, row["id"]

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_feature_spec_contract.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+CONFORMANCE_FAMILY = "feature-spec"
+
+
+def test_feature_spec_contract(ssot_registry) -> None:
+    spec_ids = {row["id"] for row in ssot_registry["specs"]}
+    for feature in ssot_registry["features"]:
+        assert isinstance(feature.get("spec_ids", []), list), feature["id"]
+        for spec_id in feature.get("spec_ids", []):
+            assert spec_id in spec_ids, (feature["id"], spec_id)
+    for spec in ssot_registry["specs"]:
+        assert "feature_ids" not in spec, spec["id"]

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_id_contract.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from ssot_registry.model.ids import is_normalized_id
+
+CONFORMANCE_FAMILY = "id"
+
+
+def test_id_contract(ssot_registry) -> None:
+    for section in ("features", "tests", "claims", "evidence", "issues", "risks", "boundaries", "releases", "adrs", "specs"):
+        for row in ssot_registry.get(section, []):
+            assert is_normalized_id(row["id"]), f"{section}.{row['id']}"

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_proof_chain_contract.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+CONFORMANCE_FAMILY = "proof-chain"
+
+
+def test_proof_chain_contract(ssot_registry) -> None:
+    claims = {row["id"]: row for row in ssot_registry["claims"]}
+    tests = {row["id"]: row for row in ssot_registry["tests"]}
+    evidence = {row["id"]: row for row in ssot_registry["evidence"]}
+    for feature in ssot_registry["features"]:
+        if feature.get("implementation_status") != "implemented":
+            continue
+        assert feature["claim_ids"], feature["id"]
+        assert feature["test_ids"], feature["id"]
+        for claim_id in feature["claim_ids"]:
+            assert claim_id in claims, (feature["id"], claim_id)
+        for test_id in feature["test_ids"]:
+            assert test_id in tests, (feature["id"], test_id)
+    for claim in ssot_registry["claims"]:
+        for test_id in claim.get("test_ids", []):
+            assert test_id in tests, (claim["id"], test_id)
+        for evidence_id in claim.get("evidence_ids", []):
+            assert evidence_id in evidence, (claim["id"], evidence_id)

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_registry_contract.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from ssot_contracts.generated.python.enums import SCHEMA_VERSION
+from ssot_registry.api import validate_registry
+
+CONFORMANCE_FAMILY = "registry"
+
+
+def test_registry_contract(ssot_repo_root, ssot_registry) -> None:
+    report = validate_registry(ssot_repo_root)
+    assert report["passed"], report
+    assert ssot_registry["schema_version"] == SCHEMA_VERSION
+    for section in ("repo", "paths", "guard_policies", "features", "tests", "claims", "evidence", "adrs", "specs"):
+        assert section in ssot_registry

ssot_conformance-0.2.15/src/ssot_conformance/cases/test_spec_adr_contract.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+CONFORMANCE_FAMILY = "spec-adr"
+
+
+def test_spec_adr_contract(ssot_registry) -> None:
+    adr_ids = {row["id"] for row in ssot_registry["adrs"]}
+    for row in ssot_registry["specs"]:
+        assert isinstance(row.get("adr_ids", []), list), row["id"]
+        for adr_id in row.get("adr_ids", []):
+            assert adr_id in adr_ids, (row["id"], adr_id)

ssot_conformance-0.2.15/src/ssot_conformance/catalog.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+
+
+CATALOG_VERSION = "0.2.14"
+
+FAMILIES = (
+    "package-layout",
+    "plugin",
+    "registry",
+    "document",
+    "id",
+    "spec-adr",
+    "feature-spec",
+    "proof-chain",
+    "boundary-release",
+    "scaffold",
+    "evidence-output",
+    "cli",
+    "command-runner",
+)
+
+PROFILE_DEFINITIONS = {
+    "all": list(FAMILIES),
+    "core": list(FAMILIES),
+    **{family: [family] for family in FAMILIES},
+}
+
+_FEATURES = {
+    "package-layout": [
+        ("feat:conformance.package-layout", "SSOT conformance package layout", "Provide the ssot-conformance workspace package structure and package metadata.", ["spc:0524"], ["clm:conformance.package-layout.t2"], ["tst:pytest.conformance.package-layout"]),
+    ],
+    "plugin": [
+        ("feat:conformance.pytest-plugin", "SSOT conformance pytest plugin", "Expose pytest integration for running portable SSOT conformance cases against a target repository.", ["spc:0524"], ["clm:conformance.pytest-plugin.t2"], ["tst:pytest.conformance.pytest-plugin"]),
+        ("feat:conformance.case-discovery", "SSOT conformance case discovery", "Discover selected conformance profiles and case families before execution or scaffolding.", ["spc:0524", "spc:0525"], ["clm:conformance.case-discovery.t2"], ["tst:pytest.conformance.pytest-plugin"]),
+    ],
+    "registry": [
+        ("feat:conformance.registry-contract", "Registry conformance contract cases", "Validate registry existence, schema version, required sections, packaged schema conformance, and canonical JSON expectations.", ["spc:0525"], ["clm:conformance.registry-contract.t2"], ["tst:pytest.conformance.registry-contract"]),
+    ],
+    "document": [
+        ("feat:conformance.document-contract", "Document conformance contract cases", "Validate ADR and SPEC document rows, JSON files, hashes, origins, and numbering ranges.", ["spc:0525"], ["clm:conformance.document-contract.t2"], ["tst:pytest.conformance.document-contract"]),
+    ],
+    "id": [
+        ("feat:conformance.id-contract", "Normalized ID conformance contract cases", "Validate normalized entity IDs, reference IDs, and maximum identifier length policy.", ["spc:0525"], ["clm:conformance.id-contract.t2"], ["tst:pytest.conformance.id-contract"]),
+    ],
+    "spec-adr": [
+        ("feat:conformance.spec-adr-contract", "SPEC-to-ADR conformance contract cases", "Validate typed SPEC adr_ids links and derived SPEC-to-ADR graph visibility.", ["spc:0525"], ["clm:conformance.spec-adr-contract.t2"], ["tst:pytest.conformance.spec-adr-contract"]),
+    ],
+    "feature-spec": [
+        ("feat:conformance.feature-spec-contract", "Feature-to-SPEC conformance contract cases", "Validate feature-owned spec_ids links and confirm SPEC entities do not own feature_ids.", ["spc:0525", "spc:0526"], ["clm:conformance.feature-spec-contract.t2"], ["tst:pytest.conformance.feature-spec-contract"]),
+    ],
+    "proof-chain": [
+        ("feat:conformance.proof-chain-contract", "Proof-chain conformance contract cases", "Validate feature, claim, test, and evidence readiness relationships for targeted conformance rows.", ["spc:0525"], ["clm:conformance.proof-chain-contract.t2"], ["tst:pytest.conformance.proof-chain-contract"]),
+    ],
+    "boundary-release": [
+        ("feat:conformance.boundary-release-contract", "Boundary and release conformance contract cases", "Validate frozen boundary and release closure references used for conformance certification.", ["spc:0525"], ["clm:conformance.boundary-release-contract.t2"], ["tst:pytest.conformance.boundary-release-contract"]),
+    ],
+    "scaffold": [
+        ("feat:conformance.scaffold-dry-run", "Conformance scaffold dry-run planning", "Compute missing conformance feature and test rows without mutating the target registry.", ["spc:0526"], ["clm:conformance.scaffold-dry-run.t2"], ["tst:pytest.conformance.scaffold"]),
+        ("feat:conformance.scaffold-apply", "Conformance scaffold apply mode", "Create missing conformance feature and test rows through SSOT APIs while preserving validation.", ["spc:0526"], ["clm:conformance.scaffold-apply.t2"], ["tst:pytest.conformance.scaffold"]),
+        ("feat:conformance.scaffold-idempotency", "Conformance scaffold idempotency", "Ensure repeated scaffold runs do not duplicate rows or churn stable identifiers.", ["spc:0526"], ["clm:conformance.scaffold-idempotency.t2"], ["tst:pytest.conformance.scaffold"]),
+    ],
+    "evidence-output": [
+        ("feat:conformance.evidence-output", "Conformance evidence output", "Emit machine-readable conformance evidence suitable for registry status synchronization.", ["spc:0526"], ["clm:conformance.evidence-output.t2"], ["tst:pytest.conformance.evidence-output"]),
+    ],
+    "cli": [
+        ("feat:cli.conformance-surface", "CLI conformance command surface", "Expose ssot conformance commands for profile listing, discovery, scaffolding, execution, and evidence handling.", ["spc:0524", "spc:0526"], ["clm:cli.conformance-surface.t2"], ["tst:pytest.cli.conformance-surface"]),
+    ],
+    "command-runner": [
+        ("feat:conformance.command-runner", "Registry-driven conformance command runner", "Execute governed conformance rows through registry-owned command metadata instead of ad hoc runner flags.", ["spc:0524", "spc:0526"], ["clm:conformance.command-runner.t2"], ["tst:command.conformance.command-runner"]),
+    ],
+}
+
+_CLAIMS = {
+    "package-layout": [
+        ("clm:conformance.package-layout.t2", "Conformance package layout is planned", "The ssot-conformance package layout is tracked as a T2 conformance implementation target.", ["feat:conformance.package-layout"], ["tst:pytest.conformance.package-layout"], ["evd:t2.conformance.package-layout.pytest"]),
+    ],
+    "plugin": [
+        ("clm:conformance.pytest-plugin.t2", "Conformance pytest plugin is planned", "The pytest plugin integration is tracked as a T2 conformance implementation target.", ["feat:conformance.pytest-plugin"], ["tst:pytest.conformance.pytest-plugin"], ["evd:t2.conformance.pytest-plugin.pytest"]),
+        ("clm:conformance.case-discovery.t2", "Conformance case discovery is planned", "The conformance profile and case discovery behavior is tracked as a T2 target.", ["feat:conformance.case-discovery"], ["tst:pytest.conformance.pytest-plugin"], ["evd:t2.conformance.pytest-plugin.pytest"]),
+    ],
+    "registry": [
+        ("clm:conformance.registry-contract.t2", "Registry conformance contract is planned", "The registry conformance test family is tracked as a T2 target.", ["feat:conformance.registry-contract"], ["tst:pytest.conformance.registry-contract"], ["evd:t2.conformance.registry-contract.pytest"]),
+    ],
+    "document": [
+        ("clm:conformance.document-contract.t2", "Document conformance contract is planned", "The ADR and SPEC document conformance test family is tracked as a T2 target.", ["feat:conformance.document-contract"], ["tst:pytest.conformance.document-contract"], ["evd:t2.conformance.document-contract.pytest"]),
+    ],
+    "id": [
+        ("clm:conformance.id-contract.t2", "Normalized ID conformance contract is planned", "The normalized ID conformance test family is tracked as a T2 target.", ["feat:conformance.id-contract"], ["tst:pytest.conformance.id-contract"], ["evd:t2.conformance.id-contract.pytest"]),
+    ],
+    "spec-adr": [
+        ("clm:conformance.spec-adr-contract.t2", "SPEC-to-ADR conformance contract is planned", "The SPEC-to-ADR conformance test family is tracked as a T2 target.", ["feat:conformance.spec-adr-contract"], ["tst:pytest.conformance.spec-adr-contract"], ["evd:t2.conformance.spec-adr-contract.pytest"]),
+    ],
+    "feature-spec": [
+        ("clm:conformance.feature-spec-contract.t2", "Feature-to-SPEC conformance contract is planned", "The feature-to-SPEC conformance test family is tracked as a T2 target.", ["feat:conformance.feature-spec-contract"], ["tst:pytest.conformance.feature-spec-contract"], ["evd:t2.conformance.feature-spec-contract.pytest"]),
+    ],
+    "proof-chain": [
+        ("clm:conformance.proof-chain-contract.t2", "Proof-chain conformance contract is planned", "The feature claim test evidence proof-chain conformance family is tracked as a T2 target.", ["feat:conformance.proof-chain-contract"], ["tst:pytest.conformance.proof-chain-contract"], ["evd:t2.conformance.proof-chain-contract.pytest"]),
+    ],
+    "boundary-release": [
+        ("clm:conformance.boundary-release-contract.t2", "Boundary and release conformance contract is planned", "The boundary and release conformance test family is tracked as a T2 target.", ["feat:conformance.boundary-release-contract"], ["tst:pytest.conformance.boundary-release-contract"], ["evd:t2.conformance.boundary-release-contract.pytest"]),
+    ],
+    "scaffold": [
+        ("clm:conformance.scaffold-dry-run.t2", "Conformance scaffold dry-run is planned", "The scaffold dry-run planner is tracked as a T2 target.", ["feat:conformance.scaffold-dry-run"], ["tst:pytest.conformance.scaffold"], ["evd:t2.conformance.scaffold.pytest"]),
+        ("clm:conformance.scaffold-apply.t2", "Conformance scaffold apply is planned", "The scaffold apply mutation path is tracked as a T2 target.", ["feat:conformance.scaffold-apply"], ["tst:pytest.conformance.scaffold"], ["evd:t2.conformance.scaffold.pytest"]),
+        ("clm:conformance.scaffold-idempotency.t2", "Conformance scaffold idempotency is planned", "The scaffold idempotency behavior is tracked as a T2 target.", ["feat:conformance.scaffold-idempotency"], ["tst:pytest.conformance.scaffold"], ["evd:t2.conformance.scaffold.pytest"]),
+    ],
+    "evidence-output": [
+        ("clm:conformance.evidence-output.t2", "Conformance evidence output is planned", "The conformance evidence output behavior is tracked as a T2 target.", ["feat:conformance.evidence-output"], ["tst:pytest.conformance.evidence-output"], ["evd:t2.conformance.evidence-output.pytest"]),
+    ],
+    "cli": [
+        ("clm:cli.conformance-surface.t2", "CLI conformance surface is planned", "The ssot conformance CLI surface is tracked as a T2 target.", ["feat:cli.conformance-surface"], ["tst:pytest.cli.conformance-surface"], ["evd:t2.cli.conformance-surface.pytest"]),
+    ],
+    "command-runner": [
+        ("clm:conformance.command-runner.t2", "Registry-driven conformance command runner is planned", "The suite-agnostic command execution lane is tracked as a T2 conformance target.", ["feat:conformance.command-runner"], ["tst:command.conformance.command-runner"], ["evd:t2.conformance.command-runner.command"]),
+    ],
+}
+
+_TESTS = {
+    "package-layout": [
+        ("tst:pytest.conformance.package-layout", "Conformance package layout tests", "tests/unit/test_conformance_package_layout.py", ["feat:conformance.package-layout"], ["clm:conformance.package-layout.t2"], ["evd:t2.conformance.package-layout.pytest"]),
+    ],
+    "plugin": [
+        ("tst:pytest.conformance.pytest-plugin", "Conformance pytest plugin integration tests", "tests/integration/test_conformance_pytest_plugin.py", ["feat:conformance.pytest-plugin", "feat:conformance.case-discovery"], ["clm:conformance.pytest-plugin.t2", "clm:conformance.case-discovery.t2"], ["evd:t2.conformance.pytest-plugin.pytest"]),
+    ],
+    "registry": [
+        ("tst:pytest.conformance.registry-contract", "Registry conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_registry_contract.py", ["feat:conformance.registry-contract"], ["clm:conformance.registry-contract.t2"], ["evd:t2.conformance.registry-contract.pytest"]),
+    ],
+    "document": [
+        ("tst:pytest.conformance.document-contract", "Document conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_document_contract.py", ["feat:conformance.document-contract"], ["clm:conformance.document-contract.t2"], ["evd:t2.conformance.document-contract.pytest"]),
+    ],
+    "id": [
+        ("tst:pytest.conformance.id-contract", "Normalized ID conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_id_contract.py", ["feat:conformance.id-contract"], ["clm:conformance.id-contract.t2"], ["evd:t2.conformance.id-contract.pytest"]),
+    ],
+    "spec-adr": [
+        ("tst:pytest.conformance.spec-adr-contract", "SPEC-to-ADR conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_spec_adr_contract.py", ["feat:conformance.spec-adr-contract"], ["clm:conformance.spec-adr-contract.t2"], ["evd:t2.conformance.spec-adr-contract.pytest"]),
+    ],
+    "feature-spec": [
+        ("tst:pytest.conformance.feature-spec-contract", "Feature-to-SPEC conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_feature_spec_contract.py", ["feat:conformance.feature-spec-contract"], ["clm:conformance.feature-spec-contract.t2"], ["evd:t2.conformance.feature-spec-contract.pytest"]),
+    ],
+    "proof-chain": [
+        ("tst:pytest.conformance.proof-chain-contract", "Proof-chain conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_proof_chain_contract.py", ["feat:conformance.proof-chain-contract"], ["clm:conformance.proof-chain-contract.t2"], ["evd:t2.conformance.proof-chain-contract.pytest"]),
+    ],
+    "boundary-release": [
+        ("tst:pytest.conformance.boundary-release-contract", "Boundary and release conformance contract tests", "pkgs/ssot-conformance/src/ssot_conformance/cases/test_boundary_release_contract.py", ["feat:conformance.boundary-release-contract"], ["clm:conformance.boundary-release-contract.t2"], ["evd:t2.conformance.boundary-release-contract.pytest"]),
+    ],
+    "scaffold": [
+        ("tst:pytest.conformance.scaffold", "Conformance scaffold tests", "tests/unit/test_conformance_scaffold.py", ["feat:conformance.scaffold-dry-run", "feat:conformance.scaffold-apply", "feat:conformance.scaffold-idempotency"], ["clm:conformance.scaffold-dry-run.t2", "clm:conformance.scaffold-apply.t2", "clm:conformance.scaffold-idempotency.t2"], ["evd:t2.conformance.scaffold.pytest"]),
+    ],
+    "evidence-output": [
+        ("tst:pytest.conformance.evidence-output", "Conformance evidence output tests", "tests/unit/test_conformance_evidence_output.py", ["feat:conformance.evidence-output"], ["clm:conformance.evidence-output.t2"], ["evd:t2.conformance.evidence-output.pytest"]),
+    ],
+    "cli": [
+        ("tst:pytest.cli.conformance-surface", "CLI conformance surface tests", "tests/integration/test_cli_conformance.py", ["feat:cli.conformance-surface"], ["clm:cli.conformance-surface.t2"], ["evd:t2.cli.conformance-surface.pytest"]),
+    ],
+    "command-runner": [
+        ("tst:command.conformance.command-runner", "Registry-driven conformance command runner tests", "tests/integration/test_cli_registry_execution.py", ["feat:conformance.command-runner"], ["clm:conformance.command-runner.t2"], ["evd:t2.conformance.command-runner.command"]),
+    ],
+}
+
+_EVIDENCE = {
+    "package-layout": [
+        ("evd:t2.conformance.package-layout.pytest", "Package layout pytest evidence", ".ssot/evidence/conformance/conformance-package-layout-pytest.json", ["clm:conformance.package-layout.t2"], ["tst:pytest.conformance.package-layout"]),
+    ],
+    "plugin": [
+        ("evd:t2.conformance.pytest-plugin.pytest", "Pytest plugin integration evidence", ".ssot/evidence/conformance/conformance-pytest-plugin-pytest.json", ["clm:conformance.pytest-plugin.t2", "clm:conformance.case-discovery.t2"], ["tst:pytest.conformance.pytest-plugin"]),
+    ],
+    "registry": [
+        ("evd:t2.conformance.registry-contract.pytest", "Registry contract pytest evidence", ".ssot/evidence/conformance/conformance-registry-contract-pytest.json", ["clm:conformance.registry-contract.t2"], ["tst:pytest.conformance.registry-contract"]),
+    ],
+    "document": [
+        ("evd:t2.conformance.document-contract.pytest", "Document contract pytest evidence", ".ssot/evidence/conformance/conformance-document-contract-pytest.json", ["clm:conformance.document-contract.t2"], ["tst:pytest.conformance.document-contract"]),
+    ],
+    "id": [
+        ("evd:t2.conformance.id-contract.pytest", "ID contract pytest evidence", ".ssot/evidence/conformance/conformance-id-contract-pytest.json", ["clm:conformance.id-contract.t2"], ["tst:pytest.conformance.id-contract"]),
+    ],
+    "spec-adr": [
+        ("evd:t2.conformance.spec-adr-contract.pytest", "SPEC-to-ADR contract pytest evidence", ".ssot/evidence/conformance/conformance-spec-adr-contract-pytest.json", ["clm:conformance.spec-adr-contract.t2"], ["tst:pytest.conformance.spec-adr-contract"]),
+    ],
+    "feature-spec": [
+        ("evd:t2.conformance.feature-spec-contract.pytest", "Feature-to-SPEC contract pytest evidence", ".ssot/evidence/conformance/conformance-feature-spec-contract-pytest.json", ["clm:conformance.feature-spec-contract.t2"], ["tst:pytest.conformance.feature-spec-contract"]),
+    ],
+    "proof-chain": [
+        ("evd:t2.conformance.proof-chain-contract.pytest", "Proof-chain contract pytest evidence", ".ssot/evidence/conformance/conformance-proof-chain-contract-pytest.json", ["clm:conformance.proof-chain-contract.t2"], ["tst:pytest.conformance.proof-chain-contract"]),
+    ],
+    "boundary-release": [
+        ("evd:t2.conformance.boundary-release-contract.pytest", "Boundary and release contract pytest evidence", ".ssot/evidence/conformance/conformance-boundary-release-contract-pytest.json", ["clm:conformance.boundary-release-contract.t2"], ["tst:pytest.conformance.boundary-release-contract"]),
+    ],
+    "scaffold": [
+        ("evd:t2.conformance.scaffold.pytest", "Scaffold pytest evidence", ".ssot/evidence/conformance/conformance-scaffold-pytest.json", ["clm:conformance.scaffold-dry-run.t2", "clm:conformance.scaffold-apply.t2", "clm:conformance.scaffold-idempotency.t2"], ["tst:pytest.conformance.scaffold"]),
+    ],
+    "evidence-output": [
+        ("evd:t2.conformance.evidence-output.pytest", "Evidence output pytest evidence", ".ssot/evidence/conformance/conformance-evidence-output-pytest.json", ["clm:conformance.evidence-output.t2"], ["tst:pytest.conformance.evidence-output"]),
+    ],
+    "cli": [
+        ("evd:t2.cli.conformance-surface.pytest", "CLI conformance surface pytest evidence", ".ssot/evidence/conformance/cli-conformance-surface-pytest.json", ["clm:cli.conformance-surface.t2"], ["tst:pytest.cli.conformance-surface"]),
+    ],
+    "command-runner": [
+        ("evd:t2.conformance.command-runner.command", "Registry-driven conformance command evidence", ".ssot/evidence/conformance/conformance-command-runner-command.json", ["clm:conformance.command-runner.t2"], ["tst:command.conformance.command-runner"]),
+    ],
+}
+
+_TEST_KIND_OVERRIDES = {
+    "tst:command.conformance.command-runner": "command",
+}
+
+_EVIDENCE_KIND_OVERRIDES = {
+    "evd:t2.conformance.command-runner.command": "command",
+}
+
+
+def _build_execution_row(test_id: str, path: str, kind: str) -> dict[str, object]:
+    packaged_case_root = "pkgs/ssot-conformance/src/ssot_conformance/cases/"
+    env: dict[str, str] = {}
+    if path.startswith(packaged_case_root) and path.endswith(".py"):
+        module_name = f"ssot_conformance.cases.{Path(path).stem}"
+        argv = [
+            "python",
+            "-m",
+            "pytest",
+            "--pyargs",
+            module_name,
+            "-q",
+            "-p",
+            "ssot_conformance.plugin",
+            "--ssot-repo-root=.",
+        ]
+        env["PYTEST_DISABLE_PLUGIN_AUTOLOAD"] = "1"
+    else:
+        argv = ["python", "-m", "pytest", path, "-q"]
+    return {
+        "mode": "command",
+        "argv": argv,
+        "cwd": ".",
+        "env": env,
+        "timeout_seconds": 600,
+        "success": {"type": "exit_code", "expected": 0},
+    }
+
+
+def list_profiles() -> list[dict[str, object]]:
+    profiles = []
+    for profile_name, families in PROFILE_DEFINITIONS.items():
+        profiles.append(
+            {
+                "profile": profile_name,
+                "families": list(families),
+                "case_count": sum(len(_TESTS[family]) for family in families),
+            }
+        )
+    return profiles
+
+
+def resolve_selected_families(profiles: list[str] | None = None) -> list[str]:
+    if not profiles:
+        return list(PROFILE_DEFINITIONS["all"])
+    selected: list[str] = []
+    for profile in profiles:
+        if profile not in PROFILE_DEFINITIONS:
+            raise ValueError(f"Unknown conformance profile: {profile}")
+        for family in PROFILE_DEFINITIONS[profile]:
+            if family not in selected:
+                selected.append(family)
+    return selected
+
+
+def _feature_row(values: tuple[str, str, str, list[str], list[str], list[str]]) -> dict[str, object]:
+    feature_id, title, description, spec_ids, claim_ids, test_ids = values
+    return {
+        "id": feature_id,
+        "title": title,
+        "description": description,
+        "implementation_status": "absent",
+        "lifecycle": {"stage": "active", "replacement_feature_ids": [], "note": None},
+        "plan": {"horizon": "backlog", "slot": None, "target_claim_tier": "T2", "target_lifecycle_stage": "active"},
+        "spec_ids": list(spec_ids),
+        "claim_ids": list(claim_ids),
+        "test_ids": list(test_ids),
+        "requires": [],
+    }
+
+
+def _claim_row(values: tuple[str, str, str, list[str], list[str], list[str]]) -> dict[str, object]:
+    claim_id, title, description, feature_ids, test_ids, evidence_ids = values
+    return {
+        "id": claim_id,
+        "title": title,
+        "status": "proposed",
+        "tier": "T2",
+        "kind": "conformance",
+        "description": description,
+        "feature_ids": list(feature_ids),
+        "test_ids": list(test_ids),
+        "evidence_ids": list(evidence_ids),
+    }
+
+
+def _test_row(values: tuple[str, str, str, list[str], list[str], list[str]]) -> dict[str, object]:
+    test_id, title, path, feature_ids, claim_ids, evidence_ids = values
+    kind = _TEST_KIND_OVERRIDES.get(test_id, "pytest")
+    return {
+        "id": test_id,
+        "title": title,
+        "status": "planned",
+        "kind": kind,
+        "path": path,
+        "feature_ids": list(feature_ids),
+        "claim_ids": list(claim_ids),
+        "evidence_ids": list(evidence_ids),
+        "execution": _build_execution_row(test_id, path, kind),
+    }
+
+
+def _evidence_row(values: tuple[str, str, str, list[str], list[str]]) -> dict[str, object]:
+    evidence_id, title, path, claim_ids, test_ids = values
+    return {
+        "id": evidence_id,
+        "title": title,
+        "status": "planned",
+        "kind": _EVIDENCE_KIND_OVERRIDES.get(evidence_id, "pytest"),
+        "tier": "T2",
+        "path": path,
+        "claim_ids": list(claim_ids),
+        "test_ids": list(test_ids),
+    }
+
+
+def build_catalog_slice(profiles: list[str] | None = None) -> dict[str, object]:
+    families = resolve_selected_families(profiles)
+    payload = {
+        "catalog_version": CATALOG_VERSION,
+        "profiles": profiles or ["all"],
+        "families": families,
+        "features": [],
+        "claims": [],
+        "tests": [],
+        "evidence": [],
+    }
+    for family in families:
+        payload["features"].extend(_feature_row(values) for values in _FEATURES[family])
+        payload["claims"].extend(_claim_row(values) for values in _CLAIMS[family])
+        payload["tests"].extend(_test_row(values) for values in _TESTS[family])
+        payload["evidence"].extend(_evidence_row(values) for values in _EVIDENCE[family])
+    return deepcopy(payload)

ssot_conformance-0.2.15/src/ssot_conformance/discovery.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from .catalog import build_catalog_slice
+
+
+def discover_cases(profiles: list[str] | None = None) -> dict[str, object]:
+    catalog = build_catalog_slice(profiles)
+    return {
+        "passed": True,
+        "catalog_version": catalog["catalog_version"],
+        "profiles": catalog["profiles"],
+        "families": catalog["families"],
+        "cases": [
+            {
+                "id": row["id"],
+                "title": row["title"],
+                "kind": row["kind"],
+                "path": row["path"],
+                "feature_ids": row["feature_ids"],
+                "claim_ids": row["claim_ids"],
+                "evidence_ids": row["evidence_ids"],
+            }
+            for row in catalog["tests"]
+        ],
+    }

ssot_conformance-0.2.15/src/ssot_conformance/evidence.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ssot_registry.util.jcs import dump_jcs_json
+
+
+def build_evidence_output(
+    *,
+    repo_root: str,
+    selected_profiles: list[str],
+    selected_families: list[str],
+    cases: list[dict[str, object]],
+) -> dict[str, object]:
+    summary = {"passed": 0, "failed": 0, "skipped": 0, "total": len(cases)}
+    for row in cases:
+        outcome = str(row.get("outcome", "unknown"))
+        if outcome in summary:
+            summary[outcome] += 1
+    return {
+        "kind": "ssot-conformance-evidence",
+        "repo_root": repo_root,
+        "profiles": selected_profiles,
+        "families": selected_families,
+        "summary": summary,
+        "cases": cases,
+    }
+
+
+def write_evidence_output(path: str | Path, payload: dict[str, object]) -> str:
+    target = Path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(dump_jcs_json(payload), encoding="utf-8")
+    return target.as_posix()

ssot_conformance-0.2.15/src/ssot_conformance/plugin.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+try:  # pragma: no cover - import depends on environment
+    import pytest
+except ModuleNotFoundError:  # pragma: no cover - import depends on environment
+    pytest = None
+
+from .catalog import resolve_selected_families
+from .evidence import build_evidence_output, write_evidence_output
+
+
+def pytest_addoption(parser: Any) -> None:
+    group = parser.getgroup("ssot-conformance")
+    group.addoption("--ssot-repo-root", action="store", default=".", help="Target repository root for SSOT conformance evaluation.")
+    group.addoption(
+        "--ssot-conformance-profile",
+        action="append",
+        default=[],
+        help="Conformance profile or family to execute. May be repeated.",
+    )
+    group.addoption(
+        "--ssot-conformance-evidence-output",
+        action="store",
+        default=None,
+        help="Write machine-readable conformance evidence JSON to this path.",
+    )
+
+
+def pytest_configure(config: Any) -> None:
+    config._ssot_conformance_reports = []
+
+
+def pytest_collection_modifyitems(config: Any, items: list[Any]) -> None:
+    selected_families = set(resolve_selected_families(config.getoption("ssot_conformance_profile")))
+    kept: list[Any] = []
+    deselected: list[Any] = []
+    for item in items:
+        family = getattr(item.module, "CONFORMANCE_FAMILY", None)
+        if family is None or family in selected_families:
+            kept.append(item)
+        else:
+            deselected.append(item)
+    if deselected:
+        config.hook.pytest_deselected(items=deselected)
+        items[:] = kept
+
+
+if pytest is not None:
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(item: Any, call: Any) -> Any:
+        outcome = yield
+        report = outcome.get_result()
+        if report.when != "call":
+            return
+        item.config._ssot_conformance_reports.append(
+            {
+                "nodeid": report.nodeid,
+                "family": getattr(item.module, "CONFORMANCE_FAMILY", None),
+                "outcome": report.outcome,
+            }
+        )
+
+
+def pytest_sessionfinish(session: Any, exitstatus: int) -> None:
+    output = session.config.getoption("ssot_conformance_evidence_output")
+    if output is None:
+        return
+    selected_profiles = session.config.getoption("ssot_conformance_profile") or ["all"]
+    selected_families = resolve_selected_families(selected_profiles)
+    payload = build_evidence_output(
+        repo_root=str(Path(session.config.getoption("ssot_repo_root")).resolve()),
+        selected_profiles=list(selected_profiles),
+        selected_families=selected_families,
+        cases=list(session.config._ssot_conformance_reports),
+    )
+    write_evidence_output(output, payload)
+
+
+if pytest is not None:
+    @pytest.fixture(scope="session")
+    def ssot_repo_root(pytestconfig: Any) -> Path:
+        return Path(pytestconfig.getoption("ssot_repo_root")).resolve()
+
+
+    @pytest.fixture(scope="session")
+    def ssot_registry(ssot_repo_root: Path) -> dict[str, object]:
+        import json
+
+        return json.loads((ssot_repo_root / ".ssot" / "registry.json").read_text(encoding="utf-8"))

ssot_conformance-0.2.15/src/ssot_conformance/runner.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import subprocess
+from pathlib import Path
+
+from .catalog import resolve_selected_families
+from .evidence import build_evidence_output, write_evidence_output
+
+_PLUGIN_MODULE_NAME = "ssot_conformance.plugin"
+
+
+def run_pytest_cases(
+    *,
+    repo_root: str | Path,
+    profiles: list[str] | None = None,
+    evidence_output: str | Path | None = None,
+    pytest_args: list[str] | None = None,
+) -> dict[str, object]:
+    try:
+        import pytest
+    except ModuleNotFoundError as exc:  # pragma: no cover - depends on test environment
+        raise ValueError("pytest is required for `ssot conformance run`; install dev dependencies or use `uv run pytest`") from exc
+
+    import importlib.resources as resources
+
+    resolved_repo_root = Path(repo_root).resolve()
+    selected_profiles = profiles or ["all"]
+    selected_families = resolve_selected_families(profiles)
+    case_root = resources.files("ssot_conformance.cases")
+    args = [
+        str(case_root),
+        "-p",
+        _PLUGIN_MODULE_NAME,
+        f"--ssot-repo-root={resolved_repo_root}",
+    ]
+    for profile in selected_profiles:
+        args.append(f"--ssot-conformance-profile={profile}")
+    if evidence_output is not None:
+        args.append(f"--ssot-conformance-evidence-output={evidence_output}")
+    args.extend(pytest_args or [])
+
+    stdout_buffer = io.StringIO()
+    stderr_buffer = io.StringIO()
+    previous_plugin_autoload = os.environ.get("PYTEST_DISABLE_PLUGIN_AUTOLOAD")
+    os.environ["PYTEST_DISABLE_PLUGIN_AUTOLOAD"] = "1"
+    with contextlib.redirect_stdout(stdout_buffer), contextlib.redirect_stderr(stderr_buffer):
+        try:
+            exit_code = pytest.main(args)
+        finally:
+            if previous_plugin_autoload is None:
+                os.environ.pop("PYTEST_DISABLE_PLUGIN_AUTOLOAD", None)
+            else:
+                os.environ["PYTEST_DISABLE_PLUGIN_AUTOLOAD"] = previous_plugin_autoload
+    payload: dict[str, object] = {
+        "runner": "pytest",
+        "passed": exit_code == 0,
+        "pytest_exit_code": exit_code,
+        "profiles": selected_profiles,
+        "families": selected_families,
+        "case_root": str(case_root),
+    }
+    if stdout_buffer.getvalue():
+        payload["pytest_stdout"] = stdout_buffer.getvalue()
+    if stderr_buffer.getvalue():
+        payload["pytest_stderr"] = stderr_buffer.getvalue()
+    if evidence_output is not None:
+        evidence_path = Path(evidence_output)
+        if evidence_path.exists():
+            payload["evidence_output"] = evidence_path.as_posix()
+        else:
+            payload["evidence_output"] = write_evidence_output(
+                evidence_path,
+                build_evidence_output(
+                    repo_root=str(resolved_repo_root),
+                    selected_profiles=selected_profiles,
+                    selected_families=selected_families,
+                    cases=[],
+                ),
+            )
+    return payload
+
+
+def run_command_suite(
+    *,
+    repo_root: str | Path,
+    profiles: list[str] | None = None,
+    evidence_output: str | Path | None = None,
+    command: list[str],
+) -> dict[str, object]:
+    if not command:
+        raise ValueError("command runner requires a command after `--command`")
+
+    resolved_repo_root = Path(repo_root).resolve()
+    selected_profiles = profiles or ["all"]
+    selected_families = resolve_selected_families(profiles)
+    result = subprocess.run(
+        command,
+        cwd=str(resolved_repo_root),
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    outcome = "passed" if result.returncode == 0 else "failed"
+    case = {
+        "nodeid": "command-suite",
+        "runner": "command",
+        "command": list(command),
+        "outcome": outcome,
+        "returncode": result.returncode,
+    }
+    if result.stdout:
+        case["stdout"] = result.stdout
+    if result.stderr:
+        case["stderr"] = result.stderr
+    payload: dict[str, object] = {
+        "runner": "command",
+        "passed": result.returncode == 0,
+        "command_exit_code": result.returncode,
+        "command": list(command),
+        "profiles": selected_profiles,
+        "families": selected_families,
+    }
+    if evidence_output is not None:
+        payload["evidence_output"] = write_evidence_output(
+            evidence_output,
+            build_evidence_output(
+                repo_root=str(resolved_repo_root),
+                selected_profiles=selected_profiles,
+                selected_families=selected_families,
+                cases=[case],
+            ),
+        )
+    else:
+        payload["cases"] = [case]
+    return payload

ssot_conformance-0.2.15/src/ssot_conformance/scaffold.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+
+from ssot_registry.api import create_entity, validate_registry
+
+from .catalog import build_catalog_slice, resolve_selected_families
+
+
+def _ids(rows: list[dict[str, object]]) -> set[str]:
+    return {str(row["id"]) for row in rows}
+
+
+def plan_scaffold(
+    path: str | Path,
+    *,
+    profiles: list[str] | None = None,
+    include_claims: bool = False,
+    include_evidence: bool = False,
+) -> dict[str, object]:
+    registry_report = validate_registry(path)
+    if not registry_report["passed"]:
+        raise ValueError("Target registry must validate before conformance scaffold planning")
+
+    catalog = build_catalog_slice(profiles)
+    registry_path = Path(path) / ".ssot" / "registry.json" if Path(path).is_dir() else Path(path)
+    repo_root = registry_path.parent.parent if registry_path.name == "registry.json" else Path(path)
+    import json
+
+    registry = json.loads(registry_path.read_text(encoding="utf-8"))
+    existing = {section: _ids(registry.get(section, [])) for section in ("features", "claims", "tests", "evidence")}
+
+    missing = {
+        "features": [row["id"] for row in catalog["features"] if row["id"] not in existing["features"]],
+        "claims": [row["id"] for row in catalog["claims"] if row["id"] not in existing["claims"]],
+        "tests": [row["id"] for row in catalog["tests"] if row["id"] not in existing["tests"]],
+        "evidence": [row["id"] for row in catalog["evidence"] if row["id"] not in existing["evidence"]],
+    }
+
+    planned_feature_ids = set(existing["features"]) | set(missing["features"])
+    planned_claim_ids = set(existing["claims"]) | (set(missing["claims"]) if include_claims else set())
+    planned_evidence_ids = set(existing["evidence"]) | (set(missing["evidence"]) if include_evidence else set())
+
+    blocked_tests: list[dict[str, object]] = []
+    creatable_tests: list[str] = []
+    for row in catalog["tests"]:
+        test_id = str(row["id"])
+        if test_id in existing["tests"]:
+            continue
+        reasons: list[str] = []
+        for feature_id in row["feature_ids"]:
+            if feature_id not in planned_feature_ids:
+                reasons.append(f"missing feature {feature_id}")
+        for claim_id in row["claim_ids"]:
+            if claim_id not in planned_claim_ids:
+                reasons.append(f"missing claim {claim_id}")
+        for evidence_id in row["evidence_ids"]:
+            if evidence_id not in planned_evidence_ids:
+                reasons.append(f"missing evidence {evidence_id}")
+        if reasons:
+            blocked_tests.append({"id": test_id, "reasons": reasons})
+        else:
+            creatable_tests.append(test_id)
+
+    return {
+        "passed": True,
+        "repo_root": repo_root.as_posix(),
+        "profiles": catalog["profiles"],
+        "families": resolve_selected_families(profiles),
+        "missing": missing,
+        "creatable_test_ids": creatable_tests,
+        "blocked_tests": blocked_tests,
+        "include_claims": include_claims,
+        "include_evidence": include_evidence,
+    }
+
+
+def apply_scaffold(
+    path: str | Path,
+    *,
+    profiles: list[str] | None = None,
+    include_claims: bool = False,
+    include_evidence: bool = False,
+) -> dict[str, object]:
+    plan = plan_scaffold(path, profiles=profiles, include_claims=include_claims, include_evidence=include_evidence)
+    catalog = build_catalog_slice(profiles)
+    repo_root = Path(plan["repo_root"])
+
+    created = {"features": [], "claims": [], "tests": [], "evidence": []}
+    unchanged = {"features": [], "claims": [], "tests": [], "evidence": []}
+
+    missing = {key: set(value) for key, value in plan["missing"].items()}
+    creatable_tests = set(plan["creatable_test_ids"])
+
+    claim_rows = {row["id"]: row for row in catalog["claims"]}
+    evidence_rows = {row["id"]: row for row in catalog["evidence"]}
+    feature_rows = {row["id"]: row for row in catalog["features"]}
+    test_rows = {row["id"]: row for row in catalog["tests"]}
+
+    for feature_id in missing["features"]:
+        row = deepcopy(feature_rows[feature_id])
+        row["spec_ids"] = []
+        row["claim_ids"] = []
+        row["test_ids"] = []
+        create_entity(path, "features", row)
+        created["features"].append(feature_id)
+
+    if include_claims:
+        for claim_id in missing["claims"]:
+            row = deepcopy(claim_rows[claim_id])
+            row["test_ids"] = []
+            row["evidence_ids"] = []
+            create_entity(path, "claims", row)
+            created["claims"].append(claim_id)
+    else:
+        unchanged["claims"].extend(sorted(plan["missing"]["claims"]))
+
+    if include_evidence:
+        for evidence_id in missing["evidence"]:
+            row = deepcopy(evidence_rows[evidence_id])
+            target = repo_root / str(row["path"])
+            target.parent.mkdir(parents=True, exist_ok=True)
+            if not target.exists():
+                target.write_text("{}", encoding="utf-8")
+            row["test_ids"] = []
+            create_entity(path, "evidence", row)
+            created["evidence"].append(evidence_id)
+
+    for test_id in creatable_tests:
+        if test_id not in missing["tests"]:
+            continue
+        row = deepcopy(test_rows[test_id])
+        target = repo_root / str(row["path"])
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if not target.exists():
+            target.write_text("def test_placeholder():\n    assert True\n", encoding="utf-8")
+        create_entity(path, "tests", row)
+        created["tests"].append(test_id)
+
+    validation = validate_registry(path)
+    return {
+        "passed": validation["passed"],
+        "profiles": plan["profiles"],
+        "families": plan["families"],
+        "created": created,
+        "unchanged": unchanged,
+        "blocked_tests": plan["blocked_tests"],
+        "validation": validation,
+    }

ssot_conformance-0.2.15/src/ssot_conformance.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: ssot-conformance
+Version: 0.2.15
+Summary: Reusable SSOT conformance harness, pytest plugin, and scaffold helpers.
+Author-email: Jacob Stewart <jacob@swarmauri.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/groupsum/ssot-registry/tree/main/pkgs/ssot-conformance
+Project-URL: Repository, https://github.com/groupsum/ssot-registry/tree/main/pkgs/ssot-conformance
+Project-URL: Issues, https://github.com/groupsum/ssot-registry/issues
+Keywords: ssot,conformance,pytest,governance,validation,scaffold
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Plugins
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ssot-core==0.2.15
+Requires-Dist: ssot-contracts==0.2.15
+Requires-Dist: tomli>=2.0.1; python_version < "3.11"
+
+<div align="center">
+  <h1>🔷 ssot-conformance</h1>
+  <p><strong>Reusable SSOT conformance harness for downstream repositories.</strong></p>
+</div>
+
+<div align="center">
+  <a href="https://pypi.org/project/ssot-conformance/"><img src="https://img.shields.io/pypi/v/ssot-conformance?label=PyPI%20version" alt="PyPI version" /></a>
+  <a href="https://pypi.org/project/ssot-conformance/"><img src="https://img.shields.io/pypi/pyversions/ssot-conformance?label=Python" alt="Supported Python versions" /></a>
+  <a href="https://pepy.tech/project/ssot-conformance"><img src="https://static.pepy.tech/badge/ssot-conformance" alt="Downloads" /></a>
+  <a href="https://hits.sh/github.com/groupsum/ssot-registry/"><img src="https://hits.sh/github.com/groupsum/ssot-registry.svg?style=flat-square" alt="Repository hits" /></a>
+</div>
+
+Reusable SSOT conformance harness for downstream repositories.
+
+This package provides:
+
+- portable conformance case families grouped by registry, document, id, SPEC-to-ADR, feature-to-SPEC, proof-chain, and boundary/release concerns
+- a `pytest` plugin entry point for repo-root selection, case-family filtering, and evidence-output emission
+- scaffold helpers that can compute and optionally create missing conformance SSOT rows
+- machine-readable evidence output suitable for later SSOT evidence ingestion and status synchronization
+
+The package is intentionally repo-agnostic. It evaluates a target repository through `.ssot` artifacts and registry semantics rather than assuming a specific implementation language for the target system.
+
+## Install
+
+```bash
+python -m pip install ssot-conformance
+```
+
+For local development from this repository:
+
+```bash
+python -m pip install -e pkgs/ssot-conformance
+```
+
+## Execution model
+
+Packaged `ssot-core` conformance remains pytest-based, but the operator-facing execution model is registry-driven:
+
+- packaged conformance rows store executable `tests[].execution` metadata
+- `ssot conformance run` resolves governed conformance tests and runs those stored commands
+- downstream repos can use the same `tests[].execution` contract for arbitrary command-backed suites
+
+For direct SSOT entity execution, prefer:
+
+```text
+ssot test run . --id tst:pytest.conformance.registry-contract
+ssot spec run-tests . --id spc:0525
+ssot boundary run-tests . --id bnd:full-cert
+```
+
+## Package relationships
+
+- Package type: reusable conformance and pytest plugin package
+- Depends on: [ssot-core](https://pypi.org/project/ssot-core/), [ssot-contracts](https://pypi.org/project/ssot-contracts/)
+- Consumed by: [ssot-cli](https://pypi.org/project/ssot-cli/) and downstream repositories that run packaged SSOT conformance checks
+
+If you need the CLI wrapper for these checks, install [ssot-cli](https://pypi.org/project/ssot-cli/). If you need to embed or run the reusable conformance cases directly, this is the package to install.

ssot_conformance-0.2.15/src/ssot_conformance.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+src/ssot_conformance/__init__.py
+src/ssot_conformance/catalog.py
+src/ssot_conformance/discovery.py
+src/ssot_conformance/evidence.py
+src/ssot_conformance/plugin.py
+src/ssot_conformance/runner.py
+src/ssot_conformance/scaffold.py
+src/ssot_conformance.egg-info/PKG-INFO
+src/ssot_conformance.egg-info/SOURCES.txt
+src/ssot_conformance.egg-info/dependency_links.txt
+src/ssot_conformance.egg-info/entry_points.txt
+src/ssot_conformance.egg-info/requires.txt
+src/ssot_conformance.egg-info/top_level.txt
+src/ssot_conformance/cases/__init__.py
+src/ssot_conformance/cases/test_boundary_release_contract.py
+src/ssot_conformance/cases/test_document_contract.py
+src/ssot_conformance/cases/test_feature_spec_contract.py
+src/ssot_conformance/cases/test_id_contract.py
+src/ssot_conformance/cases/test_proof_chain_contract.py
+src/ssot_conformance/cases/test_registry_contract.py
+src/ssot_conformance/cases/test_spec_adr_contract.py

ssot_conformance-0.2.15/src/ssot_conformance.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ssot_conformance-0.2.15/src/ssot_conformance.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+ssot-conformance = ssot_conformance.plugin

ssot_conformance-0.2.15/src/ssot_conformance.egg-info/requires.txt

@@ -0,0 +1,5 @@
+ssot-core==0.2.15
+ssot-contracts==0.2.15
+
+[:python_version < "3.11"]
+tomli>=2.0.1

ssot_conformance-0.2.15/src/ssot_conformance.egg-info/top_level.txt

@@ -0,0 +1 @@
+ssot_conformance