agent-lifecycle-kit 1.85.0__tar.gz → 1.87.0__tar.gz

{agent_lifecycle_kit-1.85.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-1.87.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 1.85.0
+Version: 1.87.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==1.85.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==1.87.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -68,7 +68,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
 - The boundaries of [planning-only launch](docs/reference/planning-only-launch.md) and [frozen-task launch through a verified profile](docs/reference/qualified-host-launch.md) are documented in the reference. Shipped planning profiles remain candidates with safe failure until the corresponding profile is verified.
 - The [system architecture](docs/architecture/system-architecture.md) page explains how the project is organized, and [project comparison](docs/reference/project-comparison.md) shows how it differs from similar tools.
 - Multiple-agent boundaries, workflow configuration, model choice, prompts, timeouts and retries are described in [workflow customization and execution controls](docs/reference/workflow-customization.md).
-- Create a local project profile with `agent-lifecycle project profile init`; see [project workflow profile](docs/reference/project-workflow-profile.md).
+- Create a local project profile with `agent-lifecycle project profile init`; see [project workflow profile](docs/reference/project-workflow-profile.md). Explain the selected profile, plan constraints and adapter capability lineage with [effective configuration](docs/reference/effective-configuration.md) and [adapter action evidence](docs/reference/adapter-action-evidence.md).
 - For long sessions, use [context checkpoints and compaction recovery](docs/reference/context-checkpoints.md). They preserve a bounded local continuation package without changing plan authority.
 ## What it gives you
 - A finish-oriented lifecycle: plan, execute, review, and prove the result.
@@ -194,7 +194,7 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 
 - Start: [English documentation](docs/README.md), [Русская документация](docs/ru/README.md), [Install](docs/guides/install-and-first-run.md), [Quickstart](docs/guides/quickstart.md), [Beginner and advanced workflows](docs/guides/beginner-and-advanced-workflows.md), [Commands by task](docs/guides/commands-by-task.md), [Research workflow](docs/guides/research-workflow.md), [Lifecycle task scenarios](docs/guides/lifecycle-cookbook.md), and [Code review workflows](docs/guides/code-review-workflows.md).
 - 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), [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), [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).
+- 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), [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 recovery](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).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.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==1.85.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==1.87.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -46,7 +46,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
 - The boundaries of [planning-only launch](docs/reference/planning-only-launch.md) and [frozen-task launch through a verified profile](docs/reference/qualified-host-launch.md) are documented in the reference. Shipped planning profiles remain candidates with safe failure until the corresponding profile is verified.
 - The [system architecture](docs/architecture/system-architecture.md) page explains how the project is organized, and [project comparison](docs/reference/project-comparison.md) shows how it differs from similar tools.
 - Multiple-agent boundaries, workflow configuration, model choice, prompts, timeouts and retries are described in [workflow customization and execution controls](docs/reference/workflow-customization.md).
-- Create a local project profile with `agent-lifecycle project profile init`; see [project workflow profile](docs/reference/project-workflow-profile.md).
+- Create a local project profile with `agent-lifecycle project profile init`; see [project workflow profile](docs/reference/project-workflow-profile.md). Explain the selected profile, plan constraints and adapter capability lineage with [effective configuration](docs/reference/effective-configuration.md) and [adapter action evidence](docs/reference/adapter-action-evidence.md).
 - For long sessions, use [context checkpoints and compaction recovery](docs/reference/context-checkpoints.md). They preserve a bounded local continuation package without changing plan authority.
 ## What it gives you
 - A finish-oriented lifecycle: plan, execute, review, and prove the result.
@@ -172,7 +172,7 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 
 - Start: [English documentation](docs/README.md), [Русская документация](docs/ru/README.md), [Install](docs/guides/install-and-first-run.md), [Quickstart](docs/guides/quickstart.md), [Beginner and advanced workflows](docs/guides/beginner-and-advanced-workflows.md), [Commands by task](docs/guides/commands-by-task.md), [Research workflow](docs/guides/research-workflow.md), [Lifecycle task scenarios](docs/guides/lifecycle-cookbook.md), and [Code review workflows](docs/guides/code-review-workflows.md).
 - 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), [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), [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).
+- 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), [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 recovery](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).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "1.85.0"
+version = "1.87.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-1.85.0 → agent_lifecycle_kit-1.87.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "1.85.0"
+__version__ = "1.87.0"

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.0}/src/agent_lifecycle/audit/package.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from agent_lifecycle.audit.implementation import (
     build_final_implementation_audit,
@@ -22,10 +23,10 @@ from agent_lifecycle.planning import (
     validate_plan_manifest,
     validate_repository_references,
 )
+from agent_lifecycle.planning.traceability import validate_finding_check_traceability
 from agent_lifecycle.workflow.artifacts import package_root
 from agent_lifecycle.workflow.state import load_state
 
-
 PACKAGE_AUDIT_SCHEMA = "agent-plan-package-audit-report.v1"
 _PLAN_FILES = (
     "README.md",
@@ -66,7 +67,9 @@ def build_package_audit(
         raise LifecycleError("plan-directory-missing", "plan directory was not found", {"path": str(package_dir)})
     manifest_path = package_dir / "plan.manifest.json"
     if manifest_path.is_symlink():
-        raise LifecycleError("plan-manifest-symlink", "plan manifest must not be a symlink", {"path": str(manifest_path)})
+        raise LifecycleError(
+            "plan-manifest-symlink", "plan manifest must not be a symlink", {"path": str(manifest_path)}
+        )
     manifest = read_json_object(manifest_path, label="plan manifest")
     package_id = _package_id(manifest)
     findings: list[dict[str, Any]] = []
@@ -92,20 +95,24 @@ def build_package_audit(
     _capture_check_failure("lock", lock_check, findings, blockers)
 
     acceptance_path = package_dir / "acceptance-criteria.md"
-    acceptance_check = _run_check(
-        lambda: validate_acceptance_checklist(
-            manifest,
-            acceptance_path.read_text(encoding="utf-8"),
+    acceptance_check = (
+        _run_check(
+            lambda: validate_acceptance_checklist(
+                manifest,
+                acceptance_path.read_text(encoding="utf-8"),
+            )
+        )
+        if acceptance_path.is_file() and not acceptance_path.is_symlink()
+        else _missing_check(
+            "acceptance-checklist-symlink" if acceptance_path.is_symlink() else "acceptance-checklist-missing",
+            "acceptance checklist must not be a symlink"
+            if acceptance_path.is_symlink()
+            else "acceptance checklist was not found",
         )
-    ) if acceptance_path.is_file() and not acceptance_path.is_symlink() else _missing_check(
-        "acceptance-checklist-symlink" if acceptance_path.is_symlink() else "acceptance-checklist-missing",
-        "acceptance checklist must not be a symlink" if acceptance_path.is_symlink() else "acceptance checklist was not found",
     )
     _capture_check_failure("acceptance", acceptance_check, findings, blockers)
 
-    references_check = _run_check(
-        lambda: require_repository_references_pass(validate_repository_references(manifest))
-    )
+    references_check = _run_check(lambda: require_repository_references_pass(validate_repository_references(manifest)))
     _capture_check_failure("references", references_check, findings, blockers)
 
     plan_status = _plan_status(
@@ -188,6 +195,27 @@ def require_package_audit_pass(audit: dict[str, Any]) -> dict[str, Any]:
     return audit
 
 
+def build_finding_check_adoption_audit(
+    *,
+    findings: list[dict[str, Any]],
+    bindings: list[dict[str, Any]],
+    plan_deltas: list[dict[str, Any]],
+    evidence: list[dict[str, Any]] | None = None,
+    active_binding_ids: list[str] | None = None,
+    source_revision: str | None = None,
+) -> dict[str, Any]:
+    """Audit finding/check adoption as a read-only package-level gate."""
+
+    return validate_finding_check_traceability(
+        findings=findings,
+        bindings=bindings,
+        plan_deltas=plan_deltas,
+        evidence=evidence,
+        active_binding_ids=active_binding_ids,
+        source_revision=source_revision,
+    )
+
+
 def validate_package_audit(audit: dict[str, Any]) -> dict[str, Any]:
     """Validate the integrity and top-level semantics of a package receipt."""
 
@@ -200,12 +228,16 @@ def validate_package_audit(audit: dict[str, Any]) -> dict[str, Any]:
     if audit.get("status") not in {"PASS", "FAIL", "REVIEW_REQUIRED"}:
         blockers.append({"code": "package-audit-status", "message": "package audit status is unsupported"})
     if audit.get("productionPromotionClaimed") is not False:
-        blockers.append({"code": "package-audit-production-claim", "message": "package audit must not claim production promotion"})
+        blockers.append(
+            {"code": "package-audit-production-claim", "message": "package audit must not claim production promotion"}
+        )
     auditor = audit.get("auditor")
     if not isinstance(auditor, dict) or auditor.get("independent") is not True:
         blockers.append({"code": "package-audit-auditor", "message": "package auditor must be independent"})
     if audit.get("status") == "PASS" and audit.get("blockers"):
-        blockers.append({"code": "package-audit-open-blockers", "message": "PASS package audit must not contain blockers"})
+        blockers.append(
+            {"code": "package-audit-open-blockers", "message": "PASS package audit must not contain blockers"}
+        )
     result = {
         "schemaVersion": "agent-plan-package-audit-validation.v1",
         "status": "PASS" if not blockers else "FAIL",
@@ -301,10 +333,20 @@ def _build_implementation_section(
             final_audit = aggregate["result"]
             final_validation = validate_final_implementation_audit(final_audit, state=state)
             if final_validation.get("status") != "PASS":
-                _capture_check_failure("final-implementation-validation", {"status": "FAIL", "blockers": final_validation.get("blockers", []), "result": final_validation}, findings, blockers)
+                _capture_check_failure(
+                    "final-implementation-validation",
+                    {"status": "FAIL", "blockers": final_validation.get("blockers", []), "result": final_validation},
+                    findings,
+                    blockers,
+                )
                 report_status = "FAIL"
             elif final_audit.get("status") != "PASS":
-                _capture_check_failure("final-implementation", {"status": "FAIL", "blockers": final_audit.get("blockers", []), "result": final_audit}, findings, blockers)
+                _capture_check_failure(
+                    "final-implementation",
+                    {"status": "FAIL", "blockers": final_audit.get("blockers", []), "result": final_audit},
+                    findings,
+                    blockers,
+                )
                 report_status = "FAIL"
     elif require_implementation:
         _add_finding(
@@ -452,7 +494,9 @@ def _contained_relative_path(root: Path, raw: str) -> str:
             {"root": str(root), "path": str(resolved)},
         ) from exc
     if not resolved.is_file():
-        raise LifecycleError("implementation-report-missing", "implementation audit report was not found", {"path": str(resolved)})
+        raise LifecycleError(
+            "implementation-report-missing", "implementation audit report was not found", {"path": str(resolved)}
+        )
     return normalize_repo_path(relative.as_posix(), label="implementation audit report")
 
 
@@ -477,10 +521,7 @@ def _package_file_check(
             )
         except LifecycleError as exc:
             return {"status": "FAIL", "blockers": [_error(exc)]}
-        entries = [
-            {"path": item["path"], "status": "PASS", "bytes": item["bytes"]}
-            for item in verification["entries"]
-        ]
+        entries = [{"path": item["path"], "status": "PASS", "bytes": item["bytes"]} for item in verification["entries"]]
         body = {
             "schemaVersion": "agent-plan-package-files.v2",
             "status": "PASS",
@@ -497,8 +538,14 @@ def _package_file_check(
         exists = path.is_file()
         is_symlink = path.is_symlink()
         optional_draft_lock = name == "plan.lock.json" and not exists and not is_symlink
-        status = "SYMLINK" if is_symlink else ("PASS" if exists else ("REVIEW_REQUIRED" if optional_draft_lock else "MISSING"))
-        entries.append({"path": name, "status": status, "bytes": path.stat().st_size if exists and not is_symlink else 0})
+        status = (
+            "SYMLINK"
+            if is_symlink
+            else ("PASS" if exists else ("REVIEW_REQUIRED" if optional_draft_lock else "MISSING"))
+        )
+        entries.append(
+            {"path": name, "status": status, "bytes": path.stat().st_size if exists and not is_symlink else 0}
+        )
         if (not exists and not optional_draft_lock) or is_symlink:
             missing.append(name)
     body = {
@@ -552,29 +599,50 @@ def _missing_check(code: str, message: str) -> dict[str, Any]:
     return {"status": "FAIL", "blockers": [{"code": code, "message": message, "context": {}}]}
 
 
-def _capture_check_failure(category: str, check: dict[str, Any], findings: list[dict[str, Any]], blockers: list[dict[str, Any]]) -> None:
+def _capture_check_failure(
+    category: str, check: dict[str, Any], findings: list[dict[str, Any]], blockers: list[dict[str, Any]]
+) -> None:
     if check.get("status") != "FAIL":
         return
     for item in check.get("blockers", []):
         if not isinstance(item, dict):
             continue
+        context = item.get("context")
+        context_payload = context if isinstance(context, dict) else {}
         _add_finding(
             findings,
             blockers,
             code=str(item.get("code") or f"{category}-failed"),
-            severity="HIGH" if category in {"manifest", "completeness", "lock", "implementation-state", "implementation-reports"} else "MEDIUM",
+            severity="HIGH"
+            if category in {"manifest", "completeness", "lock", "implementation-state", "implementation-reports"}
+            else "MEDIUM",
             category=category,
             message=str(item.get("message") or f"{category} check failed"),
-            context=item.get("context") if isinstance(item.get("context"), dict) else item,
+            context=context_payload,
         )
 
 
 def _lineage_blockers(state: dict[str, Any], manifest: dict[str, Any], package_id: str) -> list[dict[str, Any]]:
     expected_digest = canonical_digest(manifest)
     checks = (
-        ("implementation-package-mismatch", "workflow state packageId does not match the plan package", state.get("packageId"), package_id),
-        ("implementation-revision-mismatch", "workflow state planRevision does not match the plan", state.get("planRevision"), manifest.get("planRevision")),
-        ("implementation-digest-mismatch", "workflow state planDigest does not match the plan", state.get("planDigest"), expected_digest),
+        (
+            "implementation-package-mismatch",
+            "workflow state packageId does not match the plan package",
+            state.get("packageId"),
+            package_id,
+        ),
+        (
+            "implementation-revision-mismatch",
+            "workflow state planRevision does not match the plan",
+            state.get("planRevision"),
+            manifest.get("planRevision"),
+        ),
+        (
+            "implementation-digest-mismatch",
+            "workflow state planDigest does not match the plan",
+            state.get("planDigest"),
+            expected_digest,
+        ),
     )
     return [
         {"code": code, "message": message, "context": {"actual": actual, "expected": expected}}

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.0}/src/agent_lifecycle/audit/proof_findings.py

@@ -2,6 +2,15 @@
 
 from __future__ import annotations
 
+from agent_lifecycle.contracts.finding_check_schemas import (
+    FINDING_CHECK_BINDING_SCHEMA,
+    FINDING_CHECK_EVIDENCE_SCHEMA,
+    build_finding_check_binding,
+    build_finding_check_evidence,
+    transition_finding_check_binding,
+    validate_finding_check_binding,
+    validate_finding_check_evidence,
+)
 from agent_lifecycle.contracts.proof_validation import (
     FINDING_SCHEMA,
     ROOT_CAUSE_SCHEMA,
@@ -14,12 +23,19 @@ from agent_lifecycle.contracts.proof_validation import (
 )
 
 __all__ = [
+    "FINDING_CHECK_BINDING_SCHEMA",
+    "FINDING_CHECK_EVIDENCE_SCHEMA",
     "FINDING_SCHEMA",
     "ROOT_CAUSE_SCHEMA",
+    "build_finding_check_binding",
+    "build_finding_check_evidence",
     "build_finding_identity",
     "build_root_cause_evidence",
     "finding_identity_fields",
     "stable_finding_id",
+    "transition_finding_check_binding",
+    "validate_finding_check_binding",
+    "validate_finding_check_evidence",
     "validate_finding_identity",
     "validate_root_cause_evidence",
 ]

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.0}/src/agent_lifecycle/cli/dispatch_planning.py

@@ -12,6 +12,11 @@ from agent_lifecycle.contracts import (
     read_json_object,
     write_json_create,
 )
+from agent_lifecycle.contracts.finding_check_schemas import (
+    validate_finding_check_binding,
+    validate_finding_check_evidence,
+    validate_finding_check_proposal,
+)
 from agent_lifecycle.freeze import verify_plan_lock
 from agent_lifecycle.planning import (
     build_plan_delta,
@@ -33,10 +38,12 @@ from agent_lifecycle.planning.verification import (
     load_verification_inputs,
     require_plan_verification_pass,
 )
+from agent_lifecycle.policy.proposals import accept_finding_check_proposal, build_finding_check_proposal
 from agent_lifecycle.specification import (
     build_completion_gate_receipt,
     validate_specification,
 )
+from agent_lifecycle.workflow.artifacts import build_finding_check_evidence_artifact
 
 
 def dispatch_planning(args: argparse.Namespace) -> dict[str, Any]:
@@ -194,9 +201,62 @@ def _dispatch_plan(args: argparse.Namespace) -> dict[str, Any]:
         if args.out:
             write_json_create(Path(args.out), payload)
         return payload
+    if args.plan_command == "finding-check":
+        return _dispatch_finding_check(args)
     raise LifecycleError("command-not-implemented", "plan command is not implemented")
 
 
+def _dispatch_finding_check(args: argparse.Namespace) -> dict[str, Any]:
+    def read(path: str, label: str) -> dict[str, Any]:
+        return read_json_object(Path(path), label=label)
+
+    if args.finding_check_command == "propose":
+        payload = build_finding_check_proposal(
+            finding=read(args.finding, "finding"),
+            plan_delta=read(args.delta, "plan delta"),
+            check_identity=read(args.check, "check identity"),
+            owner=args.owner,
+            scope=read(args.scope, "check scope"),
+            source_revision=args.source_revision,
+            expected_result=args.expected_result,
+            proposal_id=args.proposal_id,
+        )
+    elif args.finding_check_command == "validate":
+        if args.binding:
+            payload = validate_finding_check_binding(read(args.binding, "finding-check binding"))
+        elif args.proposal:
+            payload = validate_finding_check_proposal(read(args.proposal, "finding-check proposal"))
+        elif args.evidence:
+            payload = validate_finding_check_evidence(read(args.evidence, "finding-check evidence"))
+        else:
+            raise LifecycleError("finding-check-input-required", "binding, proposal or evidence is required")
+    elif args.finding_check_command == "accept":
+        payload = accept_finding_check_proposal(
+            read(args.proposal, "finding-check proposal"), read(args.authorization, "authorization")
+        )
+    elif args.finding_check_command == "evidence":
+        payload = build_finding_check_evidence_artifact(
+            read(args.binding, "finding-check binding"),
+            result=args.result,
+            source_revision=args.source_revision,
+            evidence_ids=args.evidence_id,
+        )
+    elif args.finding_check_command == "transition":
+        from agent_lifecycle.contracts.finding_check_schemas import transition_finding_check_binding
+
+        payload = transition_finding_check_binding(
+            read(args.binding, "finding-check binding"),
+            args.target_status,
+            authorization=read(args.authorization, "authorization"),
+            evidence=read(args.evidence, "finding-check evidence") if args.evidence else None,
+        )
+    else:
+        raise LifecycleError("command-not-implemented", "finding-check command is not implemented")
+    if args.out:
+        write_json_create(Path(args.out), payload)
+    return payload
+
+
 def _dispatch_task(args: argparse.Namespace) -> dict[str, Any]:
     if args.task_command == "compile":
         execution_strategy = (

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.0}/src/agent_lifecycle/cli/lifecycle_parsers.py

@@ -6,11 +6,14 @@ import argparse
 
 from agent_lifecycle.adapter_sessions import START_MODES
 from agent_lifecycle.cli.progress_hooks import add_progress_hook_args
+from agent_lifecycle.cli.project import add_project_parser
 from agent_lifecycle.contracts.lifecycle_action_catalog import COMPATIBILITY_COMMANDS
 from agent_lifecycle.contracts.review_mesh_schemas import REVIEW_MESH_MODE_IDS
 from agent_lifecycle.resources import builtin_profile_path
 from agent_lifecycle.review_mesh.operator_templates import REVIEW_MESH_OPERATOR_TEMPLATE_IDS
 
+_add_project_parser = add_project_parser
+
 _BASELINE_PROFILE = builtin_profile_path("lifecycle-baselines.v1.json")
 _MODEL_ROUTING_PROFILE = builtin_profile_path("model-routing-profile.v1.json")
 _RISK_POLICY = builtin_profile_path("risk-execution-policy.v1.json")
@@ -61,45 +64,6 @@ def _add_start_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentPa
     )
 
 
-def _add_project_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    project = subparsers.add_parser("project", help="project-local ALK configuration")
-    project_sub = project.add_subparsers(dest="project_command", required=True)
-    profile = project_sub.add_parser("profile", help="project workflow profile commands")
-    profile_sub = profile.add_subparsers(dest="profile_command", required=True)
-    init = profile_sub.add_parser("init", help="create a minimal local project profile")
-    init.add_argument("--project-root", default=".")
-    init.add_argument("--out", default=".alk/project-profile.json")
-    init.add_argument("--adapter", help="set the default adapter in the new profile")
-    check = profile_sub.add_parser("check", help="validate and resolve a project profile")
-    check.add_argument("--project-root", default=".")
-    check.add_argument("--profile")
-    check.add_argument("--manifest")
-    check.add_argument("--lock")
-    check.add_argument("--adapter")
-    check.add_argument("--mode", choices=list(START_MODES))
-    check.add_argument("--risk", choices=["auto", "S0", "S1", "S2"])
-    check.add_argument("--out")
-    principles = project_sub.add_parser("principles", help="check a bounded project-principles artifact")
-    principles_sub = principles.add_subparsers(dest="principles_command", required=True)
-    principles_check = principles_sub.add_parser("check", aliases=["validate"])
-    principles_check.add_argument("--file", "--path", dest="principles_path", required=True)
-    principles_check.add_argument("--project-root", default=".")
-    principles_check.add_argument("--out")
-    preset = project_sub.add_parser("preset", help="inspect and render built-in workflow presets")
-    preset_sub = preset.add_subparsers(dest="preset_command", required=True)
-    preset_sub.add_parser("list", help="list built-in workflow presets")
-    for command in ("inspect", "validate"):
-        child = preset_sub.add_parser(command, help=f"{command} a built-in workflow preset")
-        child.add_argument("--preset", required=True)
-        child.add_argument("--project-root", default=".")
-    render = preset_sub.add_parser("render", help="render a preset to an explicit profile path")
-    render.add_argument("--preset", required=True)
-    render.add_argument("--project-root", default=".")
-    render.add_argument("--profile-id")
-    render.add_argument("--adapter")
-    render.add_argument("--out", required=True)
-
-
 def _add_host_launch_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
     host_launch = subparsers.add_parser("host-launch", help="inspect or preflight an operator-local host profile")
     host_launch_sub = host_launch.add_subparsers(dest="host_launch_command", required=True)

{agent_lifecycle_kit-1.85.0 → agent_lifecycle_kit-1.87.0}/src/agent_lifecycle/cli/planning_parsers.py

@@ -59,6 +59,41 @@ def _add_plan_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentPar
     delta_check = plan_sub.add_parser("delta-check", aliases=["delta-validate"])
     delta_check.add_argument("--delta", required=True)
     delta_check.add_argument("--out")
+    finding_check = plan_sub.add_parser("finding-check", help="bind accepted findings to deterministic checks")
+    finding_check_sub = finding_check.add_subparsers(dest="finding_check_command", required=True)
+    propose = finding_check_sub.add_parser("propose")
+    propose.add_argument("--finding", required=True)
+    propose.add_argument("--delta", required=True)
+    propose.add_argument("--check", required=True)
+    propose.add_argument("--scope", required=True)
+    propose.add_argument("--owner", required=True)
+    propose.add_argument("--source-revision", required=True)
+    propose.add_argument("--expected-result", choices=["PASS", "FAIL", "BLOCKED"], default="PASS")
+    propose.add_argument("--proposal-id", default="finding-check-adoption-proposal")
+    propose.add_argument("--out")
+    validate = finding_check_sub.add_parser("validate")
+    validate.add_argument("--binding")
+    validate.add_argument("--proposal")
+    validate.add_argument("--evidence")
+    validate.add_argument("--out")
+    accept = finding_check_sub.add_parser("accept")
+    accept.add_argument("--proposal", required=True)
+    accept.add_argument("--authorization", required=True)
+    accept.add_argument("--out")
+    evidence = finding_check_sub.add_parser("evidence")
+    evidence.add_argument("--binding", required=True)
+    evidence.add_argument("--result", choices=["PASS", "FAIL", "BLOCKED"], required=True)
+    evidence.add_argument("--source-revision", required=True)
+    evidence.add_argument("--evidence-id", action="append", required=True)
+    evidence.add_argument("--out")
+    transition = finding_check_sub.add_parser("transition")
+    transition.add_argument("--binding", required=True)
+    transition.add_argument(
+        "--target-status", choices=["PROPOSED", "ACCEPTED", "IMPLEMENTED", "VERIFIED", "RETIRED"], required=True
+    )
+    transition.add_argument("--authorization", required=True)
+    transition.add_argument("--evidence")
+    transition.add_argument("--out")
 
 
 def _add_task_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None: