ssot-core 0.2.20.dev1__tar.gz → 0.2.21.dev1__tar.gz

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssot-core
-Version: 0.2.20.dev1
+Version: 0.2.21.dev1
 Summary: Core Python runtime, registry model, validation, and release workflow APIs for SSOT.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License-Expression: Apache-2.0
@@ -36,9 +36,9 @@ Classifier: Topic :: Utilities
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: orjson<4.0,>=3.10
-Requires-Dist: ssot-contracts==0.2.20.dev1
-Requires-Dist: ssot-pack-contracts<0.3.0,>=0.2.21.dev1
-Requires-Dist: ssot-views==0.2.20.dev1
+Requires-Dist: ssot-contracts==0.2.21.dev1
+Requires-Dist: ssot-pack-contracts<0.3.0,>=0.2.22.dev1
+Requires-Dist: ssot-views==0.2.21.dev1
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 
 <div align="center">

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ssot-core"
-version = "0.2.20.dev1"
+version = "0.2.21.dev1"
 description = "Core Python runtime, registry model, validation, and release workflow APIs for SSOT."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -12,9 +12,9 @@ license = "Apache-2.0"
 authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
 dependencies = [
   "orjson>=3.10,<4.0",
-  "ssot-contracts==0.2.20.dev1",
-  "ssot-pack-contracts>=0.2.21.dev1,<0.3.0",
-  "ssot-views==0.2.20.dev1",
+  "ssot-contracts==0.2.21.dev1",
+  "ssot-pack-contracts>=0.2.22.dev1,<0.3.0",
+  "ssot-views==0.2.21.dev1",
   "tomli>=2.0.1; python_version < '3.11'",
 ]
 keywords = ["ssot", "core", "registry", "validation", "release-management", "governance", "compliance"]

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/src/ssot_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssot-core
-Version: 0.2.20.dev1
+Version: 0.2.21.dev1
 Summary: Core Python runtime, registry model, validation, and release workflow APIs for SSOT.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License-Expression: Apache-2.0
@@ -36,9 +36,9 @@ Classifier: Topic :: Utilities
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: orjson<4.0,>=3.10
-Requires-Dist: ssot-contracts==0.2.20.dev1
-Requires-Dist: ssot-pack-contracts<0.3.0,>=0.2.21.dev1
-Requires-Dist: ssot-views==0.2.20.dev1
+Requires-Dist: ssot-contracts==0.2.21.dev1
+Requires-Dist: ssot-pack-contracts<0.3.0,>=0.2.22.dev1
+Requires-Dist: ssot-views==0.2.21.dev1
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
 
 <div align="center">

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/src/ssot_core.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/ssot_registry/api/packs.py
 src/ssot_registry/api/plan.py
 src/ssot_registry/api/profile_eval.py
 src/ssot_registry/api/profile_resolution.py
+src/ssot_registry/api/proof_graph.py
 src/ssot_registry/api/registry.py
 src/ssot_registry/api/release.py
 src/ssot_registry/api/save.py

ssot_core-0.2.21.dev1/src/ssot_core.egg-info/requires.txt

@@ -0,0 +1,7 @@
+orjson<4.0,>=3.10
+ssot-contracts==0.2.21.dev1
+ssot-pack-contracts<0.3.0,>=0.2.22.dev1
+ssot-views==0.2.21.dev1
+
+[:python_version < "3.11"]
+tomli>=2.0.1

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/src/ssot_registry/api/__init__.py

@@ -1,6 +1,6 @@
 from .boundary import freeze_boundary
 from .claims import evaluate_claims
-from .config import ensure_repo_config, load_repo_config, run_repo_automation, validate_repo_config
+from .config import ensure_repo_config, load_repo_config, resolve_feature_create_auto_scaffold, run_repo_automation, validate_repo_config
 from .documents import (
     create_document,
     create_document_reservation,
@@ -24,7 +24,9 @@ from .entity_ops import (
     add_release_boundaries,
     add_release_claims,
     add_release_evidence,
+    audit_feature_parent_links,
     create_entity,
+    create_feature_with_scaffolded_proof_graph,
     delete_entity,
     get_entity,
     link_entities,
@@ -36,6 +38,7 @@ from .entity_ops import (
     remove_release_boundaries,
     remove_release_claims,
     remove_release_evidence,
+    migrate_feature_parent_audit_edge,
     set_claim_status,
     set_claim_tier,
     set_feature_parents,
@@ -60,6 +63,7 @@ from .load import load_registry
 from .plan import plan_features, plan_issues
 from .packs import inspect_pack, preflight_pack, sync_pack
 from .origin import sync_origin_assurance_rows
+from .proof_graph import certify_feature_proof_graphs
 from .registry import export_registry
 from .release import certify_release, promote_release, publish_release, revoke_release
 from .save import save_registry, save_registry_unchecked
@@ -77,6 +81,7 @@ __all__ = [
     "ensure_repo_config",
     "load_repo_config",
     "validate_repo_config",
+    "resolve_feature_create_auto_scaffold",
     "run_repo_automation",
     "create_document",
     "get_document",
@@ -93,6 +98,7 @@ __all__ = [
     "create_document_reservation",
     "list_document_reservations",
     "create_entity",
+    "create_feature_with_scaffolded_proof_graph",
     "get_entity",
     "list_entities",
     "update_entity",
@@ -111,6 +117,8 @@ __all__ = [
     "add_feature_children",
     "remove_feature_children",
     "list_feature_children",
+    "audit_feature_parent_links",
+    "migrate_feature_parent_audit_edge",
     "add_release_boundaries",
     "remove_release_boundaries",
     "add_release_claims",
@@ -123,6 +131,7 @@ __all__ = [
     "preflight_pack",
     "sync_pack",
     "sync_origin_assurance_rows",
+    "certify_feature_proof_graphs",
     "set_feature_lifecycle",
     "build_artifact_manifest",
     "build_local_evidence_bundle",

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/src/ssot_registry/api/config.py

@@ -24,6 +24,13 @@ _DEFAULT_CONFIG: dict[str, Any] = {
         "interactive": False,
         "fail_closed": True,
     },
+    "commands": {
+        "feature": {
+            "create": {
+                "auto_scaffold_proof_graph": True,
+            }
+        }
+    },
     "sync": {
         "docs": "manual",
         "templates": "manual",
@@ -51,6 +58,9 @@ _DEFAULT_TEMPLATE = """[policy]
 interactive = false
 fail_closed = true
 
+[commands.feature.create]
+auto_scaffold_proof_graph = true
+
 [sync]
 docs = "manual"
 templates = "manual"
@@ -148,6 +158,11 @@ def validate_repo_config_payload(config: dict[str, Any]) -> dict[str, Any]:
     _expect_bool(policy, "interactive", prefix="policy")
     _expect_bool(policy, "fail_closed", prefix="policy")
 
+    commands = _expect_table(normalized, "commands")
+    feature_commands = _expect_table(commands, "feature")
+    feature_create = _expect_table(feature_commands, "create")
+    _expect_bool(feature_create, "auto_scaffold_proof_graph", prefix="commands.feature.create")
+
     sync = _expect_table(normalized, "sync")
     for field_name in ("docs", "templates", "upstream_packages"):
         _expect_choice(sync, field_name, _AUTOMATION_MODE_CHOICES, prefix="sync")
@@ -226,6 +241,17 @@ def validate_repo_config(path: str | Path) -> dict[str, Any]:
     }
 
 
+def resolve_feature_create_auto_scaffold(path: str | Path, explicit: bool | None) -> bool:
+    if explicit is not None:
+        return explicit
+    try:
+        payload = load_repo_config(path)
+    except FileNotFoundError:
+        return bool(_DEFAULT_CONFIG["commands"]["feature"]["create"]["auto_scaffold_proof_graph"])
+    feature_create = payload["config"]["commands"]["feature"]["create"]
+    return bool(feature_create["auto_scaffold_proof_graph"])
+
+
 def run_repo_automation(path: str | Path) -> dict[str, Any]:
     global _AUTOMATION_DEPTH
 

{ssot_core-0.2.20.dev1 → ssot_core-0.2.21.dev1}/src/ssot_registry/api/entity_ops.py

@@ -4,9 +4,10 @@ from copy import deepcopy
 from pathlib import Path
 from typing import Any
 
-from ssot_registry.model.enums import ASSURANCE_ENTITY_SECTIONS, ASSURANCE_ORIGINS, REF_FIELD_TARGETS
+from ssot_registry.model.enums import ASSURANCE_ENTITY_SECTIONS, ASSURANCE_ORIGINS, CLAIM_TIER_RANK, REF_FIELD_TARGETS
 from ssot_registry.model.registry import normalize_repo_kind
 from ssot_registry.util.errors import ValidationError
+from ssot_registry.util.jsonio import stable_json_dumps
 
 from .load import load_registry
 from .save import save_registry
@@ -52,6 +53,9 @@ LINKABLE_FIELDS = {
 }
 
 SECTIONS = tuple(SECTION_LABELS)
+PARENT_AUDIT_TERMS = ("requires", "require", "required", "depends", "dependency", "prerequisite", "blocks", "blocked", "before")
+PARENT_AUDIT_TARGET_HORIZONS = {"current", "explicit"}
+PARENT_AUDIT_INCOMPLETE_STATUSES = {"absent", "partial"}
 
 
 def _row_lookup(registry: dict[str, Any], section: str) -> dict[str, dict[str, Any]]:
@@ -192,6 +196,160 @@ def _validate_and_save(registry_path: Path, repo_root: Path, registry: dict[str,
     }
 
 
+def _safe_slug(entity_id: str) -> str:
+    return entity_id.split(":", 1)[-1].replace("/", ".").replace(" ", "-").lower()
+
+
+def _tier_sequence(target_tier: str) -> list[str]:
+    if target_tier not in CLAIM_TIER_RANK:
+        raise ValueError(f"Unsupported claim tier: {target_tier}")
+    return [tier for tier, _rank in sorted(CLAIM_TIER_RANK.items(), key=lambda item: item[1]) if CLAIM_TIER_RANK[tier] <= CLAIM_TIER_RANK[target_tier]]
+
+
+def _ensure_scaffold_file(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists():
+        path.write_text(content, encoding="utf-8")
+
+
+def create_feature_with_scaffolded_proof_graph(path: str | Path, row: dict[str, Any]) -> dict[str, Any]:
+    registry_path, repo_root, registry = load_registry(path)
+    entity_id = row.get("id")
+    if not isinstance(entity_id, str):
+        raise ValueError("feature row must include a string id")
+    if entity_id in _row_lookup(registry, "features"):
+        raise ValueError(f"Feature already exists: {entity_id}")
+
+    candidate = deepcopy(row)
+    _ensure_assurance_origin(registry, "features", candidate)
+    candidate.setdefault("parent_feature_ids", [])
+    _normalize_feature_parent_ids(candidate)
+    for field_name in LINKABLE_FIELDS["features"]:
+        if field_name in candidate and isinstance(candidate[field_name], list):
+            candidate[field_name] = _dedupe_preserve(candidate[field_name])
+    _validate_assurance_origin_mutation(registry, "features", candidate)
+
+    plan = candidate.get("plan") if isinstance(candidate.get("plan"), dict) else {}
+    target_tier = str(plan.get("target_claim_tier") or "T1")
+    tiers = _tier_sequence(target_tier)
+    slug = _safe_slug(entity_id)
+    evidence_id = f"evd:{target_tier.lower()}.{slug}.proof-graph"
+    evidence_path = f".ssot/evidence/{slug}/proof-graph-{target_tier.lower()}.json"
+    claim_ids = [f"clm:{slug}.{tier.lower()}" for tier in tiers]
+    test_ids = [f"tst:pytest.{slug}.{tier.lower()}.proof-graph" for tier in tiers]
+    test_path_by_tier = {
+        tier: f"tests/ssot_scaffold/test_{slug.replace('.', '_').replace('-', '_')}_{tier.lower()}_proof_graph.py"
+        for tier in tiers
+    }
+
+    claims: list[dict[str, Any]] = []
+    for index, tier in enumerate(tiers):
+        claim_ids_in_chain = claim_ids[: index + 1]
+        claim = {
+            "id": claim_ids[index],
+            "title": f"{candidate['title']} {tier} claim",
+            "status": "declared" if tier == "T0" else "proposed",
+            "tier": tier,
+            "kind": "runtime",
+            "description": f"{tier} scaffold claim for {entity_id}.",
+            "origin": candidate["origin"],
+            "feature_ids": [entity_id],
+            "test_ids": [test_ids[index]],
+            "evidence_ids": [evidence_id],
+            "depends_on_claim_ids": claim_ids_in_chain[:-1],
+        }
+        claims.append(claim)
+
+    test_rows: list[dict[str, Any]] = []
+    for index, tier in enumerate(tiers):
+        test_path = test_path_by_tier[tier]
+        test_rows.append(
+            {
+                "id": test_ids[index],
+                "title": f"{candidate['title']} {tier} proof-graph scaffold test",
+                "body": f"Planned scaffold test for {entity_id} {tier} support.",
+                "origin": candidate["origin"],
+                "status": "planned",
+                "kind": "pytest",
+                "path": test_path,
+                "feature_ids": [entity_id],
+                "claim_ids": [claim_ids[index]],
+                "evidence_ids": [evidence_id],
+                "execution": {
+                    "argv": ["python", "-m", "pytest", test_path, "-q"],
+                    "cwd": ".",
+                    "env": {},
+                    "mode": "command",
+                    "success": {"expected": 0, "type": "exit_code"},
+                    "timeout_seconds": 600,
+                },
+            }
+        )
+    evidence_row = {
+        "id": evidence_id,
+        "title": f"{candidate['title']} proof-graph scaffold evidence",
+        "status": "planned",
+        "kind": "scaffold",
+        "tier": target_tier,
+        "body": f"Planned scaffold evidence for {entity_id}.",
+        "origin": candidate["origin"],
+        "path": evidence_path,
+        "claim_ids": claim_ids,
+        "test_ids": test_ids,
+    }
+
+    candidate["claim_ids"] = _dedupe_preserve([*claim_ids, *_ensure_list_field(candidate, "claim_ids")])
+    candidate["test_ids"] = _dedupe_preserve([*test_ids, *_ensure_list_field(candidate, "test_ids")])
+    registry["features"].append(candidate)
+    registry.setdefault("claims", []).extend(claims)
+    registry.setdefault("tests", []).extend(test_rows)
+    registry.setdefault("evidence", []).append(evidence_row)
+
+    for created in claims:
+        _sync_reciprocals_for_row(registry, "claims", created)
+    for created in test_rows:
+        _sync_reciprocals_for_row(registry, "tests", created)
+    _sync_reciprocals_for_row(registry, "evidence", evidence_row)
+    _sync_reciprocals_for_row(registry, "features", candidate)
+
+    for test_path in test_path_by_tier.values():
+        _ensure_scaffold_file(
+            repo_root / test_path,
+            "def test_ssot_scaffold_placeholder():\n    assert True\n",
+        )
+    _ensure_scaffold_file(
+        repo_root / evidence_path,
+        stable_json_dumps(
+            {
+                "schema_version": "ssot.evidence.scaffold.v1",
+                "feature_id": entity_id,
+                "claim_ids": claim_ids,
+                "test_ids": test_ids,
+                "target_tier": target_tier,
+                "status": "planned",
+            }
+        ),
+    )
+
+    mutation = _validate_and_save(registry_path, repo_root, registry, f"creating feature {entity_id} with scaffolded proof graph")
+    return {
+        "passed": True,
+        "registry_path": registry_path.as_posix(),
+        "section": "features",
+        "entity": candidate,
+        "scaffolded": {
+            "claim_ids": claim_ids,
+            "test_id": test_ids[-1],
+            "test_ids": test_ids,
+            "evidence_id": evidence_id,
+            "test_path": test_path_by_tier[tiers[-1]],
+            "test_paths": [test_path_by_tier[tier] for tier in tiers],
+            "evidence_path": evidence_path,
+        },
+        **mutation,
+    }
+
+
 def _rewrite_references_for_renamed_id(
     registry: dict[str, Any],
     *,
@@ -486,6 +644,112 @@ def list_feature_children(path: str | Path, parent_id: str) -> list[dict[str, An
     return sorted(rows, key=lambda row: row["id"])
 
 
+def _audit_text(row: dict[str, Any]) -> str:
+    return " ".join(str(row.get(field_name, "")) for field_name in ("id", "title", "description", "body")).lower()
+
+
+def audit_feature_parent_links(path: str | Path) -> dict[str, Any]:
+    registry_path, _repo_root, registry = load_registry(path)
+    feature_lookup = _row_lookup(registry, "features")
+    findings: list[dict[str, Any]] = []
+
+    for feature in sorted(feature_lookup.values(), key=lambda row: row["id"]):
+        feature_id = str(feature["id"])
+        parent_ids = feature.get("parent_feature_ids", [])
+        if not isinstance(parent_ids, list):
+            continue
+        for parent_id in sorted(dict.fromkeys(parent_ids)):
+            parent = feature_lookup.get(parent_id)
+            if parent is None:
+                continue
+
+            reasons: list[str] = []
+            feature_horizon = feature.get("plan", {}).get("horizon") if isinstance(feature.get("plan"), dict) else None
+            parent_status = parent.get("implementation_status")
+            if (feature_horizon in PARENT_AUDIT_TARGET_HORIZONS or feature.get("implementation_status") == "implemented") and (
+                parent_status in PARENT_AUDIT_INCOMPLETE_STATUSES
+            ):
+                reasons.append("targeted_or_implemented_child_has_incomplete_parent")
+
+            combined_text = f"{_audit_text(feature)} {_audit_text(parent)}"
+            matched_terms = [term for term in PARENT_AUDIT_TERMS if term in combined_text]
+            if matched_terms:
+                reasons.append(f"dependency_language:{','.join(matched_terms)}")
+
+            if not reasons:
+                continue
+
+            confidence = "high" if len(reasons) > 1 else "medium"
+            if reasons == [reason for reason in reasons if reason.startswith("dependency_language:")]:
+                confidence = "low"
+            findings.append(
+                {
+                    "feature_id": feature_id,
+                    "parent_feature_id": parent_id,
+                    "reason": reasons,
+                    "suggested_requires_edge": {"feature_id": feature_id, "requires": parent_id},
+                    "confidence": confidence,
+                }
+            )
+
+    return {
+        "passed": True,
+        "registry_path": registry_path.as_posix(),
+        "findings": findings,
+        "summary": {
+            "finding_count": len(findings),
+            "high_confidence_count": sum(1 for finding in findings if finding["confidence"] == "high"),
+            "medium_confidence_count": sum(1 for finding in findings if finding["confidence"] == "medium"),
+            "low_confidence_count": sum(1 for finding in findings if finding["confidence"] == "low"),
+        },
+    }
+
+
+def migrate_feature_parent_audit_edge(
+    path: str | Path,
+    feature_id: str,
+    parent_id: str,
+    *,
+    remove_parent_link: bool = False,
+) -> dict[str, Any]:
+    registry_path, repo_root, registry = load_registry(path)
+    feature_lookup = _row_lookup(registry, "features")
+    if feature_id not in feature_lookup:
+        raise ValueError(f"Unknown feature id: {feature_id}")
+    if parent_id not in feature_lookup:
+        raise ValueError(f"Unknown parent feature id: {parent_id}")
+
+    feature = feature_lookup[feature_id]
+    parent_ids = _ensure_list_field(feature, "parent_feature_ids")
+    if parent_id not in parent_ids:
+        raise ValueError(f"Feature {feature_id} does not have parent link {parent_id}")
+
+    requires = _ensure_list_field(feature, "requires")
+    added_requires = parent_id not in requires
+    if added_requires:
+        requires.append(parent_id)
+        feature["requires"] = _dedupe_preserve(requires)
+
+    removed_parent_link = False
+    if remove_parent_link:
+        feature["parent_feature_ids"] = _dedupe_sorted([value for value in parent_ids if value != parent_id])
+        removed_parent_link = True
+    else:
+        _normalize_feature_parent_ids(feature)
+
+    mutation = _validate_and_save(registry_path, repo_root, registry, "migrating feature parent audit edge")
+    return {
+        "passed": True,
+        "registry_path": registry_path.as_posix(),
+        "feature_id": feature_id,
+        "parent_feature_id": parent_id,
+        "added_requires": added_requires,
+        "removed_parent_link": removed_parent_link,
+        "entity": deepcopy(feature),
+        **mutation,
+    }
+
+
 def set_claim_tier(path: str | Path, claim_id: str, tier: str) -> dict[str, Any]:
     registry_path, repo_root, registry = load_registry(path)
     row = _entity_row(registry, "claims", claim_id)