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

{agent_lifecycle_kit-2.22.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.22.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.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).
+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.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).
+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.22.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.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).
+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.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).
+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.22.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.22.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.22.0 → agent_lifecycle_kit-2.23.0}/src/agent_lifecycle/_version.py

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

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.22.0 → agent_lifecycle_kit-2.23.0}/src/agent_lifecycle/cli/dispatch_planning.py

@@ -11,6 +11,7 @@ from agent_lifecycle.audit.delta_review import (
     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 (
@@ -126,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,

{agent_lifecycle_kit-2.22.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)

agent_lifecycle_kit-2.23.0/src/agent_lifecycle/contracts/compact_plan_schemas.py

@@ -0,0 +1,261 @@
+"""Closed, bounded compact authoring input; no review or execution authority."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, NoReturn
+
+from agent_lifecycle.contracts.canonical import canonical_bytes
+from agent_lifecycle.contracts.errors import LifecycleError
+from agent_lifecycle.contracts.paths import normalize_repo_path
+
+COMPACT_PLAN_SCHEMA = "agent-compact-plan.v1"
+MAX_COMPACT_INPUT_BYTES = 65536
+MAX_COMPACT_OUTPUT_BYTES = 262144
+MAX_COMPACT_CHANGES = 12
+MAX_COMPACT_COMMANDS = 32
+COMPACT_RISKS = frozenset(
+    (
+        "architecture",
+        "security",
+        "performance",
+        "browser",
+        "externalEnvironment",
+        "data",
+        "release",
+        "externalSpecification",
+    )
+)
+ORCHESTRATION_FIELDS = frozenset(
+    (
+        "startMode",
+        "remediationMode",
+        "maxPlanReviewRounds",
+        "maxTaskAttempts",
+        "maxParallelTasks",
+        "maxValidationRunsPerTask",
+        "maxToolCallsPerIteration",
+        "maxUsageIterationsPerAttempt",
+        "maxToolCallsPerTask",
+        "maxToolCallsPerRun",
+        "maxReportedTokensPerTask",
+        "maxReportedTokensPerRun",
+        "maxEvidenceArtifactBytes",
+        "maxEvidenceBytesPerTask",
+        "maxEvidenceBytesPerRun",
+        "maxTaskWallSeconds",
+        "maxRunWallSeconds",
+        "maxContextBytes",
+        "maxRenderedPacketBytes",
+    )
+)
+_ROOT_FIELDS = frozenset(
+    (
+        "schemaVersion",
+        "tier",
+        "mechanical",
+        "package",
+        "author",
+        "baseRevision",
+        "owner",
+        "riskFlags",
+        "changes",
+        "orchestration",
+        "releaseImpact",
+        "readOnly",
+        "forbiddenWrites",
+        "securityGates",
+        "contextLimits",
+    )
+)
+_CHANGE_FIELDS = frozenset(
+    ("id", "title", "requirement", "acceptance", "evidenceDescription", "evidencePath", "writes", "validationCommands")
+)
+_ID = re.compile(r"[A-Za-z][A-Za-z0-9_-]{0,39}\Z")
+_SHA = re.compile(r"[0-9a-f]{40}\Z")
+
+
+def load_compact_plan_input(raw: bytes) -> dict[str, Any]:
+    """Parse only bounded UTF-8 JSON with unique keys and finite numbers."""
+    if not isinstance(raw, bytes) or len(raw) > MAX_COMPACT_INPUT_BYTES:
+        _fail("input-too-large", "Compact input must be bytes within 65536 bytes")
+    try:
+        value = json.loads(raw.decode("utf-8"), object_pairs_hook=_unique_object, parse_constant=_nonfinite)
+    except (UnicodeError, ValueError, RecursionError):
+        _fail("json-invalid", "Compact input must be finite, bounded UTF-8 JSON")
+    return require_compact_plan_input(value)
+
+
+def require_compact_plan_input(value: Any) -> dict[str, Any]:
+    """Validate the exact source shape without inferring low risk or missing facts."""
+    source = _object(value, _ROOT_FIELDS, "input")
+    if source["schemaVersion"] != COMPACT_PLAN_SCHEMA:
+        _fail("schema-unsupported", "Unsupported compact input schema")
+    if source["tier"] not in ("S0", "S1"):
+        _fail("full-s2-required", "Compact authoring requires explicit S0/S1; use the full S2 route")
+    if type(source["mechanical"]) is not bool:
+        _fail("mechanical-invalid", "mechanical must be a boolean")
+    if source["tier"] == "S0" and source["mechanical"] is not True:
+        _fail("full-s2-required", "S0 requires explicitly bounded mechanical work")
+    package = _object(source["package"], {"id", "title", "planArtifactRoot", "artifactRoot"}, "package")
+    for field in ("id", "title"):
+        _text(package[field], "package." + field, 200)
+    for field in ("planArtifactRoot", "artifactRoot"):
+        _path(package[field], "package." + field)
+    for field in ("author", "owner"):
+        _text(source[field], field, 200)
+    base = _object(source["baseRevision"], {"ref", "sha"}, "baseRevision")
+    _text(base["ref"], "baseRevision.ref", 200)
+    if not isinstance(base["sha"], str) or _SHA.fullmatch(base["sha"]) is None:
+        _fail("base-invalid", "baseRevision.sha must be exactly 40 lowercase hex characters")
+    risks = _object(source["riskFlags"], COMPACT_RISKS, "riskFlags")
+    if any(type(flag) is not bool for flag in risks.values()):
+        _fail("risk-invalid", "Every risk flag must be a strict boolean")
+    if any(risks.values()):
+        _fail("full-s2-required", "Elevated risk requires the full S2 route")
+    changes = _list(source["changes"], "changes", 1, MAX_COMPACT_CHANGES)
+    if source["tier"] == "S0" and len(changes) != 1:
+        _fail("full-s2-required", "S0 requires exactly one change")
+    _changes(changes)
+    _orchestration(source["orchestration"])
+    _text(source["releaseImpact"], "releaseImpact")
+    _paths(source["readOnly"], "readOnly", 0)
+    _paths(source["forbiddenWrites"], "forbiddenWrites", 0)
+    for gate in _list(source["securityGates"], "securityGates", 1, 32):
+        _text(gate, "securityGates[]")
+    _context(source["contextLimits"])
+    if len(canonical_bytes(source)) > MAX_COMPACT_INPUT_BYTES:
+        _fail("input-too-large", "Compact input exceeds 65536 UTF-8 bytes")
+    return source
+
+
+def _changes(changes: list[Any]) -> None:
+    seen: set[str] = set()
+    command_count = 0
+    for item in changes:
+        change = _object(item, _CHANGE_FIELDS, "change")
+        identity = change["id"]
+        if not isinstance(identity, str) or _ID.fullmatch(identity) is None:
+            _fail("change-id-invalid", "Change id must be a bounded literal identifier")
+        if identity.casefold() in seen:
+            _fail("change-id-duplicate", "Change ids must be unique without ambiguous case aliases")
+        seen.add(identity.casefold())
+        _text(change["title"], "change.title", 200)
+        for name in ("requirement", "acceptance", "evidenceDescription"):
+            _text(change[name], "change." + name)
+        _path(change["evidencePath"], "change.evidencePath")
+        _paths(change["writes"], "change.writes", 1)
+        commands = _list(change["validationCommands"], "change.validationCommands", 1, MAX_COMPACT_COMMANDS)
+        for command in commands:
+            _text(command, "change.validationCommands[]")
+        command_count += len(commands)
+    if command_count > MAX_COMPACT_COMMANDS:
+        _fail("commands-too-many", "Total validation command occurrences exceed 32")
+
+
+def _orchestration(value: Any) -> None:
+    policy = _object(value, ORCHESTRATION_FIELDS, "orchestration")
+    if policy["startMode"] != "manual-after-freeze" or policy["remediationMode"] not in ("ask", "bounded-auto"):
+        _fail("execution-mode-invalid", "Compact plans require reviewed freeze and separate manual authorization")
+    for field in ORCHESTRATION_FIELDS - {"startMode", "remediationMode"}:
+        _positive_integer(policy[field], "orchestration." + field)
+    if policy["maxParallelTasks"] != 1 or policy["maxTaskAttempts"] > 3 or policy["maxPlanReviewRounds"] > 4:
+        _fail("execution-limits-invalid", "Compact work is serial with at most 3 attempts and 4 review rounds")
+    pairs = (
+        ("maxToolCallsPerTask", "maxToolCallsPerRun"),
+        ("maxReportedTokensPerTask", "maxReportedTokensPerRun"),
+        ("maxTaskWallSeconds", "maxRunWallSeconds"),
+        ("maxEvidenceArtifactBytes", "maxEvidenceBytesPerTask"),
+        ("maxEvidenceBytesPerTask", "maxEvidenceBytesPerRun"),
+    )
+    if any(policy[small] > policy[large] for small, large in pairs):
+        _fail("execution-limits-invalid", "Per-task and per-artifact caps must fit enclosing caps")
+
+
+def _context(value: Any) -> None:
+    limits = _object(
+        value,
+        {"targetReviewerPacketTokens", "maxReviewerPacketTokens", "smallContextProfilesRequired"},
+        "contextLimits",
+    )
+    for field in ("targetReviewerPacketTokens", "maxReviewerPacketTokens"):
+        _positive_integer(limits[field], "contextLimits." + field)
+    if limits["targetReviewerPacketTokens"] > limits["maxReviewerPacketTokens"]:
+        _fail("context-invalid", "Target reviewer packet must fit its maximum")
+    if limits["smallContextProfilesRequired"] is not True:
+        _fail("context-invalid", "Small-context profiles must remain required")
+
+
+def _object(value: Any, fields: set[str] | frozenset[str], label: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or set(value) != fields:
+        _fail("fields-invalid", label + " must contain exactly its declared fields")
+    return value
+
+
+def _list(value: Any, label: str, minimum: int, maximum: int) -> list[Any]:
+    if not isinstance(value, list) or not minimum <= len(value) <= maximum:
+        _fail("list-invalid", label + " has an invalid type or item count")
+    return value
+
+
+def _text(value: Any, label: str, maximum: int = 4096) -> str:
+    if not isinstance(value, str) or not value.strip() or len(value) > maximum or "\x00" in value:
+        _fail("text-invalid", label + " must be nonempty bounded text without NUL")
+    try:
+        value.encode("utf-8")
+    except UnicodeError:
+        _fail("text-invalid", label + " must be valid UTF-8 text")
+    return value
+
+
+def _positive_integer(value: Any, label: str) -> None:
+    if type(value) is not int or value <= 0:
+        _fail("integer-invalid", label + " must be a strict positive integer")
+
+
+def _path(value: Any, label: str) -> str:
+    _text(value, label, 1024)
+    if any(character in value for character in "*?[]"):
+        _fail("path-invalid", label + " must be a literal path without wildcards")
+    normalized = normalize_repo_path(value, label=label)
+    if normalized != value:
+        _fail("path-invalid", label + " must already be a canonical literal relative path")
+    return normalized
+
+
+def _paths(value: Any, label: str, minimum: int) -> None:
+    paths = _list(value, label, minimum, 128)
+    normalized = [_path(path, label + "[]") for path in paths]
+    if len({path.casefold() for path in normalized}) != len(normalized):
+        _fail("path-duplicate", label + " contains duplicate or ambiguous paths")
+
+
+def _unique_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            _fail("json-duplicate-key", "Duplicate JSON keys are forbidden")
+        result[key] = value
+    return result
+
+
+def _nonfinite(_: str) -> Any:
+    _fail("json-nonfinite", "Non-finite JSON numbers are forbidden")
+
+
+def _fail(code: str, message: str) -> NoReturn:
+    raise LifecycleError("compact-plan-" + code, message)
+
+
+__all__ = [
+    "COMPACT_PLAN_SCHEMA",
+    "COMPACT_RISKS",
+    "MAX_COMPACT_CHANGES",
+    "MAX_COMPACT_COMMANDS",
+    "MAX_COMPACT_INPUT_BYTES",
+    "MAX_COMPACT_OUTPUT_BYTES",
+    "ORCHESTRATION_FIELDS",
+    "load_compact_plan_input",
+    "require_compact_plan_input",
+]