agent-lifecycle-kit 2.0.0__tar.gz → 2.1.0__tar.gz

{agent_lifecycle_kit-2.0.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 2.0.0
+Version: 2.1.0
 Summary: Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion.
 Author: Agent Lifecycle Kit contributors
 License: Apache-2.0
@@ -43,7 +43,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.0.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.1.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -187,9 +187,9 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 - Public release claims use tracked source files and redacted evidence summaries.
 - External dialect imports and retrieved episodes enrich context, while reviewed
   ALK artifacts remain the source of truth.
-- Cross-check, Review Mesh and historical runner recovery receipts add evidence
-  when a task or plan enables them; legacy runner records are converted
-  read-only and the operator chooses the review depth.
+- Cross-check, Review Mesh and historical runner recovery receipts add evidence when a task or plan enables them; legacy runner records are converted
+  read-only and the operator chooses the review depth. High-risk criteria can opt into [risk-bound independent verification](docs/reference/risk-bound-independent-verification.md);
+  ordinary criteria remain on the standard evidence path.
 
 ## Documentation
 
@@ -197,6 +197,6 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 - Planning and adapters: [Issue to specification drafts](docs/guides/issue-to-spec.md), [Adapter install](docs/adapters/install.md), and [Adapter support matrix](docs/adapters/support-matrix.md).
 - Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [External verification checks](docs/reference/external-verification-checks.md), [Plan verification](docs/reference/plan-verification.md), [Research evidence](docs/reference/research-evidence.md), [Public locators and redaction](docs/reference/public-locators-and-redaction.md), [Finding-to-check adoption](docs/reference/finding-check-adoption.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
 - Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [performance and resource budgets](docs/reference/performance-and-resource-budgets.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
-- Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner migration](docs/guides/runner-migration-2.md), [Runner recovery records](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
+- Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner migration](docs/guides/runner-migration-2.md), [Runner recovery records](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Risk-bound independent verification](docs/reference/risk-bound-independent-verification.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).
 Apache-2.0. See [LICENSE](LICENSE).

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/README.md

@@ -21,7 +21,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.0.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.1.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -165,9 +165,9 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 - Public release claims use tracked source files and redacted evidence summaries.
 - External dialect imports and retrieved episodes enrich context, while reviewed
   ALK artifacts remain the source of truth.
-- Cross-check, Review Mesh and historical runner recovery receipts add evidence
-  when a task or plan enables them; legacy runner records are converted
-  read-only and the operator chooses the review depth.
+- Cross-check, Review Mesh and historical runner recovery receipts add evidence when a task or plan enables them; legacy runner records are converted
+  read-only and the operator chooses the review depth. High-risk criteria can opt into [risk-bound independent verification](docs/reference/risk-bound-independent-verification.md);
+  ordinary criteria remain on the standard evidence path.
 
 ## Documentation
 
@@ -175,6 +175,6 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 - Planning and adapters: [Issue to specification drafts](docs/guides/issue-to-spec.md), [Adapter install](docs/adapters/install.md), and [Adapter support matrix](docs/adapters/support-matrix.md).
 - Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [External verification checks](docs/reference/external-verification-checks.md), [Plan verification](docs/reference/plan-verification.md), [Research evidence](docs/reference/research-evidence.md), [Public locators and redaction](docs/reference/public-locators-and-redaction.md), [Finding-to-check adoption](docs/reference/finding-check-adoption.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
 - Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [performance and resource budgets](docs/reference/performance-and-resource-budgets.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
-- Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner migration](docs/guides/runner-migration-2.md), [Runner recovery records](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
+- Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner migration](docs/guides/runner-migration-2.md), [Runner recovery records](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Risk-bound independent verification](docs/reference/risk-bound-independent-verification.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).
 Apache-2.0. See [LICENSE](LICENSE).

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "2.0.0"
+version = "2.1.0"
 description = "Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion."
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/src/agent_lifecycle/audit/proof_integrity.py

@@ -2,6 +2,11 @@
 
 from __future__ import annotations
 
+from agent_lifecycle.contracts.independent_evidence_schemas import (
+    require_independent_evidence_pass,
+    validate_independence_requirement,
+    validate_independent_evidence,
+)
 from agent_lifecycle.contracts.proof_validation import (
     DEFAULT_LEGACY_EXEMPTIONS,
     FINDING_SCHEMA,
@@ -46,11 +51,14 @@ __all__ = [
     "build_receipt_hash_chain",
     "build_root_cause_evidence",
     "finding_identity_fields",
+    "require_independent_evidence_pass",
     "require_proof_integrity_pass",
     "stable_finding_id",
     "validate_finding_identity",
     "validate_fix_impact_receipt",
     "validate_hash_chain_migration_policy",
+    "validate_independence_requirement",
+    "validate_independent_evidence",
     "validate_proof_integrity_receipt",
     "validate_receipt_hash_chain",
     "validate_root_cause_evidence",

agent_lifecycle_kit-2.1.0/src/agent_lifecycle/contracts/independent_evidence_schemas.py

@@ -0,0 +1,389 @@
+"""Schemas for criterion-scoped independent evidence."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_digest
+from agent_lifecycle.contracts.schema_builders import open_object_schema
+
+INDEPENDENCE_REQUIREMENT_SCHEMA = "agent-independence-requirement.v1"
+INDEPENDENT_EVIDENCE_SCHEMA = "agent-independent-evidence.v1"
+INDEPENDENT_EVIDENCE_VALIDATION_SCHEMA = "agent-independent-evidence-validation.v1"
+
+INDEPENDENCE_DIMENSIONS = ("producer", "implementation", "source")
+INDEPENDENCE_METHODS = ("deterministic-check", "human-review")
+INDEPENDENCE_SOURCE_POLICIES = ("exact-revision", "current-lineage", "any-current")
+INDEPENDENT_EVIDENCE_STATUSES = ("PASS", "FAIL", "UNAVAILABLE")
+
+INDEPENDENT_EVIDENCE_SCHEMAS = {
+    INDEPENDENCE_REQUIREMENT_SCHEMA: open_object_schema(
+        INDEPENDENCE_REQUIREMENT_SCHEMA,
+        required=[
+            "schemaVersion",
+            "required",
+            "requiredDimensions",
+            "allowedMethods",
+            "prohibitedProducerClasses",
+            "sourcePolicy",
+            "productionPromotionClaimed",
+            "requirementDigest",
+        ],
+        properties={
+            "required": {"type": "boolean"},
+            "requiredDimensions": {"type": "array", "items": {"enum": list(INDEPENDENCE_DIMENSIONS)}},
+            "allowedMethods": {"type": "array", "items": {"enum": list(INDEPENDENCE_METHODS)}},
+            "prohibitedProducerClasses": {"type": "array", "items": {"type": "string", "minLength": 1}},
+            "sourcePolicy": {"enum": list(INDEPENDENCE_SOURCE_POLICIES)},
+            "productionPromotionClaimed": {"const": False},
+            "requirementDigest": {"type": "string", "minLength": 64, "maxLength": 64},
+        },
+    ),
+    INDEPENDENT_EVIDENCE_SCHEMA: open_object_schema(
+        INDEPENDENT_EVIDENCE_SCHEMA,
+        required=[
+            "schemaVersion",
+            "status",
+            "evidenceId",
+            "criterionId",
+            "requirementDigest",
+            "sourceRevision",
+            "sourceLineageDigest",
+            "method",
+            "producerClass",
+            "producerIdentityHash",
+            "implementationDigest",
+            "findings",
+            "unavailableReason",
+            "rawReasoningStored",
+            "rawTranscriptStored",
+            "productionPromotionClaimed",
+            "evidenceDigest",
+        ],
+        properties={
+            "status": {"enum": list(INDEPENDENT_EVIDENCE_STATUSES)},
+            "evidenceId": {"type": "string", "minLength": 1},
+            "criterionId": {"type": "string", "minLength": 1},
+            "requirementDigest": {"type": "string", "minLength": 64, "maxLength": 64},
+            "sourceRevision": {"type": "string", "minLength": 1},
+            "sourceLineageDigest": {"type": "string", "minLength": 64, "maxLength": 64},
+            "method": {"enum": list(INDEPENDENCE_METHODS)},
+            "producerClass": {"type": "string", "minLength": 1},
+            "producerIdentityHash": {"type": "string", "minLength": 64, "maxLength": 64},
+            "implementationDigest": {"type": "string", "minLength": 64, "maxLength": 64},
+            "findings": {"type": "array", "items": {"type": "object"}},
+            "unavailableReason": {"type": ["string", "null"]},
+            "rawReasoningStored": {"const": False},
+            "rawTranscriptStored": {"const": False},
+            "productionPromotionClaimed": {"const": False},
+            "evidenceDigest": {"type": "string", "minLength": 64, "maxLength": 64},
+        },
+    ),
+    INDEPENDENT_EVIDENCE_VALIDATION_SCHEMA: open_object_schema(
+        INDEPENDENT_EVIDENCE_VALIDATION_SCHEMA,
+        required=[
+            "schemaVersion",
+            "status",
+            "evidenceId",
+            "criterionId",
+            "evidenceStatus",
+            "independenceStatus",
+            "blockers",
+            "evidenceDigest",
+            "validationDigest",
+        ],
+        properties={
+            "status": {"enum": ["PASS", "FAIL"]},
+            "evidenceId": {"type": ["string", "null"]},
+            "criterionId": {"type": ["string", "null"]},
+            "evidenceStatus": {"type": ["string", "null"]},
+            "independenceStatus": {"enum": ["REQUIRED_PASS", "OPTIONAL_PASS", "NOT_PROVEN", "UNAVAILABLE"]},
+            "blockers": {"type": "array", "items": {"type": "object"}},
+            "evidenceDigest": {"type": ["string", "null"], "minLength": 0, "maxLength": 64},
+            "validationDigest": {"type": "string", "minLength": 64, "maxLength": 64},
+        },
+    ),
+}
+
+
+def build_independence_requirement(
+    *,
+    required: bool = True,
+    required_dimensions: list[str] | None = None,
+    allowed_methods: list[str] | None = None,
+    prohibited_producer_classes: list[str] | None = None,
+    source_policy: str = "exact-revision",
+) -> dict[str, Any]:
+    """Build a criterion-level independence requirement."""
+
+    body = {
+        "schemaVersion": INDEPENDENCE_REQUIREMENT_SCHEMA,
+        "required": bool(required),
+        "requiredDimensions": list(required_dimensions or INDEPENDENCE_DIMENSIONS),
+        "allowedMethods": list(allowed_methods or INDEPENDENCE_METHODS),
+        "prohibitedProducerClasses": list(prohibited_producer_classes or []),
+        "sourcePolicy": source_policy,
+        "productionPromotionClaimed": False,
+    }
+    body = {**body, "requirementDigest": canonical_digest(body)}
+    validation = validate_independence_requirement(body)
+    if validation["status"] != "PASS":
+        raise LifecycleError(
+            "independence-requirement-invalid",
+            "independence requirement is invalid",
+            {"validation": validation},
+        )
+    return body
+
+
+def validate_independence_requirement(value: Any) -> dict[str, Any]:
+    """Validate a frozen criterion's explicit independence requirement."""
+
+    blockers: list[dict[str, Any]] = []
+    if not isinstance(value, dict):
+        blockers.append({"code": "independence-requirement-object-invalid"})
+        return _requirement_validation(value, blockers)
+    if value.get("schemaVersion") != INDEPENDENCE_REQUIREMENT_SCHEMA:
+        blockers.append({"code": "independence-requirement-schema-invalid"})
+    if not isinstance(value.get("required"), bool):
+        blockers.append({"code": "independence-requirement-required-invalid"})
+    dimensions = value.get("requiredDimensions")
+    if (
+        not isinstance(dimensions, list)
+        or not dimensions
+        or not all(isinstance(item, str) and item in INDEPENDENCE_DIMENSIONS for item in dimensions)
+        or len(dimensions) != len(set(item for item in dimensions if isinstance(item, str)))
+    ):
+        blockers.append({"code": "independence-requirement-dimensions-invalid"})
+    methods = value.get("allowedMethods")
+    if (
+        not isinstance(methods, list)
+        or not methods
+        or not all(isinstance(item, str) and item in INDEPENDENCE_METHODS for item in methods)
+        or len(methods) != len(set(item for item in methods if isinstance(item, str)))
+    ):
+        blockers.append({"code": "independence-requirement-methods-invalid"})
+    producers = value.get("prohibitedProducerClasses")
+    if not isinstance(producers, list) or any(not isinstance(item, str) or not item for item in producers):
+        blockers.append({"code": "independence-requirement-producer-policy-invalid"})
+    if value.get("sourcePolicy") not in INDEPENDENCE_SOURCE_POLICIES:
+        blockers.append({"code": "independence-requirement-source-policy-invalid"})
+    if value.get("productionPromotionClaimed") is not False:
+        blockers.append({"code": "independence-requirement-production-claim"})
+    expected_digest = canonical_digest({key: item for key, item in value.items() if key != "requirementDigest"})
+    if value.get("requirementDigest") != expected_digest:
+        blockers.append({"code": "independence-requirement-digest-mismatch"})
+    return _requirement_validation(value, blockers)
+
+
+def build_independent_evidence(
+    *,
+    evidence_id: str,
+    criterion_id: str,
+    requirement: dict[str, Any],
+    source_revision: str,
+    source_lineage_digest: str,
+    method: str,
+    producer_class: str,
+    producer_identity_hash: str,
+    implementation_digest: str,
+    status: str = "PASS",
+    findings: list[dict[str, Any]] | None = None,
+    unavailable_reason: str | None = None,
+) -> dict[str, Any]:
+    """Build a bounded evidence record without storing reviewer internals."""
+
+    requirement_validation = validate_independence_requirement(requirement)
+    if requirement_validation["status"] != "PASS":
+        raise LifecycleError(
+            "independence-requirement-invalid",
+            "independence requirement is invalid",
+            {"validation": requirement_validation},
+        )
+    body = {
+        "schemaVersion": INDEPENDENT_EVIDENCE_SCHEMA,
+        "status": status,
+        "evidenceId": evidence_id,
+        "criterionId": criterion_id,
+        "requirementDigest": requirement["requirementDigest"],
+        "sourceRevision": source_revision,
+        "sourceLineageDigest": source_lineage_digest,
+        "method": method,
+        "producerClass": producer_class,
+        "producerIdentityHash": producer_identity_hash,
+        "implementationDigest": implementation_digest,
+        "findings": list(findings or []),
+        "unavailableReason": unavailable_reason,
+        "rawReasoningStored": False,
+        "rawTranscriptStored": False,
+        "productionPromotionClaimed": False,
+    }
+    body = {**body, "evidenceDigest": canonical_digest(body)}
+    validation = validate_independent_evidence(body, requirement=requirement)
+    if validation["status"] != "PASS":
+        raise LifecycleError(
+            "independent-evidence-invalid",
+            "independent evidence is invalid",
+            {"validation": validation},
+        )
+    return body
+
+
+def validate_independent_evidence(
+    evidence: Any,
+    *,
+    requirement: dict[str, Any] | None = None,
+    expected_source_revision: str | None = None,
+    expected_source_lineage_digest: str | None = None,
+    primary_producer_class: str | None = None,
+    primary_implementation_digest: str | None = None,
+) -> dict[str, Any]:
+    """Validate evidence and fail closed only when its criterion requires it."""
+
+    blockers: list[dict[str, Any]] = []
+    if not isinstance(evidence, dict):
+        blockers.append({"code": "independent-evidence-object-invalid"})
+        return _evidence_validation(evidence, blockers, "UNAVAILABLE")
+    if evidence.get("schemaVersion") != INDEPENDENT_EVIDENCE_SCHEMA:
+        blockers.append({"code": "independent-evidence-schema-invalid"})
+    _required_text(evidence.get("evidenceId"), "independent-evidence-id-missing", blockers)
+    _required_text(evidence.get("criterionId"), "independent-evidence-criterion-id-missing", blockers)
+    _required_text(evidence.get("sourceRevision"), "independent-evidence-source-revision-missing", blockers)
+    _digest(evidence.get("requirementDigest"), "independent-evidence-requirement-digest-invalid", blockers)
+    _digest(evidence.get("sourceLineageDigest"), "independent-evidence-source-lineage-invalid", blockers)
+    _digest(evidence.get("producerIdentityHash"), "independent-evidence-producer-identity-invalid", blockers)
+    _digest(evidence.get("implementationDigest"), "independent-evidence-implementation-digest-invalid", blockers)
+    if evidence.get("status") not in INDEPENDENT_EVIDENCE_STATUSES:
+        blockers.append({"code": "independent-evidence-status-invalid"})
+    if evidence.get("method") not in INDEPENDENCE_METHODS:
+        blockers.append({"code": "independent-evidence-method-invalid"})
+    _required_text(evidence.get("producerClass"), "independent-evidence-producer-class-missing", blockers)
+    if not isinstance(evidence.get("findings"), list) or not all(
+        isinstance(item, dict) for item in evidence["findings"]
+    ):
+        blockers.append({"code": "independent-evidence-findings-invalid"})
+    if evidence.get("status") == "UNAVAILABLE" and not _non_empty_text(evidence.get("unavailableReason")):
+        blockers.append({"code": "independent-evidence-unavailable-reason-missing"})
+    if evidence.get("status") != "UNAVAILABLE" and evidence.get("unavailableReason") is not None:
+        blockers.append({"code": "independent-evidence-unavailable-reason-unexpected"})
+    if evidence.get("rawReasoningStored") is not False:
+        blockers.append({"code": "independent-evidence-raw-reasoning"})
+    if evidence.get("rawTranscriptStored") is not False:
+        blockers.append({"code": "independent-evidence-raw-transcript"})
+    if evidence.get("productionPromotionClaimed") is not False:
+        blockers.append({"code": "independent-evidence-production-claim"})
+
+    required = False
+    if requirement is not None:
+        requirement_validation = validate_independence_requirement(requirement)
+        if requirement_validation["status"] != "PASS":
+            blockers.append({"code": "independent-evidence-requirement-invalid", "validation": requirement_validation})
+        elif evidence.get("requirementDigest") != requirement.get("requirementDigest"):
+            blockers.append({"code": "independent-evidence-requirement-mismatch"})
+        required = requirement.get("required") is True
+        if evidence.get("method") not in requirement.get("allowedMethods", []):
+            blockers.append({"code": "independent-evidence-method-not-allowed"})
+        if evidence.get("producerClass") in requirement.get("prohibitedProducerClasses", []):
+            blockers.append({"code": "independent-evidence-producer-not-independent"})
+    if expected_source_revision is not None and evidence.get("sourceRevision") != expected_source_revision:
+        blockers.append({"code": "independent-evidence-source-stale"})
+    if (
+        expected_source_lineage_digest is not None
+        and evidence.get("sourceLineageDigest") != expected_source_lineage_digest
+    ):
+        blockers.append({"code": "independent-evidence-lineage-mismatch"})
+    if primary_producer_class is not None and evidence.get("producerClass") == primary_producer_class:
+        blockers.append({"code": "independent-evidence-producer-not-independent"})
+    if (
+        primary_implementation_digest is not None
+        and evidence.get("implementationDigest") == primary_implementation_digest
+    ):
+        blockers.append({"code": "independent-evidence-implementation-not-independent"})
+    if required and evidence.get("status") != "PASS":
+        blockers.append({"code": "independent-evidence-required"})
+
+    expected_digest = canonical_digest({key: item for key, item in evidence.items() if key != "evidenceDigest"})
+    if evidence.get("evidenceDigest") != expected_digest:
+        blockers.append({"code": "independent-evidence-digest-mismatch"})
+    if blockers:
+        independence_status = "UNAVAILABLE" if evidence.get("status") == "UNAVAILABLE" else "NOT_PROVEN"
+    elif required:
+        independence_status = "REQUIRED_PASS"
+    else:
+        independence_status = "OPTIONAL_PASS"
+    return _evidence_validation(evidence, blockers, independence_status)
+
+
+def require_independent_evidence_pass(validation: dict[str, Any]) -> dict[str, Any]:
+    """Require a valid independent evidence record for a declared criterion."""
+
+    if validation.get("status") != "PASS" or validation.get("independenceStatus") != "REQUIRED_PASS":
+        raise LifecycleError(
+            "independent-evidence-required",
+            "required independent evidence did not pass",
+            {"validation": validation},
+        )
+    return validation
+
+
+def _requirement_validation(value: Any, blockers: list[dict[str, Any]]) -> dict[str, Any]:
+    body = {
+        "schemaVersion": "agent-independence-requirement-validation.v1",
+        "status": "PASS" if not blockers else "FAIL",
+        "required": value.get("required")
+        if isinstance(value, dict) and isinstance(value.get("required"), bool)
+        else None,
+        "blockers": blockers,
+    }
+    return {**body, "validationDigest": canonical_digest(body)}
+
+
+def _evidence_validation(value: Any, blockers: list[dict[str, Any]], independence_status: str) -> dict[str, Any]:
+    body = {
+        "schemaVersion": INDEPENDENT_EVIDENCE_VALIDATION_SCHEMA,
+        "status": "PASS" if not blockers else "FAIL",
+        "evidenceId": value.get("evidenceId")
+        if isinstance(value, dict) and isinstance(value.get("evidenceId"), str)
+        else None,
+        "criterionId": value.get("criterionId")
+        if isinstance(value, dict) and isinstance(value.get("criterionId"), str)
+        else None,
+        "evidenceStatus": value.get("status")
+        if isinstance(value, dict) and isinstance(value.get("status"), str)
+        else None,
+        "independenceStatus": independence_status,
+        "blockers": blockers,
+        "evidenceDigest": value.get("evidenceDigest") if isinstance(value, dict) else None,
+    }
+    return {**body, "validationDigest": canonical_digest(body)}
+
+
+def _required_text(value: Any, code: str, blockers: list[dict[str, Any]]) -> None:
+    if not _non_empty_text(value):
+        blockers.append({"code": code})
+
+
+def _non_empty_text(value: Any) -> bool:
+    return isinstance(value, str) and bool(value)
+
+
+def _digest(value: Any, code: str, blockers: list[dict[str, Any]]) -> None:
+    if not isinstance(value, str) or len(value) != 64 or any(char not in "0123456789abcdef" for char in value):
+        blockers.append({"code": code})
+
+
+__all__ = [
+    "INDEPENDENCE_DIMENSIONS",
+    "INDEPENDENCE_METHODS",
+    "INDEPENDENCE_REQUIREMENT_SCHEMA",
+    "INDEPENDENCE_SOURCE_POLICIES",
+    "INDEPENDENT_EVIDENCE_SCHEMA",
+    "INDEPENDENT_EVIDENCE_SCHEMAS",
+    "INDEPENDENT_EVIDENCE_STATUSES",
+    "INDEPENDENT_EVIDENCE_VALIDATION_SCHEMA",
+    "build_independence_requirement",
+    "build_independent_evidence",
+    "require_independent_evidence_pass",
+    "validate_independence_requirement",
+    "validate_independent_evidence",
+]

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/src/agent_lifecycle/contracts/review_mesh_schemas.py

@@ -85,6 +85,7 @@ REVIEW_MESH_SCHEMAS: dict[str, dict[str, Any]] = {
             "blocking": {"type": "boolean"},
             "advisory": {"type": "boolean"},
             "evidenceIds": {"type": "array", "items": {"type": "string", "minLength": 1}},
+            "independenceRequirement": {"type": ["object", "null"]},
             "productionPromotionClaimed": {"const": False},
             "assignmentDigest": {"type": "string", "minLength": 64, "maxLength": 64},
         },
@@ -120,10 +121,12 @@ REVIEW_MESH_SCHEMAS: dict[str, dict[str, Any]] = {
             "phase": {"type": "string", "minLength": 1},
             "subject": {"type": "object"},
             "reviewer": {"type": "object"},
+            "independenceRequirement": {"type": ["object", "null"]},
             "findings": {"type": "array", "items": {"type": "object"}},
             "budgetUsage": {"type": "object"},
             "independence": {"type": "object"},
             "crossCheckReceipt": {"type": "object"},
+            "independentEvidence": {"type": ["object", "null"]},
             "blockers": {"type": "array", "items": {"type": "object"}},
             "productionPromotionClaimed": {"const": False},
             "resultDigest": {"type": "string", "minLength": 64, "maxLength": 64},
@@ -192,6 +195,8 @@ REVIEW_MESH_SCHEMAS: dict[str, dict[str, Any]] = {
             "requiredRolesSatisfied": {"type": "boolean"},
             "quorumSatisfied": {"type": "boolean"},
             "blockingFindingsUnresolved": {"type": "boolean"},
+            "independenceRequirement": {"type": ["object", "null"]},
+            "independentEvidence": {"type": "array", "items": {"type": "object"}},
             "blockers": {"type": "array", "items": {"type": "object"}},
             "productionPromotionClaimed": {"const": False},
             "receiptDigest": {"type": "string", "minLength": 64, "maxLength": 64},

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/src/agent_lifecycle/contracts/schemas.py

@@ -29,6 +29,7 @@ from agent_lifecycle.contracts.external_check_schemas import EXTERNAL_CHECK_SCHE
 from agent_lifecycle.contracts.finding_check_schemas import FINDING_CHECK_SCHEMAS
 from agent_lifecycle.contracts.host_capability_schemas import HOST_CAPABILITY_SCHEMAS
 from agent_lifecycle.contracts.import_dialect_schemas import IMPORT_DIALECT_SCHEMAS
+from agent_lifecycle.contracts.independent_evidence_schemas import INDEPENDENT_EVIDENCE_SCHEMAS
 from agent_lifecycle.contracts.legacy_runner_schemas import LEGACY_RUNNER_SCHEMAS
 from agent_lifecycle.contracts.lifecycle_control_definitions import (
     CONTROL_EVENT_TYPES,
@@ -713,6 +714,7 @@ _SCHEMA_GROUPS = (
     EVIDENCE_IMPORT_SCHEMAS,
     EXTERNAL_CHECK_SCHEMAS,
     FINDING_CHECK_SCHEMAS,
+    INDEPENDENT_EVIDENCE_SCHEMAS,
     EXECUTION_STRATEGY_SCHEMAS,
     IMPORT_DIALECT_SCHEMAS,
     STATUS_GOAL_SCHEMAS,

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/src/agent_lifecycle/planning/completeness.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Any
 
 from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
+from agent_lifecycle.contracts.independent_evidence_schemas import validate_independence_requirement
 from agent_lifecycle.contracts.ownership_paths import authority_paths_overlap, normalize_authority_path
 from agent_lifecycle.planning.traceability import validate_plan_traceability
 
@@ -199,6 +200,27 @@ def _check_acceptance(manifest: dict[str, Any], tier: str, blockers: list[dict[s
     for criterion in criteria:
         if not isinstance(criterion.get("id"), str) or not criterion["id"]:
             blockers.append(_blocker("missing-acceptance-id", "acceptance criterion id is required", {"tier": tier}))
+        independence = criterion.get("independence")
+        if independence is None:
+            continue
+        validation = validate_independence_requirement(independence)
+        if validation["status"] != "PASS":
+            blockers.append(
+                _blocker(
+                    "invalid-independence-requirement",
+                    "criterion independence requirement is invalid",
+                    {"criterionId": criterion.get("id"), "validation": validation},
+                )
+            )
+            continue
+        if independence.get("required") is True and not _strings(criterion.get("independentEvidenceIds")):
+            blockers.append(
+                _blocker(
+                    "missing-independent-evidence-route",
+                    "a criterion requiring independence must route independent evidence ids",
+                    {"criterionId": criterion.get("id")},
+                )
+            )
 
 
 def _check_evidence_route(manifest: dict[str, Any], _tier: str, blockers: list[dict[str, Any]]) -> None:
@@ -215,6 +237,7 @@ def _check_evidence_route(manifest: dict[str, Any], _tier: str, blockers: list[d
                 )
             )
         evidence_ids.update(ids)
+        evidence_ids.update(_strings(criterion.get("independentEvidenceIds")))
     routed = set()
     for workstream in _workstreams(manifest):
         routed.update(_strings(workstream.get("evidenceIds")))

{agent_lifecycle_kit-2.0.0 → agent_lifecycle_kit-2.1.0}/src/agent_lifecycle/planning/manifest_contract.py

@@ -106,7 +106,17 @@ _WORKSTREAM = {
     "qualityFloor",
 }
 _ACCEPTANCE = {"criteria", "evidence", "releaseGate", "qualityFloor"}
-_CRITERION = {"id", "requirementIds", "evidenceIds", "statement", "description", "source", "priority"}
+_CRITERION = {
+    "id",
+    "requirementIds",
+    "evidenceIds",
+    "independentEvidenceIds",
+    "independence",
+    "statement",
+    "description",
+    "source",
+    "priority",
+}
 _EVIDENCE = {"id", "description", "source", "validation", "artifactPath", "required"}
 _VALIDATION = {"commands", "extraEvidence"}
 _ORCHESTRATION = {