agent-lifecycle-kit 1.50.1__py3-none-any.whl

agent_lifecycle/policy/proposals.py

@@ -0,0 +1,189 @@
+"""Build read-only lifecycle policy tuning proposals."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_digest
+from agent_lifecycle.metrics import summarize_regression_signals
+from agent_lifecycle.policy.quality_floor import is_downgrade, protected_work
+
+PROPOSAL_SCHEMA = "agent-lifecycle-policy-proposal.v1"
+SUMMARY_SCHEMA = "agent-lifecycle-policy-summary.v1"
+RECOMMENDATION_SCHEMA = "agent-lifecycle-recommendation.v1"
+
+
+def build_policy_proposal(
+    recommendation: dict[str, Any],
+    *,
+    regression_signals: list[dict[str, Any]] | None = None,
+    risk_flags: list[str] | None = None,
+    proposal_id: str = "lifecycle-policy-proposal",
+) -> dict[str, Any]:
+    blockers = _recommendation_blockers(recommendation)
+    regression_summary = summarize_regression_signals(regression_signals)
+    if regression_summary["status"] == "FAIL":
+        blockers.extend(regression_summary["blockers"])
+    if blockers:
+        body = _base_proposal(proposal_id, recommendation, regression_summary, status="FAIL")
+        body.update({"applyAllowed": False, "refusalReasons": blockers, "candidateChanges": []})
+        return _with_summary_and_digest(body)
+
+    before = str(recommendation.get("currentMode") or recommendation.get("recommendedMode") or "standard")
+    after = str(recommendation.get("recommendedMode") or before)
+    protected = protected_work(recommendation, risk_flags=risk_flags)
+    refusing = _refusal_reasons(recommendation, regression_summary, before=before, after=after, protected=protected)
+    candidate_changes = [_candidate_change(recommendation, before=before, after=after, applies=not refusing)]
+    body = _base_proposal(proposal_id, recommendation, regression_summary, status="PASS")
+    body.update(
+        {
+            "applyAllowed": not refusing,
+            "refusalReasons": refusing,
+            "candidateChanges": candidate_changes,
+            "expectedBenefit": _expected_benefit(recommendation, before=before, after=after),
+            "qualityConstraints": _quality_constraints(recommendation, protected=protected),
+            "rollback": _rollback(candidate_changes),
+        }
+    )
+    return _with_summary_and_digest(body)
+
+
+def build_policy_summary(proposal: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "schemaVersion": SUMMARY_SCHEMA,
+        "latestUserIntent": "Tune lifecycle policy only when it reduces overhead without lowering required quality.",
+        "activeDecisions": [
+            f"status={proposal.get('status')}",
+            f"applyAllowed={proposal.get('applyAllowed')}",
+            f"proposalId={proposal.get('proposalId')}",
+        ],
+        "openBlockers": list(proposal.get("refusalReasons", [])),
+        "acceptedEvidence": [
+            {
+                "id": "policy-proposal",
+                "status": proposal.get("status"),
+                "applyAllowed": proposal.get("applyAllowed") is True,
+            }
+        ],
+        "changedFiles": [],
+        "nextRequiredAction": "review proposal and apply only with explicit approval",
+        "doNotDo": [
+            "Do not auto-apply policy changes.",
+            "Do not reduce validation for protected task classes.",
+        ],
+        "applyAllowed": proposal.get("applyAllowed") is True,
+        "candidateChanges": proposal.get("candidateChanges", [])[:8],
+        "qualityConstraints": proposal.get("qualityConstraints", {}),
+    }
+
+
+def require_policy_proposal_pass(proposal: dict[str, Any]) -> dict[str, Any]:
+    if proposal.get("status") == "FAIL":
+        raise LifecycleError("policy-proposal-failed", "policy proposal validation failed", {"proposal": proposal})
+    return proposal
+
+
+def _recommendation_blockers(recommendation: dict[str, Any]) -> list[dict[str, Any]]:
+    blockers: list[dict[str, Any]] = []
+    if recommendation.get("schemaVersion") != RECOMMENDATION_SCHEMA:
+        blockers.append({"code": "policy-recommendation-schema"})
+    if recommendation.get("status") != "PASS":
+        blockers.append({"code": "policy-recommendation-status", "status": recommendation.get("status")})
+    if recommendation.get("advisoryOnly") is not True or recommendation.get("autoApply") is not False:
+        blockers.append({"code": "policy-recommendation-safety-flags"})
+    if recommendation.get("qualityFloorPreserved") is not True:
+        blockers.append({"code": "policy-recommendation-quality-floor"})
+    return blockers
+
+
+def _refusal_reasons(
+    recommendation: dict[str, Any],
+    regression_summary: dict[str, Any],
+    *,
+    before: str,
+    after: str,
+    protected: bool,
+) -> list[dict[str, Any]]:
+    reasons: list[dict[str, Any]] = []
+    if recommendation.get("confidence") == "LOW":
+        reasons.append({"code": "policy-low-confidence"})
+    if before == after:
+        reasons.append({"code": "policy-no-change", "mode": before})
+    if protected and is_downgrade(before, after):
+        reasons.append({"code": "policy-protected-downgrade", "before": before, "after": after})
+    if regression_summary["status"] == "BLOCK":
+        reasons.append({"code": "policy-regression-signals", "count": len(regression_summary["blockingSignals"])})
+    return reasons
+
+
+def _base_proposal(
+    proposal_id: str,
+    recommendation: dict[str, Any],
+    regression_summary: dict[str, Any],
+    *,
+    status: str,
+) -> dict[str, Any]:
+    return {
+        "schemaVersion": PROPOSAL_SCHEMA,
+        "status": status,
+        "proposalId": proposal_id,
+        "taskShape": recommendation.get("taskShape"),
+        "sourceRecommendationDigest": recommendation.get("recommendationDigest") or canonical_digest(recommendation),
+        "regressionSignals": regression_summary,
+        "advisoryOnly": True,
+        "autoApply": False,
+        "productionPromotionClaimed": False,
+    }
+
+
+def _candidate_change(recommendation: dict[str, Any], *, before: str, after: str, applies: bool) -> dict[str, Any]:
+    task_shape = recommendation.get("taskShape") or "feature"
+    return {
+        "path": f"taskShapes.{task_shape}.defaultMode",
+        "before": before,
+        "after": after,
+        "applies": applies,
+    }
+
+
+def _expected_benefit(recommendation: dict[str, Any], *, before: str, after: str) -> dict[str, Any]:
+    stats = recommendation.get("statistics") if isinstance(recommendation.get("statistics"), dict) else {}
+    selected_signal = stats.get("selectedSignal") if isinstance(stats.get("selectedSignal"), dict) else {}
+    totals = stats.get("totals") if isinstance(stats.get("totals"), dict) else {}
+    pipeline = totals.get("pipelineCompliance", {}) if isinstance(totals.get("pipelineCompliance"), dict) else {}
+    coordination = totals.get("coordination", {}) if isinstance(totals.get("coordination"), dict) else {}
+    return {
+        "kind": "reduce-process-overhead" if is_downgrade(before, after) else "preserve-or-increase-quality",
+        "processOverheadTokens": int(pipeline.get("tokens", 0)) + int(coordination.get("tokens", 0)),
+        "pipelineTokenShare": (stats.get("ratios") or {}).get("pipelineTokenShare", 0.0),
+        "localAverageTokens": selected_signal.get("averageTokens"),
+        "localSuccessRate": selected_signal.get("successRate"),
+    }
+
+
+def _quality_constraints(recommendation: dict[str, Any], *, protected: bool) -> dict[str, Any]:
+    return {
+        "qualityFloor": recommendation.get("qualityFloor"),
+        "qualityFloorPreserved": True,
+        "protectedWork": protected,
+        "nonNegotiable": [
+            "acceptance evidence",
+            "final proof",
+            "security review for security-sensitive work",
+            "release review for release work",
+            "adapter promotion evidence for adapter maturity claims",
+        ],
+    }
+
+
+def _rollback(changes: list[dict[str, Any]]) -> dict[str, Any]:
+    return {
+        "strategy": "restore previous policy values and rerun recommendation",
+        "restore": [{"path": item["path"], "value": item["before"]} for item in changes],
+        "requiresReview": True,
+    }
+
+
+def _with_summary_and_digest(body: dict[str, Any]) -> dict[str, Any]:
+    body["compactSummary"] = build_policy_summary(body)
+    return {**body, "proposalDigest": canonical_digest(body)}

agent_lifecycle/policy/quality_floor.py

@@ -0,0 +1,144 @@
+"""Quality-floor helpers for lifecycle policy proposals and decisions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_lifecycle.contracts import canonical_digest
+from agent_lifecycle.metrics.costs import DEFAULT_MODE_LIMITS
+
+MODES = tuple(DEFAULT_MODE_LIMITS)
+PROTECTED_TASK_SHAPES = {"adapter", "architecture", "release"}
+PROTECTED_RISKS = {"security", "contracts", "adapter", "architecture", "release", "migration", "dataMigration", "S2"}
+QUALITY_FLOOR_DECISION_SCHEMA = "agent-lifecycle-quality-floor-decision.v1"
+REQUIRED_EVIDENCE_FLOORS = {
+    "adapter-promotion": "release",
+    "production-promotion": "release",
+    "release-proof": "release",
+    "bug-forensics": "strict",
+    "cross-check": "strict",
+    "proof-integrity": "strict",
+    "sandbox": "strict",
+    "security-review": "strict",
+}
+
+
+def mode_index(mode: str | None) -> int:
+    return MODES.index(mode) if mode in MODES else MODES.index("standard")
+
+
+def is_downgrade(before: str | None, after: str | None) -> bool:
+    return mode_index(after) < mode_index(before)
+
+
+def max_mode(*modes: str | None) -> str:
+    valid = [mode for mode in modes if mode in MODES]
+    if not valid:
+        return "standard"
+    return max(valid, key=mode_index)
+
+
+def quality_floor_mode(
+    *,
+    task_shape: str,
+    baseline_profile: dict[str, Any],
+    sdd_tier: str | None = None,
+    risk_flags: list[str] | dict[str, Any] | None = None,
+    required_evidence: list[str] | None = None,
+) -> str:
+    """Return the minimum safe lifecycle mode for the given neutral inputs."""
+
+    return resolve_quality_floor(
+        task_shape=task_shape,
+        baseline_profile=baseline_profile,
+        sdd_tier=sdd_tier,
+        risk_flags=risk_flags,
+        required_evidence=required_evidence,
+    )["qualityFloor"]
+
+
+def resolve_quality_floor(
+    *,
+    task_shape: str,
+    baseline_profile: dict[str, Any],
+    sdd_tier: str | None = None,
+    risk_flags: list[str] | dict[str, Any] | None = None,
+    required_evidence: list[str] | None = None,
+) -> dict[str, Any]:
+    """Build a deterministic quality-floor receipt from baseline policy inputs."""
+
+    blockers: list[dict[str, Any]] = []
+    reasons: list[str] = []
+    risks = _risk_list(risk_flags)
+    evidence = sorted({item for item in (required_evidence or []) if isinstance(item, str) and item})
+    shapes = baseline_profile.get("taskShapes") if isinstance(baseline_profile, dict) else None
+    shape_config = shapes.get(task_shape) if isinstance(shapes, dict) and isinstance(shapes.get(task_shape), dict) else None
+    floor = "standard"
+    min_mode: str | None = None
+    if shape_config is None:
+        blockers.append({"code": "quality-floor-task-shape-missing", "taskShape": task_shape})
+        reasons.append("task-shape-missing")
+    else:
+        min_mode = shape_config.get("minMode") if isinstance(shape_config.get("minMode"), str) else None
+        if min_mode not in MODES:
+            blockers.append({"code": "quality-floor-min-mode-invalid", "taskShape": task_shape, "mode": min_mode})
+            reasons.append("task-shape-min-mode-invalid")
+        else:
+            floor = min_mode
+            reasons.append(f"task-shape-min-mode-{floor}")
+        if shape_config.get("highRisk") is True:
+            floor = max_mode(floor, "strict")
+            reasons.append("task-shape-high-risk")
+
+    risk_floors = baseline_profile.get("riskFloors") if isinstance(baseline_profile, dict) else None
+    if not isinstance(risk_floors, dict):
+        blockers.append({"code": "quality-floor-risk-floors-invalid"})
+        risk_floors = {}
+    for risk in [*risks, sdd_tier]:
+        if isinstance(risk, str) and risk in risk_floors:
+            risk_floor = risk_floors[risk]
+            if risk_floor in MODES:
+                floor = max_mode(floor, str(risk_floor))
+                reasons.append(f"risk-floor-{risk}-{risk_floor}")
+            else:
+                blockers.append({"code": "quality-floor-risk-mode-invalid", "risk": risk, "mode": risk_floor})
+    for item in evidence:
+        evidence_floor = REQUIRED_EVIDENCE_FLOORS.get(item)
+        if evidence_floor is not None:
+            floor = max_mode(floor, evidence_floor)
+            reasons.append(f"evidence-floor-{item}-{evidence_floor}")
+
+    body = {
+        "schemaVersion": QUALITY_FLOOR_DECISION_SCHEMA,
+        "status": "PASS" if not blockers else "FAIL",
+        "taskShape": task_shape,
+        "sddTier": sdd_tier,
+        "riskFlags": risks,
+        "requiredEvidence": evidence,
+        "minMode": min_mode,
+        "qualityFloor": floor,
+        "reasonCodes": reasons,
+        "blockers": blockers,
+        "baselineProfileDigest": canonical_digest(baseline_profile),
+        "productionPromotionClaimed": False,
+    }
+    return {**body, "floorDigest": canonical_digest(body)}
+
+
+def protected_work(recommendation: dict[str, Any], risk_flags: list[str] | None = None) -> bool:
+    task_shape = recommendation.get("taskShape")
+    quality_floor = recommendation.get("qualityFloor")
+    risks = set(risk_flags or [])
+    if isinstance(task_shape, str) and task_shape in PROTECTED_TASK_SHAPES:
+        return True
+    if isinstance(quality_floor, str) and quality_floor in {"strict", "release"}:
+        return True
+    return bool(risks.intersection(PROTECTED_RISKS))
+
+
+def _risk_list(risk_flags: list[str] | dict[str, Any] | None) -> list[str]:
+    if isinstance(risk_flags, dict):
+        return sorted(str(key) for key, value in risk_flags.items() if value)
+    if isinstance(risk_flags, list):
+        return sorted({item for item in risk_flags if isinstance(item, str) and item})
+    return []

agent_lifecycle/policy/runtime_receipts.py

@@ -0,0 +1,160 @@
+"""Runtime policy receipts for enforceable or advisory host decisions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_digest
+
+RUNTIME_POLICY_RECEIPT_SCHEMA = "agent-runtime-policy-receipt.v1"
+RUNTIME_POLICY_RECEIPT_VALIDATION_SCHEMA = "agent-runtime-policy-receipt-validation.v1"
+
+RUNTIME_ACTIONS = {"ALLOW", "DENY", "ASK"}
+ENFORCEMENT_MODES = {"enforced", "advisory"}
+
+
+def build_runtime_policy_receipt(
+    *,
+    policy_id: str,
+    action: str,
+    subject: dict[str, Any],
+    adapter_evidence: dict[str, Any],
+    enforcement_mode: str = "advisory",
+    evidence_ids: list[str] | None = None,
+) -> dict[str, Any]:
+    """Build a receipt without claiming enforcement unless evidence proves it."""
+
+    mode = _enum(enforcement_mode, ENFORCEMENT_MODES, label="enforcementMode")
+    body = {
+        "schemaVersion": RUNTIME_POLICY_RECEIPT_SCHEMA,
+        "status": "PASS",
+        "policyId": _required_string(policy_id, label="policyId"),
+        "action": _enum(action, RUNTIME_ACTIONS, label="action"),
+        "subject": _object(subject, label="subject"),
+        "adapterEvidence": _object(adapter_evidence, label="adapterEvidence"),
+        "enforcementMode": mode,
+        "enforcementClaimed": mode == "enforced",
+        "advisoryOnly": mode == "advisory",
+        "decisionRecordedBeforeExecution": adapter_evidence.get("decisionRecordedBeforeExecution") is True,
+        "evidenceIds": _string_list(evidence_ids or [], label="evidenceIds", allow_empty=True),
+        "blockers": [],
+        "productionPromotionClaimed": False,
+    }
+    blockers = _runtime_policy_blockers(body)
+    body["status"] = "PASS" if not blockers else "FAIL"
+    body["blockers"] = blockers
+    return {**body, "receiptDigest": canonical_digest(body)}
+
+
+def validate_runtime_policy_receipt(receipt: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(receipt, dict):
+        raise LifecycleError("invalid-runtime-policy-receipt", "runtime policy receipt must be an object")
+    blockers: list[dict[str, Any]] = []
+    if receipt.get("schemaVersion") != RUNTIME_POLICY_RECEIPT_SCHEMA:
+        blockers.append({"code": "runtime-policy-receipt-schema-invalid"})
+    if receipt.get("status") not in {"PASS", "FAIL"}:
+        blockers.append({"code": "runtime-policy-receipt-status-invalid"})
+    if not isinstance(receipt.get("policyId"), str) or not receipt["policyId"]:
+        blockers.append({"code": "runtime-policy-id-missing"})
+    if receipt.get("action") not in RUNTIME_ACTIONS:
+        blockers.append({"code": "runtime-policy-action-invalid", "action": receipt.get("action")})
+    if not isinstance(receipt.get("subject"), dict) or not receipt["subject"]:
+        blockers.append({"code": "runtime-policy-subject-invalid"})
+    if not isinstance(receipt.get("adapterEvidence"), dict) or not receipt["adapterEvidence"]:
+        blockers.append({"code": "runtime-policy-adapter-evidence-invalid"})
+    if receipt.get("enforcementMode") not in ENFORCEMENT_MODES:
+        blockers.append({"code": "runtime-policy-enforcement-mode-invalid"})
+    if not isinstance(receipt.get("enforcementClaimed"), bool):
+        blockers.append({"code": "runtime-policy-enforcement-claim-invalid"})
+    if not isinstance(receipt.get("advisoryOnly"), bool):
+        blockers.append({"code": "runtime-policy-advisory-flag-invalid"})
+    if not isinstance(receipt.get("decisionRecordedBeforeExecution"), bool):
+        blockers.append({"code": "runtime-policy-decision-timing-invalid"})
+    if not isinstance(receipt.get("evidenceIds", []), list) or not all(
+        isinstance(item, str) and item for item in receipt.get("evidenceIds", [])
+    ):
+        blockers.append({"code": "runtime-policy-evidence-ids-invalid"})
+    if not isinstance(receipt.get("blockers", []), list) or not all(
+        isinstance(item, dict) for item in receipt.get("blockers", [])
+    ):
+        blockers.append({"code": "runtime-policy-blockers-invalid"})
+    if receipt.get("productionPromotionClaimed") is not False:
+        blockers.append({"code": "runtime-policy-production-claim"})
+    semantic_blockers = _runtime_policy_blockers(receipt) if not blockers else []
+    if not blockers:
+        if receipt.get("blockers", []) != semantic_blockers:
+            blockers.append({"code": "runtime-policy-blockers-mismatch"})
+        blockers.extend(semantic_blockers)
+        expected_status = "PASS" if not semantic_blockers else "FAIL"
+        if receipt.get("status") != expected_status:
+            blockers.append({"code": "runtime-policy-status-mismatch"})
+    expected_digest = canonical_digest({key: value for key, value in receipt.items() if key != "receiptDigest"})
+    if receipt.get("receiptDigest") != expected_digest:
+        blockers.append({"code": "runtime-policy-receipt-digest-mismatch"})
+    body = {
+        "schemaVersion": RUNTIME_POLICY_RECEIPT_VALIDATION_SCHEMA,
+        "status": "PASS" if not blockers else "FAIL",
+        "receiptStatus": receipt.get("status") if isinstance(receipt.get("status"), str) else None,
+        "policyId": receipt.get("policyId") if isinstance(receipt.get("policyId"), str) else None,
+        "action": receipt.get("action") if isinstance(receipt.get("action"), str) else None,
+        "enforcementMode": receipt.get("enforcementMode") if isinstance(receipt.get("enforcementMode"), str) else None,
+        "enforcementClaimed": receipt.get("enforcementClaimed") if isinstance(receipt.get("enforcementClaimed"), bool) else None,
+        "blockers": blockers,
+        "receiptDigest": receipt.get("receiptDigest") if isinstance(receipt.get("receiptDigest"), str) else None,
+    }
+    return {**body, "validationDigest": canonical_digest(body)}
+
+
+def require_runtime_policy_receipt_pass(validation: dict[str, Any]) -> dict[str, Any]:
+    if validation.get("status") != "PASS" or validation.get("receiptStatus") != "PASS":
+        raise LifecycleError("runtime-policy-receipt-validation-failed", "runtime policy receipt did not pass", {"validation": validation})
+    return validation
+
+
+def _runtime_policy_blockers(receipt: dict[str, Any]) -> list[dict[str, Any]]:
+    blockers: list[dict[str, Any]] = []
+    mode = receipt.get("enforcementMode")
+    enforcement_claimed = receipt.get("enforcementClaimed") is True
+    advisory_only = receipt.get("advisoryOnly") is True
+    evidence = receipt.get("adapterEvidence") if isinstance(receipt.get("adapterEvidence"), dict) else {}
+    pre_execution = evidence.get("preExecutionEnforcement") is True
+    decision_before_execution = receipt.get("decisionRecordedBeforeExecution") is True
+    if mode == "enforced" and not enforcement_claimed:
+        blockers.append({"code": "runtime-policy-enforcement-flag-mismatch"})
+    if mode == "advisory" and not advisory_only:
+        blockers.append({"code": "runtime-policy-advisory-flag-mismatch"})
+    if enforcement_claimed and advisory_only:
+        blockers.append({"code": "runtime-policy-enforcement-and-advisory"})
+    if enforcement_claimed and not pre_execution:
+        blockers.append({"code": "runtime-policy-enforcement-unproven"})
+    if enforcement_claimed and not decision_before_execution:
+        blockers.append({"code": "runtime-policy-decision-not-pre-execution"})
+    if not enforcement_claimed and mode == "enforced":
+        blockers.append({"code": "runtime-policy-mode-unproven"})
+    if mode == "advisory" and evidence.get("postFactumOnly") is True and enforcement_claimed:
+        blockers.append({"code": "runtime-policy-post-factum-enforcement-claim"})
+    return blockers
+
+
+def _object(value: Any, *, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or not value:
+        raise LifecycleError("invalid-runtime-policy-receipt", f"{label} must be a non-empty object")
+    return dict(value)
+
+
+def _required_string(value: Any, *, label: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise LifecycleError("invalid-runtime-policy-receipt", f"{label} is required")
+    return value
+
+
+def _string_list(value: Any, *, label: str, allow_empty: bool = False) -> list[str]:
+    if not isinstance(value, list) or (not allow_empty and not value) or not all(isinstance(item, str) and item for item in value):
+        raise LifecycleError("invalid-runtime-policy-receipt", f"{label} must be a list of strings")
+    return list(value)
+
+
+def _enum(value: Any, allowed: set[str], *, label: str) -> str:
+    if value not in allowed:
+        raise LifecycleError("invalid-runtime-policy-receipt", f"{label} is unsupported", {label: value})
+    return str(value)

agent_lifecycle/py.typed

@@ -0,0 +1 @@
+

agent_lifecycle/quality/__init__.py

@@ -0,0 +1,89 @@
+"""Optional quality packs and behavior checks."""
+
+from agent_lifecycle.quality.cross_check import (
+    build_cross_check_profile,
+    build_cross_check_receipt,
+    require_cross_check_profile_pass,
+    require_cross_check_receipt_pass,
+    validate_cross_check_profile,
+    validate_cross_check_receipt,
+)
+from agent_lifecycle.quality.bug_forensics import (
+    build_bug_forensics_profile,
+    build_bug_reproduction_receipt,
+    build_failure_fingerprint,
+    build_hypothesis_ledger,
+    build_regression_proof_receipt,
+    require_bug_forensics_profile_pass,
+    require_bug_reproduction_pass,
+    require_hypothesis_ledger_pass,
+    require_regression_proof_pass,
+    validate_bug_forensics_profile,
+    validate_bug_reproduction_receipt,
+    validate_failure_fingerprint,
+    validate_hypothesis_ledger,
+    validate_regression_proof_receipt,
+)
+from agent_lifecycle.quality.bug_forensics_advisor import (
+    BUG_FORENSICS_ADVISORY_SCHEMA,
+    BUG_FORENSICS_PROFILE_ID,
+    bug_forensics_recommended,
+    build_bug_forensics_advisory,
+)
+from agent_lifecycle.quality.bug_forensics_recipes import (
+    build_bug_forensics_recipe_library,
+    require_bug_forensics_recipe_pass,
+    validate_bug_forensics_recipe_library,
+)
+from agent_lifecycle.quality.failure_classification import (
+    FAILURE_CLASSES,
+    build_failure_classification_receipt,
+    require_failure_classification_pass,
+    validate_failure_classification_receipt,
+)
+from agent_lifecycle.quality.packs import (
+    build_default_quality_pack,
+    require_behavior_checks_pass,
+    require_quality_pack_pass,
+    run_behavior_checks,
+    validate_quality_pack,
+)
+
+__all__ = [
+    "build_cross_check_profile",
+    "build_bug_forensics_profile",
+    "build_bug_forensics_advisory",
+    "build_bug_forensics_recipe_library",
+    "build_bug_reproduction_receipt",
+    "build_cross_check_receipt",
+    "build_failure_fingerprint",
+    "build_failure_classification_receipt",
+    "build_hypothesis_ledger",
+    "build_regression_proof_receipt",
+    "build_default_quality_pack",
+    "require_bug_forensics_profile_pass",
+    "require_bug_forensics_recipe_pass",
+    "require_bug_reproduction_pass",
+    "require_cross_check_profile_pass",
+    "require_cross_check_receipt_pass",
+    "require_failure_classification_pass",
+    "require_hypothesis_ledger_pass",
+    "require_regression_proof_pass",
+    "require_behavior_checks_pass",
+    "require_quality_pack_pass",
+    "bug_forensics_recommended",
+    "run_behavior_checks",
+    "validate_bug_forensics_profile",
+    "validate_bug_forensics_recipe_library",
+    "validate_bug_reproduction_receipt",
+    "validate_cross_check_profile",
+    "validate_cross_check_receipt",
+    "validate_failure_classification_receipt",
+    "validate_failure_fingerprint",
+    "validate_hypothesis_ledger",
+    "validate_regression_proof_receipt",
+    "validate_quality_pack",
+    "FAILURE_CLASSES",
+    "BUG_FORENSICS_ADVISORY_SCHEMA",
+    "BUG_FORENSICS_PROFILE_ID",
+]