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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 2.21.0
+Version: 2.23.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.23 adds [compact S0/S1 authoring](docs/reference/tier-proportional-plan-packages.md) with explicit checklist completion and unchanged approval gates. 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.23.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.23.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.23 adds [compact S0/S1 authoring](docs/reference/tier-proportional-plan-packages.md) with explicit checklist completion and unchanged approval gates. 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.23.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.23.0}/pyproject.toml

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

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

agent_lifecycle_kit-2.23.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.23.0/src/agent_lifecycle/cli/compact_plan_commands.py

@@ -0,0 +1,197 @@
+"""Create-only compact authoring and read-only explanations; no lifecycle authority."""
+
+from __future__ import annotations
+
+import os
+import stat
+import unicodedata
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.compiler.task_packets import packet_publication_lock
+from agent_lifecycle.contracts import LifecycleError, canonical_bytes, canonical_digest, load_json_object
+from agent_lifecycle.contracts.authority_io import hold_authority_directory
+from agent_lifecycle.contracts.compact_plan_schemas import MAX_COMPACT_INPUT_BYTES
+from agent_lifecycle.contracts.execution_target import discard_created_output
+from agent_lifecycle.contracts.ownership_paths import (
+    normalize_authority_path,
+    repository_authority_name,
+    require_manifest_authority_paths,
+)
+from agent_lifecycle.contracts.paths import read_stable_repository_file
+from agent_lifecycle.planning.compact_packages import (
+    build_plan_package_profiles,
+    compile_compact_plan,
+    explain_compact_plan,
+)
+
+_FD_PATH_IDENTITY_FIELDS = 5 if os.name == "nt" else 6
+
+_DRAFT_PREREQUISITE = (
+    "Before freeze-prepare: author acceptance-criteria.md from the explicit AC/EV facts "
+    "and add it to planFiles. The prepared candidate still needs current independent review before lock-create"
+)
+
+
+def compact_package_profiles() -> dict[str, Any]:
+    """Include filesystem authoring prerequisites in the user-facing tier view."""
+    body = build_plan_package_profiles()
+    body.pop("profileDigest")
+    body["draftCompletionPrerequisites"] = [_DRAFT_PREREQUISITE]
+    for profile in body["profiles"]:
+        if profile["compactSupported"]:
+            profile["requiredArtifacts"].append("acceptance-criteria.md explicitly added to planFiles before freeze")
+    return {**body, "profileDigest": canonical_digest(body)}
+
+
+def compact_plan_command(
+    *, input_path: str, repository_root: Path, output_path: str | None = None, explain: bool = False
+) -> dict[str, Any]:
+    """Consume one stable bounded source; publishing never overwrites an artifact."""
+    root = repository_root.resolve(strict=True)
+    source_name = _name(root, input_path)
+    _inspect_path(root, source_name)
+    source_version = _version(root / source_name)
+    raw = _read(root, source_name)
+    if _version(root / source_name) != source_version:
+        raise LifecycleError("compact-plan-source-changed", "Compact source changed while being read")
+    source = load_json_object(raw, label="compact source")
+    package = source.get("package")
+    plan_root = package.get("planArtifactRoot") if isinstance(package, dict) else None
+    default_output = plan_root + "/plan.manifest.json" if isinstance(plan_root, str) else "plan.manifest.json"
+    destination = _name(root, output_path or default_output)
+    explanation = None
+    if explain:
+        explanation = explain_compact_plan(source, source_path=source_name, manifest_path=destination)
+        if explanation["status"] != "PASS":
+            return explanation
+    manifest = compile_compact_plan(source, source_path=source_name, manifest_path=destination)
+    require_manifest_authority_paths(manifest, operation_root=root)
+    _inspect_manifest_paths(root, manifest)
+    if explanation is not None:
+        return {**explanation, "nextCommands": [_DRAFT_PREREQUISITE, *explanation["nextCommands"]]}
+    prepared = canonical_bytes(manifest) + b"\n"
+    _publish(root, source_name, raw, source_version, destination, prepared)
+    return {
+        "schemaVersion": "agent-compact-plan-compilation.v1",
+        "status": "DRAFT",
+        "manifestPath": destination,
+        "manifestDigest": canonical_digest(manifest),
+        "sourcePath": source_name,
+        "sourceBytes": len(raw),
+        "canonicalOutputBytes": len(prepared),
+        "filesWritten": [destination],
+        "authorityClaimed": False,
+        "modelCallsStarted": False,
+        "nextCommands": [_DRAFT_PREREQUISITE, "plan freeze-prepare", "independent plan review", "plan lock-create"],
+    }
+
+
+def _name(root: Path, name: str) -> str:
+    return normalize_authority_path(repository_authority_name(root / name, root))
+
+
+def _read(root: Path, name: str) -> bytes:
+    return read_stable_repository_file(root, name, max_bytes=MAX_COMPACT_INPUT_BYTES, label="compact source")
+
+
+def _inspect_path(root: Path, name: str) -> None:
+    """Reject observed link/name ambiguity without probing filesystem rules by writing."""
+    current = root
+    for part in normalize_authority_path(name).split("/"):
+        matches = []
+        try:
+            with os.scandir(current) as entries:
+                for index, entry in enumerate(entries):
+                    if index >= 10_000:
+                        raise LifecycleError("compact-plan-directory-too-large", "Directory inspection exceeds limit")
+                    if unicodedata.normalize("NFC", entry.name).casefold() == part.casefold():
+                        matches.append(entry.name)
+        except FileNotFoundError:
+            return
+        if not matches:
+            return
+        if len(matches) != 1 or unicodedata.normalize("NFC", matches[0]) != part:
+            raise LifecycleError("compact-plan-path-alias", "Authority path has an ambiguous or aliased name")
+        current = current / part
+        info = current.lstat()
+        if stat.S_ISLNK(info.st_mode) or getattr(info, "st_file_attributes", 0) & 0x400:
+            raise LifecycleError("compact-plan-path-alias", "Authority path cannot contain a link")
+        if stat.S_ISREG(info.st_mode) and info.st_nlink != 1:
+            raise LifecycleError("compact-plan-path-alias", "Authority file has multiple hard links")
+
+
+def _inspect_manifest_paths(root: Path, manifest: dict[str, Any]) -> None:
+    names = [*manifest["planFiles"], manifest["package"]["artifactRoot"]]
+    names.extend(manifest["readOnly"])
+    names.extend(manifest["forbiddenWrites"])
+    for task in manifest["workstreams"]:
+        names.extend(task["writes"])
+    names.extend(entry["artifactPath"] for entry in manifest["acceptance"]["evidence"])
+    for name in sorted(set(names)):
+        _inspect_path(root, name)
+
+
+def _version(path: Path) -> tuple[int, ...]:
+    info = path.lstat()
+    return (*_identity(info), info.st_nlink)
+
+
+def _identity(info: os.stat_result) -> tuple[int, ...]:
+    """Capture the created descriptor's exact fingerprint for guarded rollback."""
+    return info.st_dev, info.st_ino, info.st_mode, info.st_size, info.st_mtime_ns, info.st_ctime_ns
+
+
+def _created_identity(fd: int, path_info: os.stat_result) -> tuple[int, ...]:
+    """Join fd/path metadata, retaining a full path fingerprint for rollback.
+
+    Windows fstat ctime can be change time while path stat reports birth time.
+    All comparable fields must agree before using the path API's fingerprint.
+    """
+    descriptor = _identity(os.fstat(fd))
+    observed = _identity(path_info)
+    fields = _FD_PATH_IDENTITY_FIELDS
+    return observed if descriptor[:fields] == observed[:fields] else descriptor
+
+
+def _require_same_source(root: Path, name: str, raw: bytes, version: tuple[int, ...]) -> None:
+    _inspect_path(root, name)
+    if _version(root / name) != version or _read(root, name) != raw or _version(root / name) != version:
+        raise LifecycleError("compact-plan-source-changed", "Compact source changed before publication completed")
+
+
+def _publish(root: Path, source: str, raw: bytes, version: tuple[int, ...], destination: str, prepared: bytes) -> None:
+    path = root / destination
+    with packet_publication_lock(path.parent):
+        _inspect_path(root, destination)
+        if path.exists():
+            raise LifecycleError("compact-plan-output-exists", "Canonical output must not already exist")
+        _require_same_source(root, source, raw, version)
+        created = False
+        created_identity = None
+        try:
+            with hold_authority_directory(path.parent, writable=True) as directory:
+                fd = directory.write_child(path.name, append=False, mode=0o644)
+                created = True
+                created_identity = _created_identity(fd, directory.stat_child(path.name))
+                with os.fdopen(fd, "wb") as stream:
+                    try:
+                        stream.write(prepared)
+                        stream.flush()
+                        os.fsync(stream.fileno())
+                    finally:
+                        created_identity = _created_identity(stream.fileno(), directory.stat_child(path.name))
+                directory.sync()
+            _require_same_source(root, source, raw, version)
+        except FileExistsError:
+            if created and created_identity is not None:
+                discard_created_output(
+                    root, destination, [prepared], expected_identity=created_identity, allow_partial=True
+                )
+            raise LifecycleError("compact-plan-output-exists", "Canonical output must not already exist") from None
+        except BaseException:
+            if created and created_identity is not None:
+                discard_created_output(
+                    root, destination, [prepared], expected_identity=created_identity, allow_partial=True
+                )
+            raise

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

@@ -6,21 +6,40 @@ 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.compact_plan_commands import compact_package_profiles, compact_plan_command
 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 +61,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,
@@ -102,6 +127,15 @@ def _dispatch_specification(args: argparse.Namespace) -> dict[str, Any]:
 
 
 def _dispatch_plan(args: argparse.Namespace) -> dict[str, Any]:
+    if args.plan_command == "package-profiles":
+        return compact_package_profiles()
+    if args.plan_command in {"compact-compile", "compact-explain"}:
+        return compact_plan_command(
+            input_path=args.input,
+            output_path=getattr(args, "out", None),
+            repository_root=Path(args.repository_root),
+            explain=args.plan_command == "compact-explain",
+        )
     if args.plan_command == "freeze-prepare":
         return prepare_freeze_candidate(
             manifest_path=args.manifest,
@@ -218,6 +252,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 +264,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.23.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.23.0}/src/agent_lifecycle/cli/planning_parsers.py

@@ -12,6 +12,14 @@ _SMALL_CONTEXT_PROFILE = builtin_profile_path("small-context-profile.v1.json")
 def _add_plan_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
     plan = subparsers.add_parser("plan", help="plan commands")
     plan_sub = plan.add_subparsers(dest="plan_command", required=True)
+    plan_sub.add_parser("package-profiles", help="describe tier obligations without granting authority")
+    compact = plan_sub.add_parser("compact-compile", help="create a canonical DRAFT from bounded compact input")
+    compact.add_argument("--input", required=True)
+    compact.add_argument("--out", required=True)
+    compact.add_argument("--repository-root", default=".")
+    explain = plan_sub.add_parser("compact-explain", help="explain compact input without writing or executing")
+    explain.add_argument("--input", required=True)
+    explain.add_argument("--repository-root", default=".")
     prepare = plan_sub.add_parser("freeze-prepare", help="create a new review candidate; never a review or lock")
     prepare.add_argument("--manifest", required=True)
     prepare.add_argument("--out", required=True)
@@ -72,6 +80,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")