agent-lifecycle-kit 2.16.0__tar.gz → 2.17.0__tar.gz

{agent_lifecycle_kit-2.16.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 2.16.0
+Version: 2.17.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.16 adds 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.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.16.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.17.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.16.0 → agent_lifecycle_kit-2.17.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.16 adds 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.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.16.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.17.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.16.0 → agent_lifecycle_kit-2.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "2.16.0"
+version = "2.17.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"
@@ -41,9 +41,9 @@ dependencies = []
 
 [dependency-groups]
 quality = [
-  "ruff==0.16.5",
-  "mypy==2.3.1",
-  "coverage==7.15.4",
+  "ruff==0.17.1",
+  "mypy==2.4.0",
+  "coverage==7.16.2",
   "jsonschema==4.26.0",
 ]
 

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "2.16.0"
+__version__ = "2.17.0"

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/cli/dispatch.py

@@ -73,8 +73,20 @@ def dispatch_benchmark(args: argparse.Namespace) -> dict[str, Any] | str | None:
     return _lazy_call("agent_lifecycle.cli.benchmarks", "dispatch_benchmark", args)
 
 
+def require_known_arguments(args: argparse.Namespace, remainder: list[str]) -> None:
+    """Reject unowned arguments before a command can cause side effects."""
+    target = COMMAND_DISPATCH.get(args.command)
+    if remainder and (target is None or not target[2]):
+        raise LifecycleError(
+            "cli-unrecognized-arguments",
+            "Command contains unrecognized arguments",
+            {"argumentCount": len(remainder)},
+        )
+
+
 def dispatch(args: argparse.Namespace, remainder: list[str]) -> dict[str, Any] | str | None:
     """Route a parsed command without owning domain behavior or CLI output."""
+    require_known_arguments(args, remainder)
     target = COMMAND_DISPATCH.get(args.command)
     if target is None:
         raise LifecycleError(
@@ -84,5 +96,4 @@ def dispatch(args: argparse.Namespace, remainder: list[str]) -> dict[str, Any] |
     function = globals()[function_name]
     if accepts_remainder:
         return function(args, remainder)
-    del remainder
     return function(args)

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/cli/dispatch_lifecycle.py

@@ -229,6 +229,7 @@ def _dispatch_workflow_task(args: argparse.Namespace, state_path: Path) -> dict[
             expected_revision=args.expected_revision,
             blocker_code=args.blocker_code,
             reason=args.reason,
+            review_task_id=getattr(args, "review_task", None),
         )
     if args.workflow_command == "resolve":
         return resolve_blocker(

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/cli/dispatch_planning.py

@@ -112,7 +112,7 @@ def _dispatch_plan(args: argparse.Namespace) -> dict[str, Any]:
             "schemaVersion": "agent-plan-check.v1",
             "manifest": validate_plan_manifest(
                 manifest,
-                require_completeness=args.require_completeness,
+                require_completeness=True,
                 completeness_profile=completeness_profile,
             ),
             "lock": verify_plan_lock(manifest, lock) if lock else None,

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/cli/lifecycle_parsers.py

@@ -678,6 +678,7 @@ def _add_workflow_control_parsers(
     workflow_block.add_argument("--operation-id", required=True)
     workflow_block.add_argument("--expected-revision", required=True, type=int)
     workflow_block.add_argument("--blocker-code", required=True)
+    workflow_block.add_argument("--review-task")
     workflow_block.add_argument("--reason", required=True)
     workflow_resolve = workflow_sub.add_parser("resolve")
     workflow_resolve.add_argument("--state", required=True)

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/cli/main.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import sys
 
-from agent_lifecycle.cli.dispatch import dispatch
+from agent_lifecycle.cli.dispatch import dispatch, require_known_arguments
 from agent_lifecycle.cli.errors import to_lifecycle_error
 from agent_lifecycle.cli.parsers import build_parser
 from agent_lifecycle.contracts import LifecycleError, canonical_bytes
@@ -19,6 +19,7 @@ def main(argv: list[str] | None = None) -> int:
             from agent_lifecycle.neutrality.cli import main as neutrality_main
 
             return neutrality_main(remainder)
+        require_known_arguments(args, remainder)
         payload = dispatch(args, remainder)
     except LifecycleError as exc:
         _write(exc.to_json())

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/compiler/task_packets.py

@@ -20,6 +20,7 @@ from agent_lifecycle.contracts.ownership_paths import (
     require_output_footprint,
 )
 from agent_lifecycle.freeze import verify_plan_package_integrity
+from agent_lifecycle.planning.validation import validate_plan_manifest
 from agent_lifecycle.policy.execution_strategy import validate_execution_strategy
 
 
@@ -59,6 +60,7 @@ def compile_task_packets(
 def _verify_manifest(root: Path, manifest: dict[str, Any]) -> str:
     if manifest.get("status") != "FROZEN":
         raise LifecycleError("plan-not-frozen", "only FROZEN plans can be compiled")
+    validate_plan_manifest(manifest, require_completeness=True)
     package = manifest.get("package", {})
     plan_root = package.get("planArtifactRoot")
     if not isinstance(plan_root, str) or not plan_root:

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/contracts/canonical.py

@@ -94,6 +94,14 @@ def read_json_object(path: Path, *, label: str | None = None) -> dict[str, Any]:
     return load_json_object(data, label=label or "JSON document")
 
 
+def prepare_json_object(value: Any, *, label: str = "JSON output") -> bytes:
+    """Prepare the exact stored bytes and prove they fit the existing reader."""
+    _validate_json_nesting(value)
+    data = canonical_bytes(value) + b"\n"
+    load_json_object(data, label=label)
+    return data
+
+
 def write_json_create(path: Path, value: Any) -> bytes:
     data = canonical_bytes(value) + b"\n"
     try:

agent_lifecycle_kit-2.17.0/src/agent_lifecycle/contracts/persistence.py

@@ -0,0 +1,52 @@
+"""Shared private persistence primitives for local lifecycle state."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.contracts.canonical import (
+    canonical_digest,
+    prepare_json_object,
+    require_private_file,
+    write_json_create,
+    write_json_create_private,
+    write_json_replace_private,
+)
+from agent_lifecycle.contracts.errors import LifecycleError
+from agent_lifecycle.contracts.paths import normalize_repo_path
+
+
+def prepared_artifact_identity(path: str, value: dict[str, Any]) -> dict[str, Any]:
+    """Derive a bounded canonical artifact identity without touching storage."""
+    path = normalize_repo_path(path)
+    data = prepare_json_object(value, label="prospective workflow artifact")
+    return {"path": path, "sha256": canonical_digest(value), "bytes": len(data)}
+
+
+def persist_json_artifact(root: Path, identity: dict[str, Any], value: dict[str, Any]) -> None:
+    """Create the exact preflighted artifact using the existing authority writer."""
+    if prepared_artifact_identity(identity["path"], value) != identity:
+        raise LifecycleError("workflow-artifact-preparation-mismatch", "prepared artifact changed before persistence")
+    write_json_create(root / identity["path"], value)
+
+
+def create_private_json(path: Path, value: Any) -> bytes:
+    """Create one owner-only JSON artifact without replacing an existing file."""
+
+    return write_json_create_private(path, value)
+
+
+def replace_private_json(path: Path, value: Any) -> bytes:
+    """Atomically replace one owner-only JSON artifact and sync its directory."""
+
+    return write_json_replace_private(path, value)
+
+
+def require_private_json(path: Path) -> Path:
+    """Require a regular owner-only JSON path before reading or replacing it."""
+
+    return require_private_file(path)
+
+
+__all__ = ["create_private_json", "replace_private_json", "require_private_json"]

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/contracts/plan_manifest_schemas.py

@@ -50,7 +50,10 @@ PLAN_MANIFEST_SCHEMAS: dict[str, dict[str, Any]] = {
             "readOnly": _STRING_LIST,
             "forbiddenWrites": _STRING_LIST,
             "leadOwned": {"type": "array", "items": {"type": "object"}},
-            "workstreams": {"type": "array", "items": {"type": "object"}},
+            "workstreams": {
+                "type": "array",
+                "items": {"type": "object", "properties": {"artifactPaths": {"$ref": "#/$defs/artifactPaths"}}},
+            },
             "acceptance": _OBJECT,
             "acceptanceCriteria": {"type": "array", "items": {"type": "object"}},
             "validation": _OBJECT,
@@ -95,6 +98,12 @@ PLAN_MANIFEST_SCHEMAS: dict[str, dict[str, Any]] = {
 }
 
 PLAN_MANIFEST_SCHEMAS[MANIFEST_SCHEMA]["$defs"] = {
+    "artifactPaths": _closed_object_schema(
+        "agent-plan-artifact-paths.v1",
+        required=["result", "review"],
+        include_schema_version=False,
+        properties={"result": {"type": "string", "minLength": 1}, "review": {"type": "string", "minLength": 1}},
+    ),
     "package": _closed_object_schema(
         "agent-plan-package.v1",
         required=["id"],
@@ -151,6 +160,28 @@ PLAN_MANIFEST_SCHEMAS[MANIFEST_SCHEMA]["$defs"] = {
         "type": "object",
         "additionalProperties": True,
         "properties": {
+            "prerequisiteAcceptance": {
+                "type": "object",
+                "additionalProperties": False,
+                "required": ["required", "dependencies"],
+                "properties": {
+                    "required": {"type": "boolean"},
+                    "dependencies": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "additionalProperties": False,
+                            "required": ["packageId", "sourceRevision", "evidencePath", "sha256"],
+                            "properties": {
+                                "packageId": {"type": "string", "minLength": 1},
+                                "sourceRevision": {"type": "string", "minLength": 1},
+                                "evidencePath": {"type": "string", "minLength": 1},
+                                "sha256": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+                            },
+                        },
+                    },
+                },
+            },
             "securityAnalysis": {
                 "type": "object",
                 "required": ["profileId", "activation", "implementationAudit"],
@@ -161,7 +192,7 @@ PLAN_MANIFEST_SCHEMAS[MANIFEST_SCHEMA]["$defs"] = {
                     "implementationAudit": {"type": "object"},
                     "verificationEvidence": {"type": "object"},
                 },
-            }
+            },
         },
     },
 }

agent_lifecycle_kit-2.17.0/src/agent_lifecycle/contracts/process_lock.py

@@ -0,0 +1,124 @@
+"""Bounded OS locks for cooperating processes on one local file."""
+
+from __future__ import annotations
+
+import errno
+import math
+import os
+import stat
+import threading
+import time
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Protocol, cast
+
+from agent_lifecycle.contracts.authority_io import authority_location, ensure_authority_directory
+from agent_lifecycle.contracts.errors import LifecycleError
+
+_FD_GUARD = threading.Lock()
+_LOCK_FDS: set[int] = set()
+DEFAULT_LOCK_TIMEOUT_SECONDS = 30.0
+
+
+class _WindowsLock(Protocol):
+    LK_NBLCK: int
+
+    def locking(self, fd: int, mode: int, nbytes: int) -> None: ...
+
+
+def _after_fork_child() -> None:
+    for fd in _LOCK_FDS:
+        os.close(fd)
+    _LOCK_FDS.clear()
+    _FD_GUARD.release()
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(
+        before=_FD_GUARD.acquire,
+        after_in_parent=_FD_GUARD.release,
+        after_in_child=_after_fork_child,
+    )
+
+
+def _identity(path: Path, fd: int) -> tuple[int, int]:
+    actual = os.fstat(fd)
+    named = path.lstat()
+    if (
+        not stat.S_ISREG(named.st_mode)
+        or not stat.S_ISREG(actual.st_mode)
+        or actual.st_nlink != 1
+        or (actual.st_dev, actual.st_ino) != (named.st_dev, named.st_ino)
+        or (os.name != "nt" and stat.S_IMODE(actual.st_mode) != 0o600)
+    ):
+        raise LifecycleError("process-lock-unsafe", "process lock must remain a private regular file")
+    return actual.st_dev, actual.st_ino
+
+
+def _try_lock(fd: int) -> bool:
+    try:
+        if os.name == "posix":
+            import fcntl
+
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        elif os.name == "nt":
+            import msvcrt
+
+            windows = cast("_WindowsLock", msvcrt)
+            os.lseek(fd, 0, os.SEEK_SET)
+            windows.locking(fd, windows.LK_NBLCK, 1)
+        else:
+            raise LifecycleError("process-lock-unsupported", "local process locking is unsupported")
+        return True
+    except OSError as error:
+        if error.errno in {errno.EACCES, errno.EAGAIN}:
+            return False
+        raise
+
+
+@contextmanager
+def exclusive_process_lock(
+    path: Path,
+    *,
+    timeout_seconds: float = DEFAULT_LOCK_TIMEOUT_SECONDS,
+) -> Iterator[None]:
+    """Hold a stable lock through the caller's operation; never remove its file.
+
+    Closing the OS handle releases a crashed process's lock. File age, PID text
+    and elapsed time never authorize stealing a live lock.
+    """
+    if (
+        not isinstance(timeout_seconds, (int, float))
+        or isinstance(timeout_seconds, bool)
+        or not math.isfinite(timeout_seconds)
+        or timeout_seconds < 0
+    ):
+        raise LifecycleError("process-lock-timeout-invalid", "lock timeout must be nonnegative")
+    root, relative = authority_location(path)
+    path = root / relative
+    ensure_authority_directory(path.parent)
+    owner_pid = os.getpid()
+    fd = -1
+    try:
+        with _FD_GUARD:
+            fd = os.open(path, os.O_RDWR | os.O_CREAT | getattr(os, "O_NOFOLLOW", 0), 0o600)
+            _LOCK_FDS.add(fd)
+        identity = _identity(path, fd)
+        deadline = time.monotonic() + timeout_seconds
+        while not _try_lock(fd):
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise LifecycleError("process-lock-timeout", "another process holds the operation lock")
+            time.sleep(min(0.01, remaining))
+        if _identity(path, fd) != identity:
+            raise LifecycleError("process-lock-unsafe", "process lock identity changed")
+    except OSError as error:
+        raise LifecycleError("process-lock-unavailable", "local process lock is unavailable") from error
+    else:
+        yield
+    finally:
+        if fd >= 0 and owner_pid == os.getpid():
+            with _FD_GUARD:
+                _LOCK_FDS.discard(fd)
+                os.close(fd)

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/planning/completeness.py

@@ -138,12 +138,11 @@ def validate_plan_completeness(
     required_checks = _required_checks(active_profile, tier)
     for check in required_checks:
         _CHECKS[check](manifest, tier, blockers)
-    if tier == "S2" and _canonical_authority_enabled(manifest):
-        # Plans carrying packageIntegrity use the closed graph and path rules.
-        # Older frozen plans remain readable under their historical profile.
+    if tier == "S2":
+        _check_s2_integrity(manifest, blockers)
         _check_traceability(manifest, tier, blockers)
         _check_path_authority(manifest, tier, blockers)
-        required_checks = [*required_checks, "traceability", "path-authority"]
+        required_checks = [*required_checks, "package-integrity", "traceability", "path-authority"]
     if operation_root is not None:
         required_checks = [*required_checks, "filesystem-path-authority"]
         try:
@@ -176,12 +175,13 @@ def require_plan_completeness_pass(validation: dict[str, Any]) -> dict[str, Any]
     return validation
 
 
-def _tier(manifest: dict[str, Any]) -> str:
+def _tier(manifest: dict[str, Any]) -> str | None:
     specification = manifest.get("specification")
-    if isinstance(specification, dict) and isinstance(specification.get("tier"), str):
-        return specification["tier"]
+    if isinstance(specification, dict) and "tier" in specification:
+        value = specification["tier"]
+        return value if isinstance(value, str) else None
     raw = manifest.get("tier")
-    return raw if isinstance(raw, str) else "S1"
+    return raw if isinstance(raw, str) else None
 
 
 def _package_id(manifest: dict[str, Any]) -> str | None:
@@ -193,7 +193,22 @@ def _required_checks(profile: dict[str, Any], tier: str) -> list[str]:
     profiles = profile.get("profiles") if isinstance(profile.get("profiles"), dict) else {}
     tier_profile = profiles.get(tier) if isinstance(profiles, dict) else None
     required = tier_profile.get("requiredChecks") if isinstance(tier_profile, dict) else []
-    return _strings(required)
+    baseline = DEFAULT_PROFILE["profiles"][tier]["requiredChecks"]
+    return list(dict.fromkeys([*baseline, *_strings(required)]))
+
+
+def _check_s2_integrity(manifest: dict[str, Any], blockers: list[dict[str, Any]]) -> None:
+    integrity = manifest.get("packageIntegrity")
+    if not isinstance(integrity, dict) or integrity.get("required") is not True:
+        blockers.append(_blocker("missing-package-integrity", "S2 requires packageIntegrity.required=true"))
+        return
+    if integrity.get("lockSchemaVersion") != "agent-plan-lock.v2":
+        blockers.append(_blocker("s2-lock-schema-invalid", "S2 requires a v2 inventory lock"))
+    paths = manifest.get("planFiles")
+    if not isinstance(paths, list) or not paths or any(not isinstance(p, str) or not p for p in paths):
+        blockers.append(_blocker("plan-files-missing", "S2 requires a nonempty planFiles inventory"))
+    elif paths != sorted(set(paths)):
+        blockers.append(_blocker("plan-files-unsorted", "planFiles must be unique and sorted lexicographically"))
 
 
 def _check_single_workstream(manifest: dict[str, Any], tier: str, blockers: list[dict[str, Any]]) -> None:
@@ -313,10 +328,6 @@ def _check_write_ownership(manifest: dict[str, Any], tier: str, blockers: list[d
             )
 
 
-def _canonical_authority_enabled(manifest: dict[str, Any]) -> bool:
-    return isinstance(manifest.get("packageIntegrity"), dict)
-
-
 def _validation_ladder_enabled(manifest: dict[str, Any]) -> bool:
     validation = manifest.get("validation")
     return isinstance(validation, dict) and ("checkCatalog" in validation or "validationLadderProfile" in validation)

{agent_lifecycle_kit-2.16.0 → agent_lifecycle_kit-2.17.0}/src/agent_lifecycle/planning/manifest_contract.py

@@ -8,13 +8,17 @@ from agent_lifecycle.contracts import LifecycleError, canonical_digest
 from agent_lifecycle.contracts.authority_text import require_manifest_text
 from agent_lifecycle.contracts.immutable_input_schemas import validate_a5_plan_policy, validate_a5_policy
 from agent_lifecycle.contracts.ownership_paths import (
+    authority_paths_overlap,
+    normalize_authority_path,
     require_declared_output_footprint,
     require_manifest_authority_paths,
+    require_output_footprint,
 )
 from agent_lifecycle.contracts.plan_manifest_schemas import (
     MANIFEST_SCHEMA,
     MANIFEST_VALIDATION_SCHEMA,
 )
+from agent_lifecycle.planning.prerequisites import prerequisite_dependencies
 
 _TOP_LEVEL = {
     "schemaVersion",
@@ -191,6 +195,10 @@ def validate_plan_manifest_contract(manifest: dict[str, Any]) -> dict[str, Any]:
         return _result(manifest, blockers)
     require_manifest_text(manifest)
     require_manifest_authority_paths(manifest)
+    try:
+        prerequisite_dependencies(manifest)
+    except LifecycleError as exc:
+        blockers.append(_blocker(exc.code, exc.message))
     try:
         require_declared_output_footprint(manifest)
     except LifecycleError as exc:
@@ -211,6 +219,7 @@ def validate_plan_manifest_contract(manifest: dict[str, Any]) -> dict[str, Any]:
         if not isinstance(package.get("id"), str) or not package["id"].strip():
             blockers.append(_blocker("plan-manifest-package-id-missing", "package.id is required"))
     _validate_nested(manifest, blockers)
+    blockers.extend(_artifact_path_blockers(manifest))
     _validate_immutable_input_policy(manifest, blockers)
     _validate_extensions(manifest.get("extensions"), blockers)
     return _result(manifest, blockers)
@@ -229,6 +238,62 @@ def require_plan_manifest_contract(manifest: dict[str, Any]) -> dict[str, Any]:
     return result
 
 
+def require_plan_artifact_paths(manifest: dict[str, Any]) -> None:
+    """Apply the same closed artifact roles to legacy executable envelopes."""
+    blockers = _artifact_path_blockers(manifest)
+    if blockers:
+        raise LifecycleError("plan-artifact-paths-invalid", "plan artifact paths are invalid", {"blockers": blockers})
+
+
+def _artifact_path_blockers(manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    blockers: list[dict[str, Any]] = []
+    outputs: list[str] = []
+    seen: set[str] = set()
+    protected = [
+        p
+        for key in ("readOnly", "forbiddenWrites")
+        for values in [manifest.get(key, [])]
+        if isinstance(values, list)
+        for p in values
+        if isinstance(p, str)
+    ]
+    workstreams = manifest.get("workstreams", [])
+    if not isinstance(workstreams, list):
+        return blockers
+    for task in workstreams:
+        if not isinstance(task, dict) or "artifactPaths" not in task:
+            continue
+        roles = task["artifactPaths"]
+        if not isinstance(roles, dict) or set(roles) != {"result", "review"}:
+            blockers.append(
+                _blocker("plan-artifact-roles-invalid", "artifactPaths must contain result and review only")
+            )
+            continue
+        for raw in roles.values():
+            try:
+                if (
+                    not isinstance(raw, str)
+                    or "{" in raw.replace("{attempt}", "")
+                    or "}" in raw.replace("{attempt}", "")
+                ):
+                    raise LifecycleError("plan-artifact-path-invalid", "artifact path or attempt template is invalid")
+                path = normalize_authority_path(raw, label="artifact path")
+                key = path.casefold()
+                if key in seen:
+                    raise LifecycleError("plan-artifact-path-duplicate", "artifact paths must be distinct")
+                if any(authority_paths_overlap(key, normalize_authority_path(p).casefold()) for p in protected):
+                    raise LifecycleError("plan-output-conflict", "artifact path overlaps protected authority")
+                seen.add(key)
+                outputs.append(path)
+            except LifecycleError as exc:
+                blockers.append(_blocker(exc.code, exc.message))
+    try:
+        require_output_footprint(manifest, outputs)
+    except LifecycleError as exc:
+        blockers.append(_blocker(exc.code, exc.message))
+    return blockers
+
+
 def _validate_nested(manifest: dict[str, Any], blockers: list[dict[str, Any]]) -> None:
     _object_keys(manifest.get("author"), _AUTHOR, "author", blockers)
     _object_keys(manifest.get("baseRevision"), _BASE_REVISION, "baseRevision", blockers)