agent-lifecycle-kit 2.21.0__tar.gz → 2.22.0__tar.gz

{agent_lifecycle_kit-2.21.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-2.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 2.21.0
+Version: 2.22.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
@@ -41,9 +41,9 @@ and secret handling stay in adapters or host-local profiles.
 ALK provides a verifiable finish for external-agent work with proportionate control. It adds only the checks and evidence needed for the task; most of the time remains for research, implementation and product verification.
 
 ## Quick start
-Start with [install ALK and make the first run](docs/guides/install-and-first-run.md). Release 2.21 adds [command accounting, bounded preparation and response recovery](docs/reference/source-native-workflow-accounting.md). Release 2.20 adds [target-bound initialization](docs/reference/cli.md#release-220-composed-initialization-and-digest-display), [bounded local continuation](docs/reference/workflow-continuation.md) and batched Git snapshots. Release 2.19 adds [safe artifact authoring and planning preflight](docs/reference/safe-artifact-authoring.md), [bounded review handoff](docs/reference/review-mesh.md#bounded-review-handoff) and thin skills with complete references. Release 2.18 bounds process/Git diagnostics, hardens signing and distinguishes OpenCode 1.x/2.x compatibility ([adapter notes](docs/adapters/opencode.md)); 2.17 strengthens [workflow validation and recovery](docs/reference/workflow-completeness.md). Release 2.16 introduced cumulative accounting within verified host capabilities; see [retention maintenance](docs/operations/retention-maintenance.md).
+Start with [install ALK and make the first run](docs/guides/install-and-first-run.md). Release 2.22 adds [conservative plan-review reuse](docs/reference/conservative-delta-review.md) with independent current applicability and no automatic full reruns. Release 2.21 adds [command accounting, bounded preparation and response recovery](docs/reference/source-native-workflow-accounting.md). Release 2.20 adds [target-bound initialization](docs/reference/cli.md#release-220-composed-initialization-and-digest-display), [bounded local continuation](docs/reference/workflow-continuation.md) and batched Git snapshots. Release 2.19 adds [safe artifact authoring and planning preflight](docs/reference/safe-artifact-authoring.md), [bounded review handoff](docs/reference/review-mesh.md#bounded-review-handoff) and thin skills with complete references. Release 2.18 bounds process/Git diagnostics, hardens signing and distinguishes OpenCode 1.x/2.x compatibility ([adapter notes](docs/adapters/opencode.md)); 2.17 strengthens [workflow validation and recovery](docs/reference/workflow-completeness.md). Release 2.16 introduced cumulative accounting within verified host capabilities; see [retention maintenance](docs/operations/retention-maintenance.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.21.0`, and common `agent-lifecycle version` errors. See [2.15 migration notes](docs/reference/cli.md#migrating-authority-artifacts-to-215) and [authority boundaries](docs/reference/authority-artifact-boundaries.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.22.0`, and common `agent-lifecycle version` errors. See [2.15 migration notes](docs/reference/cli.md#migrating-authority-artifacts-to-215) and [authority boundaries](docs/reference/authority-artifact-boundaries.md).
 
 For a quick start, run:
 

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/README.md

@@ -19,9 +19,9 @@ and secret handling stay in adapters or host-local profiles.
 ALK provides a verifiable finish for external-agent work with proportionate control. It adds only the checks and evidence needed for the task; most of the time remains for research, implementation and product verification.
 
 ## Quick start
-Start with [install ALK and make the first run](docs/guides/install-and-first-run.md). Release 2.21 adds [command accounting, bounded preparation and response recovery](docs/reference/source-native-workflow-accounting.md). Release 2.20 adds [target-bound initialization](docs/reference/cli.md#release-220-composed-initialization-and-digest-display), [bounded local continuation](docs/reference/workflow-continuation.md) and batched Git snapshots. Release 2.19 adds [safe artifact authoring and planning preflight](docs/reference/safe-artifact-authoring.md), [bounded review handoff](docs/reference/review-mesh.md#bounded-review-handoff) and thin skills with complete references. Release 2.18 bounds process/Git diagnostics, hardens signing and distinguishes OpenCode 1.x/2.x compatibility ([adapter notes](docs/adapters/opencode.md)); 2.17 strengthens [workflow validation and recovery](docs/reference/workflow-completeness.md). Release 2.16 introduced cumulative accounting within verified host capabilities; see [retention maintenance](docs/operations/retention-maintenance.md).
+Start with [install ALK and make the first run](docs/guides/install-and-first-run.md). Release 2.22 adds [conservative plan-review reuse](docs/reference/conservative-delta-review.md) with independent current applicability and no automatic full reruns. Release 2.21 adds [command accounting, bounded preparation and response recovery](docs/reference/source-native-workflow-accounting.md). Release 2.20 adds [target-bound initialization](docs/reference/cli.md#release-220-composed-initialization-and-digest-display), [bounded local continuation](docs/reference/workflow-continuation.md) and batched Git snapshots. Release 2.19 adds [safe artifact authoring and planning preflight](docs/reference/safe-artifact-authoring.md), [bounded review handoff](docs/reference/review-mesh.md#bounded-review-handoff) and thin skills with complete references. Release 2.18 bounds process/Git diagnostics, hardens signing and distinguishes OpenCode 1.x/2.x compatibility ([adapter notes](docs/adapters/opencode.md)); 2.17 strengthens [workflow validation and recovery](docs/reference/workflow-completeness.md). Release 2.16 introduced cumulative accounting within verified host capabilities; see [retention maintenance](docs/operations/retention-maintenance.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.21.0`, and common `agent-lifecycle version` errors. See [2.15 migration notes](docs/reference/cli.md#migrating-authority-artifacts-to-215) and [authority boundaries](docs/reference/authority-artifact-boundaries.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.22.0`, and common `agent-lifecycle version` errors. See [2.15 migration notes](docs/reference/cli.md#migrating-authority-artifacts-to-215) and [authority boundaries](docs/reference/authority-artifact-boundaries.md).
 
 For a quick start, run:
 

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/pyproject.toml

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

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "2.21.0"
+__version__ = "2.22.0"

agent_lifecycle_kit-2.22.0/src/agent_lifecycle/audit/delta_review.py

@@ -0,0 +1,113 @@
+"""Bounded read-only plan review selection, without model orchestration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_bytes, canonical_digest
+from agent_lifecycle.contracts.plan_delta_schemas import DELTA_REVIEW_SCHEMA
+from agent_lifecycle.review.validation import (
+    build_review_impact_graph,
+    derive_delta_selection,
+    make_review_scope,
+    validate_bound_plan_review,
+    validate_review_composition,
+)
+
+MAX_PACKET_BYTES = 98304
+
+
+def build_delta_review_packet(
+    subject: dict[str, Any],
+    *,
+    baseline: dict[str, Any] | None = None,
+    reports: dict[str, dict[str, Any]] | None = None,
+    report_sizes: dict[str, int] | None = None,
+    max_bytes: int = MAX_PACKET_BYTES,
+) -> dict[str, Any]:
+    """Select eligible impact; FULL_REQUIRED never starts a full audit.
+
+    The caller still needs existing admission, independent review and freeze
+    verification. A digest or eligibility decision grants none of those rights.
+    """
+    if type(max_bytes) is not int or max_bytes < 1024:
+        raise LifecycleError("review-packet-limit", "Invalid packet limit")
+    cap = min(max_bytes, MAX_PACKET_BYTES)
+    try:
+        scope = make_review_scope(subject)
+    except LifecycleError as exc:
+        return _input_refusal(subject, exc.code)
+    body = {
+        "schemaVersion": DELTA_REVIEW_SCHEMA,
+        "mode": "FULL",
+        "reasons": ["NO_BASELINE"],
+        "baseHash": None,
+        "candidateHash": scope["candidateHash"],
+        "graphDigest": scope["graphDigest"],
+        "changedNodes": [],
+        "closure": scope["coveredNodes"],
+        "readOnly": True,
+        "modelCallsStarted": False,
+        "admissionRequired": True,
+    }
+    if baseline is not None:
+        try:
+            previous = _baseline_subject(baseline, reports, report_sizes)
+            body.update(derive_delta_selection(previous, subject))
+            body["schemaVersion"] = DELTA_REVIEW_SCHEMA
+        except LifecycleError as exc:
+            body.update(mode="FULL_REQUIRED", reasons=[exc.code])
+    if body["mode"] == "DELTA_ELIGIBLE":
+        graph = build_review_impact_graph(subject["manifest"], file_digests=subject["fileDigests"])
+        selected = set(body["closure"])
+        body["selectedNodes"] = [n for n in graph["nodes"] if n["id"] in selected]
+        body["unchangedNodes"] = [
+            {"id": n["id"], "digest": n["digest"]} for n in graph["nodes"] if n["id"] not in selected
+        ]
+        body["baselineDigest"] = canonical_digest(baseline)
+    if len(canonical_bytes(body)) + 100 > cap:
+        body = {
+            key: body[key]
+            for key in ("schemaVersion", "candidateHash", "readOnly", "modelCallsStarted", "admissionRequired")
+        }
+        body.update(mode="FULL_REQUIRED", reasons=["PACKET_LIMIT_EXCEEDED"], baseHash=None, changedNodes=[], closure=[])
+    return {**body, "packetDigest": canonical_digest(body)}
+
+
+def _input_refusal(subject: dict[str, Any], reason: str) -> dict[str, Any]:
+    manifest = subject.get("manifest") if isinstance(subject, dict) else None
+    body = {
+        "schemaVersion": DELTA_REVIEW_SCHEMA,
+        "mode": "FULL_REQUIRED",
+        "reasons": [reason],
+        "baseHash": None,
+        "candidateHash": canonical_digest(manifest),
+        "changedNodes": [],
+        "closure": [],
+        "readOnly": True,
+        "modelCallsStarted": False,
+        "admissionRequired": True,
+    }
+    return {**body, "packetDigest": canonical_digest(body)}
+
+
+def _baseline_subject(
+    baseline: dict[str, Any],
+    reports: dict[str, dict[str, Any]] | None,
+    sizes: dict[str, int] | None,
+) -> dict[str, Any]:
+    if baseline.get("schemaVersion") == "agent-plan-composite-review.v1":
+        if not reports or not sizes:
+            raise LifecycleError("review-set-incomplete", "Composite evidence needed")
+        current_paths = baseline.get("currentReports")
+        if not isinstance(current_paths, list) or not current_paths:
+            raise LifecycleError("review-set-incomplete", "Current selectors needed")
+        candidate = reports.get(current_paths[0], {}).get("subject", {})
+        result = validate_review_composition(candidate.get("manifest", {}), baseline, reports, report_sizes=sizes)
+        return result["seats"][0]["subject"]
+    bound = validate_bound_plan_review(baseline)
+    if bound["scope"]["kind"] != "FULL":
+        raise LifecycleError("review-incomplete", "Complete baseline needed")
+    if len(canonical_bytes(baseline)) > 8 * 1024 * 1024:
+        raise LifecycleError("review-chain-limit", "Baseline exceeds cap")
+    return bound["subject"]

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/src/agent_lifecycle/cli/dispatch_planning.py

@@ -6,21 +6,39 @@ import argparse
 from pathlib import Path
 from typing import Any
 
+from agent_lifecycle.audit.delta_review import (
+    _input_refusal,
+    build_delta_review_packet,
+)
+from agent_lifecycle.changesets.snapshot import _baseline_entries
 from agent_lifecycle.cli.plan_lock_commands import create_reviewed_plan_lock, prepare_freeze_candidate
 from agent_lifecycle.compiler import build_phase_packet, compile_small_model_packets, compile_task_packets
 from agent_lifecycle.contracts import (
     LifecycleError,
     canonical_digest,
+    load_json_object,
     read_json_object,
+    sha256_hex,
     write_json_create,
 )
+from agent_lifecycle.contracts.authority_io import create_authority_bytes
+from agent_lifecycle.contracts.canonical import canonical_bytes
 from agent_lifecycle.contracts.finding_check_schemas import (
     validate_finding_check_binding,
     validate_finding_check_evidence,
     validate_finding_check_proposal,
 )
+from agent_lifecycle.contracts.ownership_paths import require_output_footprint
+from agent_lifecycle.contracts.paths import normalize_repo_path
 from agent_lifecycle.contracts.phase_packet_schemas import PLANNING_HANDOFF_PAYLOAD_SCHEMA
 from agent_lifecycle.freeze import verify_plan_lock
+from agent_lifecycle.freeze.package_integrity import (
+    _bind_review_inputs,
+    _read_composite_reports,
+    _read_review_artifact,
+    _runtime_paths,
+    _verify_runtime_inventory,
+)
 from agent_lifecycle.planning import (
     build_plan_delta,
     build_plan_snapshot,
@@ -42,6 +60,12 @@ from agent_lifecycle.planning.verification import (
     require_plan_verification_pass,
 )
 from agent_lifecycle.policy.proposals import accept_finding_check_proposal, build_finding_check_proposal
+from agent_lifecycle.review.validation import (
+    make_review_subject,
+    review_output_paths,
+    validate_bound_plan_review,
+    validate_review_composition,
+)
 from agent_lifecycle.specification import (
     build_completion_gate_receipt,
     validate_specification,
@@ -218,6 +242,8 @@ 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 == "review-packet":
+        return _plan_review_packet(args)
     if args.plan_command in {"delta-check", "delta-validate"}:
         payload = validate_plan_delta(read_json_object(Path(args.delta), label="plan delta"))
         if args.out:
@@ -228,6 +254,137 @@ def _dispatch_plan(args: argparse.Namespace) -> dict[str, Any]:
     raise LifecycleError("command-not-implemented", "plan command is not implemented")
 
 
+def _plan_review_packet(args: argparse.Namespace) -> dict[str, Any]:
+    """Bind physical inputs before advisory selection; refusal writes nothing."""
+    root = Path(args.repository_root).resolve(strict=True)
+    if type(args.max_bytes) is not int or args.max_bytes < 1024:
+        raise LifecycleError("review-packet-limit", "Invalid packet limit")
+    subject: dict[str, Any] = {}
+    try:
+        manifest = load_json_object(_read_review_artifact(root, args.manifest), label="review manifest")
+        subject = {"manifest": manifest}
+        package = manifest.get("package")
+        if not isinstance(package, dict):
+            raise LifecycleError("review-input-incomplete", "Package needed")
+        expected = package.get("planArtifactRoot", "")
+        if not isinstance(expected, str) or not expected:
+            raise LifecycleError("review-input-incomplete", "Plan root needed")
+        if args.manifest != expected + "/plan.manifest.json":
+            raise LifecycleError("review-subject-mismatch", "Manifest location")
+        baseline, reports, sizes = _packet_baseline(root, args.baseline)
+        subject = _packet_subject(root, manifest, reports)
+        # A stable second read detects changes during inventory collection.
+        _bind_review_inputs(
+            {
+                "subject": subject,
+                "reviewAuthority": {"evidence": []},
+            },
+            root,
+            {},
+        )
+        _verify_runtime_inventory(
+            {**reports, "candidate": {"subject": subject}},
+            root,
+            require_current=True,
+        )
+        payload = build_delta_review_packet(
+            subject,
+            baseline=baseline,
+            reports=reports or None,
+            report_sizes=sizes or None,
+            max_bytes=args.max_bytes,
+        )
+    except LifecycleError as exc:
+        return _input_refusal(subject, exc.code)
+    if payload["mode"] == "FULL_REQUIRED":
+        return payload
+    outputs = [(args.out, payload, ".review-packet.json")]
+    if args.subject_out:
+        outputs.append((args.subject_out, subject, ".review-subject.json"))
+    names = [name for name, _, _ in outputs if name]
+    require_output_footprint(manifest, names, repository_root=root)
+    for name, _, suffix in outputs:
+        if name:
+            _packet_output_preflight(root, name, suffix, manifest)
+    for name, value, _ in outputs:
+        if name:
+            create_authority_bytes(root / name, canonical_bytes(value) + b"\n", root=root)
+    return payload
+
+
+def _packet_baseline(
+    root: Path,
+    path: str | None,
+) -> tuple[dict[str, Any] | None, dict[str, dict[str, Any]], dict[str, int]]:
+    if path is None:
+        return None, {}, {}
+    raw = _read_review_artifact(root, path)
+    baseline = load_json_object(raw, label="review baseline")
+    evidence: dict[str, dict[str, Any]] = {}
+    if baseline.get("schemaVersion") == "agent-plan-composite-review.v1":
+        current = baseline.get("currentReports")
+        if not isinstance(current, list) or not current:
+            raise LifecycleError("review-set-incomplete", "Current report needed")
+        report = load_json_object(_read_review_artifact(root, current[0]))
+        bound = validate_bound_plan_review(report)
+        manifest = bound["subject"]["manifest"]
+        reports, sizes = _read_composite_reports(manifest, baseline, root, evidence)
+        validate_review_composition(manifest, baseline, reports, report_sizes=sizes)
+    else:
+        bound = validate_bound_plan_review(baseline)
+        if bound["scope"]["kind"] != "FULL":
+            raise LifecycleError("review-incomplete", "Full baseline needed")
+        reports, sizes = {path: baseline}, {path: len(raw)}
+    for report in reports.values():
+        _bind_review_inputs(report, root, evidence)
+    return baseline, reports, sizes
+
+
+def _packet_subject(
+    root: Path,
+    manifest: dict[str, Any],
+    reports: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+    subjects = [r["subject"] for r in reports.values()]
+    manifests = [manifest, *(s["manifest"] for s in subjects)]
+    roots = {normalize_repo_path(m["package"]["planArtifactRoot"]) + "/" for m in manifests}
+    base = manifest.get("baseRevision")
+    source = base.get("sha") if isinstance(base, dict) else None
+    if not isinstance(source, str) or len(source) not in {40, 64}:
+        raise LifecycleError("review-source-unavailable", "Exact source needed")
+    if any(c not in "0123456789abcdef" for c in source):
+        raise LifecycleError("review-source-unavailable", "Invalid source hash")
+    paths = _runtime_paths(root, ["ls-tree", "-r", "--name-only", "-z", source], roots)
+    if len(paths) > 4096:
+        raise LifecycleError("review-input-limit", "Runtime inventory cap")
+    blobs = _baseline_entries(root, source, sorted(paths))
+    files = manifest.get("planFiles")
+    if not isinstance(files, list) or any(not isinstance(p, str) for p in files):
+        raise LifecycleError("review-input-incomplete", "Plan inventory needed")
+    if len(files) > 4096:
+        raise LifecycleError("review-input-limit", "Plan inventory cap")
+    digests = {p: sha256_hex(_read_review_artifact(root, p)) for p in set(files) - review_output_paths(manifest)}
+    return make_review_subject(manifest, digests, {p: entry["sha256"] for p, entry in blobs.items()})
+
+
+def _packet_output_preflight(
+    root: Path,
+    path: str,
+    suffix: str,
+    manifest: dict[str, Any],
+) -> None:
+    name = normalize_repo_path(path)
+    if name != path or not name.endswith(suffix):
+        raise LifecycleError("review-output-invalid", "Advisory suffix required")
+    forbidden = {".git", ".alk", ".claude", ".codex"}
+    if any(p.casefold() in forbidden for p in Path(name).parts):
+        raise LifecycleError("review-output-invalid", "Protected destination")
+    policy = manifest.get("orchestration", {})
+    declared = {value for value in policy.values() if isinstance(value, str)} if isinstance(policy, dict) else set()
+    if name in declared or (root / name).exists():
+        raise LifecycleError("review-output-invalid", "Destination reserved")
+
+
 def _verify_plan(args: argparse.Namespace) -> dict[str, Any]:
     if args.compact and not args.out:
         raise LifecycleError("plan-compact-output-required", "Compact display requires --out for the full receipt")

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/src/agent_lifecycle/cli/plan_lock_commands.py

@@ -64,7 +64,7 @@ def create_reviewed_plan_lock(
     )
     # Reject malformed or drifting package bytes before creating the
     # no-replace authority artifact. The second check still detects drift.
-    verify_plan_package_integrity(manifest, lock, repository_root=root)
+    verify_plan_package_integrity(manifest, lock, repository_root=root, require_current_review_source=True)
     lock_rel = f"{plan_root}/plan.lock.json"
     lock_path = root.joinpath(*PurePosixPath(lock_rel).parts)
     try:

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/src/agent_lifecycle/cli/planning_parsers.py

@@ -72,6 +72,13 @@ def _add_plan_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentPar
     delta.add_argument("--language-before", help="optional previous project domain language artifact")
     delta.add_argument("--language-after", help="optional current project domain language artifact")
     delta.add_argument("--out")
+    review_packet = plan_sub.add_parser("review-packet", help="select bounded review scope; never start a review")
+    review_packet.add_argument("--manifest", required=True)
+    review_packet.add_argument("--baseline")
+    review_packet.add_argument("--repository-root", default=".")
+    review_packet.add_argument("--max-bytes", type=int, default=98304)
+    review_packet.add_argument("--subject-out")
+    review_packet.add_argument("--out")
     delta_check = plan_sub.add_parser("delta-check", aliases=["delta-validate"])
     delta_check.add_argument("--delta", required=True)
     delta_check.add_argument("--out")

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/src/agent_lifecycle/contracts/plan_delta_schemas.py

@@ -10,6 +10,17 @@ PROJECT_PRINCIPLES_SCHEMA = "agent-project-principles.v1"
 PROJECT_PRINCIPLES_VALIDATION_SCHEMA = "agent-project-principles-validation.v1"
 PLAN_DELTA_SCHEMA = "agent-plan-delta.v1"
 PLAN_DELTA_VALIDATION_SCHEMA = "agent-plan-delta-validation.v1"
+PLAN_IMPACT_GRAPH_SCHEMA = "agent-plan-impact-graph.v1"
+DELTA_REVIEW_SCHEMA = "agent-plan-delta-review.v1"
+IMPACT_SELECTION_SCHEMA = "agent-plan-impact-selection.v1"
+REVIEW_SCOPE_SCHEMA = "agent-plan-review-scope.v1"
+COMPOSITE_REVIEW_SCHEMA = "agent-plan-composite-review.v1"
+PLAN_LOCK_SCOPE_SCHEMA = "agent-plan-lock.v3"
+MAX_REVIEW_REPORTS = 16
+MAX_REVIEW_DEPENDENCY_EDGES = 8
+MAX_REVIEW_CHAIN_BYTES = 8 * 1024 * 1024
+MAX_IMPACT_NODES = 4096
+MAX_IMPACT_EDGES = 16384
 
 _DIGEST = {"type": "string", "minLength": 64, "maxLength": 64}
 _OPTIONAL_DIGEST = {"type": ["string", "null"], "minLength": 0, "maxLength": 64}
@@ -20,6 +31,119 @@ _BOUNDED_LIST = {"type": "array", "items": _BOUNDED_TEXT, "maxItems": 32}
 
 
 PLAN_DELTA_SCHEMAS: dict[str, dict[str, Any]] = {
+    IMPACT_SELECTION_SCHEMA: open_object_schema(
+        IMPACT_SELECTION_SCHEMA,
+        required=["mode", "baseHash", "candidateHash", "closure", "selectionDigest"],
+        properties={
+            "mode": {"enum": ["DELTA_ELIGIBLE", "FULL_REQUIRED"]},
+            "baseHash": _DIGEST,
+            "candidateHash": _DIGEST,
+            "closure": {"type": "array", "items": _BOUNDED_TEXT},
+            "selectionDigest": _DIGEST,
+        },
+    ),
+    COMPOSITE_REVIEW_SCHEMA: open_object_schema(
+        COMPOSITE_REVIEW_SCHEMA,
+        required=[
+            "packageId",
+            "planRevision",
+            "reviewId",
+            "reviewedPlanHash",
+            "fullReview",
+            "verdict",
+            "reviewScope",
+            "reportBindings",
+        ],
+        properties={
+            "fullReview": {"const": False},
+            "verdict": {"const": "READY_TO_FREEZE"},
+            "reviewedPlanHash": _DIGEST,
+            "reviewScope": {"type": "object"},
+            "reportBindings": {"type": "object", "maxProperties": 128},
+        },
+    ),
+    "agent-plan-review.v2": open_object_schema(
+        "agent-plan-review.v2",
+        required=[
+            "packageId",
+            "planRevision",
+            "reviewId",
+            "reviewedPlanHash",
+            "fullReview",
+            "reviewer",
+            "verdict",
+            "findings",
+            "subject",
+            "reviewScope",
+            "reviewAuthority",
+        ],
+        properties={
+            "reviewedPlanHash": _DIGEST,
+            "fullReview": {"type": "boolean"},
+            "reviewer": {"type": "object"},
+            "subject": {"type": "object"},
+            "verdict": {"enum": ["READY_TO_FREEZE", "ACCEPTED", "CHANGES_REQUIRED", "BLOCKED"]},
+            "findings": {"type": "array", "maxItems": 128},
+            "reviewScope": {"type": "object"},
+            "reviewAuthority": {"type": "object"},
+        },
+    ),
+    PLAN_IMPACT_GRAPH_SCHEMA: open_object_schema(
+        PLAN_IMPACT_GRAPH_SCHEMA,
+        required=["manifestHash", "nodes", "edges", "graphDigest"],
+        properties={
+            "manifestHash": _DIGEST,
+            "nodes": {
+                "type": "array",
+                "maxItems": MAX_IMPACT_NODES,
+                "items": {"type": "object"},
+            },
+            "edges": {
+                "type": "array",
+                "maxItems": MAX_IMPACT_EDGES,
+                "items": {"type": "object"},
+            },
+            "graphDigest": _DIGEST,
+        },
+    ),
+    REVIEW_SCOPE_SCHEMA: open_object_schema(
+        REVIEW_SCOPE_SCHEMA,
+        required=["kind", "candidateHash", "graphDigest", "coveredNodes"],
+        properties={
+            "kind": {"enum": ["FULL", "DELTA", "COMPOSITE"]},
+            "candidateHash": _DIGEST,
+            "graphDigest": _DIGEST,
+            "coveredNodes": {
+                "type": "array",
+                "maxItems": MAX_IMPACT_NODES,
+                "items": _BOUNDED_TEXT,
+                "uniqueItems": True,
+            },
+        },
+    ),
+    DELTA_REVIEW_SCHEMA: open_object_schema(
+        DELTA_REVIEW_SCHEMA,
+        required=[
+            "mode",
+            "reasons",
+            "baseHash",
+            "candidateHash",
+            "changedNodes",
+            "closure",
+            "readOnly",
+            "packetDigest",
+        ],
+        properties={
+            "mode": {"enum": ["FULL", "DELTA_ELIGIBLE", "FULL_REQUIRED"]},
+            "reasons": _BOUNDED_LIST,
+            "baseHash": {"type": ["string", "null"]},
+            "candidateHash": _DIGEST,
+            "changedNodes": {"type": "array", "items": _BOUNDED_TEXT},
+            "closure": {"type": "array", "items": _BOUNDED_TEXT},
+            "readOnly": {"const": True},
+            "packetDigest": _DIGEST,
+        },
+    ),
     PROJECT_PRINCIPLES_SCHEMA: open_object_schema(
         PROJECT_PRINCIPLES_SCHEMA,
         required=[

{agent_lifecycle_kit-2.21.0 → agent_lifecycle_kit-2.22.0}/src/agent_lifecycle/contracts/schemas.py

@@ -367,6 +367,27 @@ LIFECYCLE_START_SCHEMAS: dict[str, dict[str, Any]] = {
     ),
 }
 PLAN_INTEGRITY_SCHEMAS: dict[str, dict[str, Any]] = {
+    "agent-plan-lock.v3": open_object_schema(
+        "agent-plan-lock.v3",
+        required=[
+            "packageId",
+            "planRevision",
+            "manifestHash",
+            "planFilesHash",
+            "entries",
+            "reviewEvidence",
+            "reviewEvidenceDigest",
+            "reviewScopeKind",
+        ],
+        properties={
+            "manifestHash": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+            "planFilesHash": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+            "entries": {"type": "array", "minItems": 1, "items": {"type": "object"}},
+            "reviewEvidence": {"type": "array", "minItems": 1, "items": {"type": "object"}},
+            "reviewEvidenceDigest": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+            "reviewScopeKind": {"const": "COMPOSITE"},
+        },
+    ),
     "agent-plan-file-inventory.v1": open_object_schema(
         "agent-plan-file-inventory.v1",
         required=["schemaVersion", "entries"],
@@ -402,7 +423,7 @@ PLAN_INTEGRITY_SCHEMAS: dict[str, dict[str, Any]] = {
             "schemaVersion": {"const": "agent-plan-package-integrity-verification.v1"},
             "status": {"enum": ["PASS", "FAIL"]},
             "required": {"type": "boolean"},
-            "lockSchemaVersion": {"enum": ["agent-plan-lock.v1", "agent-plan-lock.v2"]},
+            "lockSchemaVersion": {"enum": ["agent-plan-lock.v1", "agent-plan-lock.v2", "agent-plan-lock.v3"]},
             "filesystemVerified": {"type": "boolean"},
             "manifestHash": {"type": "string", "minLength": 64, "maxLength": 64},
             "planFilesHash": {"type": ["string", "null"], "minLength": 0, "maxLength": 64},