agent-lifecycle-kit 1.78.0__tar.gz → 1.80.0__tar.gz

{agent_lifecycle_kit-1.78.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-1.80.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 1.78.0
+Version: 1.80.0
 Summary: Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion.
 Author: Agent Lifecycle Kit contributors
 License: Apache-2.0
@@ -43,7 +43,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.78.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.80.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -81,11 +81,11 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
 - Usage visibility: tokens, time, resource counters and structured execution records without sensitive data are native; monetary cost is optional and only used when a metered host reports it.
 - Project-specific workflow settings: ALK can discover and validate uncommitted local defaults, or apply a built-in workflow preset for a common route, while the frozen plan remains authoritative.
 - Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources, an explicit documented Python API, and bounded performance controls that preserve security and evidence rules.
+- Optional adapter lifecycle control: operation-level `GUIDANCE_ONLY`, `OBSERVED` and `ENFORCED` declarations remain separate from general adapter support; bundled adapters currently publish `GUIDANCE_ONLY` with `NO_RECOMMENDATION`, and managed launch remains `WRAPPER_ONLY`. See [optional adapter lifecycle control](docs/adapters/lifecycle-control.md).
 - Project principles and plan deltas keep long-running work understandable: principles provide bounded defaults, while a digest-bound delta shows which plan authority changed and whether review and a new lock are required. CI also checks an acyclic module/package graph, layer direction and source-size limits; adapter inspection uses bounded literal profiles and fails closed without executing adapter code.
-- Read-only progress and managed sessions: host UIs can show lifecycle state,
-  attested tokens and Git-style change counters; `start` accepts task text,
-  Markdown, frozen run requests or stored ALK sessions while preserving
-  review/freeze boundaries.
+- Read-only progress and managed sessions preserve review/freeze boundaries;
+  host UIs show lifecycle state and counters, `start` accepts task text,
+  Markdown, frozen requests or stored sessions, and `plan verify` only checks plan data.
 
 ## Feature areas
 ### Plan and execute
@@ -194,7 +194,7 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 
 - Start: [English documentation](docs/README.md), [Русская документация](docs/ru/README.md), [Install](docs/guides/install-and-first-run.md), [Quickstart](docs/guides/quickstart.md), [Beginner and advanced workflows](docs/guides/beginner-and-advanced-workflows.md), [Commands by task](docs/guides/commands-by-task.md), [Research workflow](docs/guides/research-workflow.md), [Lifecycle task scenarios](docs/guides/lifecycle-cookbook.md), and [Code review workflows](docs/guides/code-review-workflows.md).
 - Planning and adapters: [Issue to specification drafts](docs/guides/issue-to-spec.md), [Adapter install](docs/adapters/install.md), and [Adapter support matrix](docs/adapters/support-matrix.md).
-- Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [Research evidence](docs/reference/research-evidence.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
+- Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [Plan verification](docs/reference/plan-verification.md), [Research evidence](docs/reference/research-evidence.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
 - Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [performance and resource budgets](docs/reference/performance-and-resource-budgets.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
 - Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner recovery](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).

{agent_lifecycle_kit-1.78.0 → agent_lifecycle_kit-1.80.0}/README.md

@@ -21,7 +21,7 @@ ALK provides a verifiable finish for external-agent work with proportionate cont
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.78.0`, and common `agent-lifecycle version` errors.
+It includes macOS, Linux and Windows instructions, Python 3.11-3.14, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==1.80.0`, and common `agent-lifecycle version` errors.
 
 For a quick start, run:
 
@@ -59,11 +59,11 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
 - Usage visibility: tokens, time, resource counters and structured execution records without sensitive data are native; monetary cost is optional and only used when a metered host reports it.
 - Project-specific workflow settings: ALK can discover and validate uncommitted local defaults, or apply a built-in workflow preset for a common route, while the frozen plan remains authoritative.
 - Reproducible Python maintenance: pinned development-only Ruff, mypy and coverage checks, a non-growing quality ratchet, stable redacted CLI errors, installed package resources, an explicit documented Python API, and bounded performance controls that preserve security and evidence rules.
+- Optional adapter lifecycle control: operation-level `GUIDANCE_ONLY`, `OBSERVED` and `ENFORCED` declarations remain separate from general adapter support; bundled adapters currently publish `GUIDANCE_ONLY` with `NO_RECOMMENDATION`, and managed launch remains `WRAPPER_ONLY`. See [optional adapter lifecycle control](docs/adapters/lifecycle-control.md).
 - Project principles and plan deltas keep long-running work understandable: principles provide bounded defaults, while a digest-bound delta shows which plan authority changed and whether review and a new lock are required. CI also checks an acyclic module/package graph, layer direction and source-size limits; adapter inspection uses bounded literal profiles and fails closed without executing adapter code.
-- Read-only progress and managed sessions: host UIs can show lifecycle state,
-  attested tokens and Git-style change counters; `start` accepts task text,
-  Markdown, frozen run requests or stored ALK sessions while preserving
-  review/freeze boundaries.
+- Read-only progress and managed sessions preserve review/freeze boundaries;
+  host UIs show lifecycle state and counters, `start` accepts task text,
+  Markdown, frozen requests or stored sessions, and `plan verify` only checks plan data.
 
 ## Feature areas
 ### Plan and execute
@@ -172,7 +172,7 @@ Adapter installation and support-level details live in [Adapter install](docs/ad
 
 - Start: [English documentation](docs/README.md), [Русская документация](docs/ru/README.md), [Install](docs/guides/install-and-first-run.md), [Quickstart](docs/guides/quickstart.md), [Beginner and advanced workflows](docs/guides/beginner-and-advanced-workflows.md), [Commands by task](docs/guides/commands-by-task.md), [Research workflow](docs/guides/research-workflow.md), [Lifecycle task scenarios](docs/guides/lifecycle-cookbook.md), and [Code review workflows](docs/guides/code-review-workflows.md).
 - Planning and adapters: [Issue to specification drafts](docs/guides/issue-to-spec.md), [Adapter install](docs/adapters/install.md), and [Adapter support matrix](docs/adapters/support-matrix.md).
-- Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [Research evidence](docs/reference/research-evidence.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
+- Reference: [System architecture](docs/architecture/system-architecture.md), [workflow customization and execution controls](docs/reference/workflow-customization.md), [execution strategy](docs/reference/execution-strategy.md), [CLI reference](docs/reference/cli.md), [Plan verification](docs/reference/plan-verification.md), [Research evidence](docs/reference/research-evidence.md), [Source of truth](docs/reference/source-of-truth.md), [Managed lifecycle runner](docs/reference/managed-lifecycle-runner.md), [Managed adapter sessions](docs/reference/managed-adapter-sessions.md), [Portable Agent Plugins](docs/reference/agent-plugins.md), [Plugin publication](docs/reference/plugin-publication.md), [Implementation audit](docs/reference/implementation-audit.md), [Plan completeness](docs/reference/plan-completeness.md), [Public contracts](docs/reference/public-contracts.md), and [Readiness diagnostics](docs/reference/readiness-diagnostics.md).
 - Quality and resources: [Reference-task evaluation](docs/reference/reference-task-evaluation.md), [model routing](docs/reference/model-routing.md), [quality-cost learning](docs/reference/quality-cost-learning.md), [performance and resource budgets](docs/reference/performance-and-resource-budgets.md), [lifecycle cost accounting](docs/reference/lifecycle-cost.md), [host-local token accounting](docs/reference/host-local-token-accounting.md), [process execution observability](docs/reference/process-execution-observability.md), [Usage export](docs/reference/usage-export.md), and [Evidence integrity](docs/reference/evidence-integrity.md).
 - Profiles and operations: [Project workflow presets](docs/reference/workflow-presets.md), [Project workflow profile](docs/reference/project-workflow-profile.md), [Read-only status views](docs/reference/read-only-status-view.md), [Adapter progress bridge](docs/reference/automatic-progress-bridge.md), [Sandbox boundaries](docs/reference/sandbox-boundaries.md), [Import mappers](docs/reference/import-mappers.md), [Episode retrieval](docs/reference/episode-retrieval.md), [Runner recovery](docs/reference/runner-recovery.md), [Cross-check profile](docs/reference/cross-check-profile.md), [Review Mesh](docs/reference/review-mesh.md), [Bug Forensics profile](docs/reference/bug-forensics.md), and [Bug Forensics context budget](docs/reference/bug-forensics-context-budget.md).
 - Release assets: [Task templates](templates/tasks/README.md), [Neutrality scanning](docs/reference/neutrality.md), and [Release security](docs/security/release-security.md).

{agent_lifecycle_kit-1.78.0 → agent_lifecycle_kit-1.80.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "1.78.0"
+version = "1.80.0"
 description = "Provider-neutral lifecycle control layer that helps coding agents plan, execute, validate, and prove software tasks to completion."
 readme = "README.md"
 requires-python = ">=3.11,<3.15"

{agent_lifecycle_kit-1.78.0 → agent_lifecycle_kit-1.80.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "1.78.0"
+__version__ = "1.80.0"

agent_lifecycle_kit-1.80.0/src/agent_lifecycle/adapter_sessions/lifecycle_control.py

@@ -0,0 +1,158 @@
+"""Adapter-session bridge for host-owned lifecycle-control gates."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, read_json_object
+from agent_lifecycle.freeze import plan_integrity_required, verify_plan_package_integrity
+from agent_lifecycle.host_protocol.lifecycle_control import load_lifecycle_control_policy
+from agent_lifecycle.host_protocol.lifecycle_gate import (
+    evaluate_post_action_gate,
+    evaluate_pre_action_gate,
+    evaluate_stop_gate,
+    lifecycle_control_selection,
+    require_lifecycle_gate_pass,
+)
+
+
+def pre_action_gate(
+    *,
+    manifest_path: Path,
+    lock_path: Path,
+    state_path: Path,
+    operation: str,
+    action_digest: str,
+    paths: list[str],
+    requested_level: str | None = None,
+    policy_path: Path | None = None,
+    next_action: dict[str, Any] | None = None,
+    task_id: str | None = None,
+    expected_state_revision: int | None = None,
+    repository_root: Path | None = None,
+) -> dict[str, Any]:
+    """Return a pre-action decision for a host adapter without launching it."""
+
+    manifest = read_json_object(manifest_path, label="frozen plan manifest")
+    lock = read_json_object(lock_path, label="plan lock")
+    state = read_json_object(state_path, label="workflow state")
+    selected_level, selected_policy, _ = lifecycle_control_selection(state)
+    policy = selected_policy or (load_lifecycle_control_policy(policy_path) if policy_path else None)
+    package_integrity: dict[str, Any] | None = None
+    if plan_integrity_required(manifest):
+        if repository_root is None:
+            package_integrity = {
+                "status": "FAIL",
+                "blockers": [{"code": "repository-root-required"}],
+            }
+        else:
+            try:
+                package_integrity = verify_plan_package_integrity(
+                    manifest,
+                    lock,
+                    repository_root=repository_root,
+                )
+            except LifecycleError as exc:
+                package_integrity = {
+                    "status": "FAIL",
+                    "blockers": [{"code": exc.code, "message": exc.message}],
+                }
+    return evaluate_pre_action_gate(
+        manifest=manifest,
+        lock=lock,
+        state=state,
+        operation=operation,
+        action_digest=action_digest,
+        paths=paths,
+        requested_level=requested_level or selected_level,
+        policy=policy,
+        next_action=next_action,
+        task_id=task_id,
+        expected_state_revision=(
+            expected_state_revision if expected_state_revision is not None else 0
+        ),
+        package_integrity=package_integrity,
+    )
+
+
+def require_pre_action(**kwargs: Any) -> dict[str, Any]:
+    """Raise before the host action when the selected gate blocks it."""
+
+    gate = pre_action_gate(**kwargs)
+    return require_lifecycle_gate_pass(gate, gate_type="pre-action")
+
+
+def post_action_gate(
+    *,
+    pre_action: dict[str, Any],
+    manifest_path: Path,
+    actual_changed_paths: list[str],
+    outcome: dict[str, Any] | None = None,
+    actual_status: str = "PASS",
+    event: dict[str, Any] | None = None,
+    policy_path: Path | None = None,
+) -> dict[str, Any]:
+    """Validate host output and changed paths after an authorized action."""
+
+    manifest = read_json_object(manifest_path, label="frozen plan manifest")
+    policy = load_lifecycle_control_policy(policy_path) if policy_path else None
+    return evaluate_post_action_gate(
+        pre_action=pre_action,
+        manifest=manifest,
+        actual_changed_paths=actual_changed_paths,
+        outcome=outcome,
+        actual_status=actual_status,
+        event=event,
+        policy=policy,
+    )
+
+
+def require_post_action(**kwargs: Any) -> dict[str, Any]:
+    """Raise when selected post-action evidence does not match the action."""
+
+    gate = post_action_gate(**kwargs)
+    return require_lifecycle_gate_pass(gate, gate_type="post-action")
+
+
+def stop_gate(
+    *,
+    state_path: Path,
+    final_audit: dict[str, Any] | None = None,
+    final_proof: dict[str, Any] | None = None,
+    pre_action: dict[str, Any] | None = None,
+    post_action: dict[str, Any] | None = None,
+    requested_level: str | None = None,
+    policy_path: Path | None = None,
+) -> dict[str, Any]:
+    """Evaluate the stop boundary from a durable workflow state snapshot."""
+
+    state = read_json_object(state_path, label="workflow state")
+    selected_level, selected_policy, _ = lifecycle_control_selection(state)
+    policy = selected_policy or (load_lifecycle_control_policy(policy_path) if policy_path else None)
+    return evaluate_stop_gate(
+        state=state,
+        final_audit=final_audit,
+        final_proof=final_proof,
+        pre_action=pre_action,
+        post_action=post_action,
+        requested_level=requested_level or selected_level,
+        policy=policy,
+    )
+
+
+def require_stop(**kwargs: Any) -> dict[str, Any]:
+    """Raise when selected stop evidence is incomplete or inconsistent."""
+
+    gate = stop_gate(**kwargs)
+    return require_lifecycle_gate_pass(gate, gate_type="stop")
+
+
+__all__ = [
+    "post_action_gate",
+    "pre_action_gate",
+    "require_post_action",
+    "require_pre_action",
+    "require_stop",
+    "stop_gate",
+]

{agent_lifecycle_kit-1.78.0 → agent_lifecycle_kit-1.80.0}/src/agent_lifecycle/adapter_sessions/process_groups.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import signal
 import subprocess
+import time
 from contextlib import suppress
 from pathlib import Path
 from typing import Any
@@ -37,16 +38,19 @@ class ProcessGroupOwner:
         """Terminate the owned group and return bounded cleanup evidence."""
 
         escalation = "none"
-        if self.process.poll() is None:
-            if os.name == "posix":
+        if os.name == "posix":
+            if self.process.poll() is None:
                 with suppress(ProcessLookupError):
                     os.killpg(self.pid, signal.SIGTERM)
-                if not _wait_process(self.process, grace_seconds):
-                    escalation = "SIGKILL"
-                    with suppress(ProcessLookupError):
-                        os.killpg(self.pid, signal.SIGKILL)
-                    _wait_process(self.process, grace_seconds)
-            elif self._job_handle is not None:
+            _wait_process(self.process, grace_seconds)
+            if not _wait_process_group_exit(self.pid, grace_seconds):
+                escalation = "SIGKILL"
+                with suppress(ProcessLookupError):
+                    os.killpg(self.pid, signal.SIGKILL)
+                _wait_process(self.process, grace_seconds)
+                _wait_process_group_exit(self.pid, grace_seconds)
+        elif self.process.poll() is None:
+            if self._job_handle is not None:
                 _terminate_windows_job(self._job_handle)
                 _wait_process(self.process, grace_seconds)
                 escalation = "job-terminate"
@@ -121,6 +125,20 @@ def _wait_process(process: subprocess.Popen[Any], timeout: float) -> bool:
         return False
 
 
+def _wait_process_group_exit(group_id: int, timeout: float) -> bool:
+    """Wait for every observable member of a POSIX process group to exit."""
+
+    deadline = time.monotonic() + max(0.01, timeout)
+    while True:
+        alive = _posix_group_has_live_processes(group_id)
+        if alive is False:
+            return True
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return False
+        time.sleep(min(0.02, remaining))
+
+
 def _create_windows_job(process: subprocess.Popen[Any]) -> int | None:
     if os.name != "nt":
         return None

{agent_lifecycle_kit-1.78.0 → agent_lifecycle_kit-1.80.0}/src/agent_lifecycle/audit/ownership.py

@@ -7,7 +7,8 @@ from pathlib import Path
 from typing import Any
 
 from agent_lifecycle.contracts import read_json_object
-from agent_lifecycle.contracts.paths import is_under_repo_path, normalize_repo_path
+from agent_lifecycle.contracts.ownership_paths import is_under_authority_path, normalize_authority_path
+from agent_lifecycle.contracts.paths import normalize_repo_path
 
 
 def build_ownership_report(
@@ -17,6 +18,18 @@ def build_ownership_report(
     base: str | None = None,
 ) -> dict[str, Any]:
     manifest = read_json_object(manifest_path, label="plan manifest")
+    return build_ownership_report_from_manifest(manifest, paths, manifest_path=manifest_path, base=base)
+
+
+def build_ownership_report_from_manifest(
+    manifest: dict[str, Any],
+    paths: list[str],
+    *,
+    manifest_path: Path | None = None,
+    base: str | None = None,
+) -> dict[str, Any]:
+    """Classify changed paths against an already loaded frozen manifest."""
+
     classifiers = _classifiers(manifest, manifest_path)
     entries = [_classify_path(path, classifiers) for path in sorted(set(paths))]
     categories = Counter(entry["category"] for entry in entries)
@@ -40,34 +53,70 @@ def report_has_category(report: dict[str, Any], categories: set[str]) -> bool:
     return any(entry.get("category") in categories for entry in report.get("entries", []))
 
 
-def _classifiers(manifest: dict[str, Any], manifest_path: Path) -> dict[str, Any]:
-    package = manifest.get("package", {})
+def _classifiers(manifest: dict[str, Any], manifest_path: Path | None) -> dict[str, Any]:
+    package_value = manifest.get("package")
+    package = package_value if isinstance(package_value, dict) else {}
     plan_root = package.get("planArtifactRoot")
+    workstreams = _list_value(manifest.get("workstreams"))
+    manifest_lead_owned = _list_value(manifest.get("leadOwned"))
+    manifest_read_only = _list_value(manifest.get("readOnly"))
+    manifest_forbidden = _list_value(manifest.get("forbiddenWrites"))
+    workstream_paths = {
+        "readOnly": [
+            path
+            for workstream in workstreams
+            if isinstance(workstream, dict)
+            for path in _list_value(workstream.get("readOnly"))
+            if isinstance(path, str)
+        ],
+        "forbiddenWrites": [
+            path
+            for workstream in workstreams
+            if isinstance(workstream, dict)
+            for path in _list_value(workstream.get("forbiddenWrites"))
+            if isinstance(path, str)
+        ],
+        "leadOwned": [
+            item["path"]
+            for workstream in workstreams
+            if isinstance(workstream, dict)
+            for item in _list_value(workstream.get("leadOwned"))
+            if isinstance(item, dict) and isinstance(item.get("path"), str)
+        ],
+    }
     return {
         "manifestPath": _repo_relative(manifest_path),
-        "planArtifactRoot": normalize_repo_path(plan_root) if isinstance(plan_root, str) else None,
+        "planArtifactRoot": normalize_authority_path(plan_root, label="planArtifactRoot")
+        if isinstance(plan_root, str)
+        else None,
         "leadOwned": [
-            normalize_repo_path(item["path"])
-            for item in manifest.get("leadOwned", [])
+            normalize_authority_path(item["path"], label="leadOwned path")
+            for item in manifest_lead_owned
             if isinstance(item, dict) and isinstance(item.get("path"), str)
-        ],
+        ]
+        + [normalize_authority_path(path, label="workstream leadOwned path") for path in workstream_paths["leadOwned"]],
         "readOnly": [
-            normalize_repo_path(path)
-            for path in manifest.get("readOnly", [])
+            normalize_authority_path(path, label="readOnly path")
+            for path in manifest_read_only
             if isinstance(path, str)
-        ],
+        ]
+        + [normalize_authority_path(path, label="workstream readOnly path") for path in workstream_paths["readOnly"]],
         "forbiddenWrites": [
-            normalize_repo_path(path)
-            for path in manifest.get("forbiddenWrites", [])
+            normalize_authority_path(path, label="forbiddenWrites path")
+            for path in manifest_forbidden
             if isinstance(path, str)
+        ]
+        + [
+            normalize_authority_path(path, label="workstream forbiddenWrites path")
+            for path in workstream_paths["forbiddenWrites"]
         ],
         "workstreams": {
             workstream["id"]: [
-                normalize_repo_path(path)
-                for path in workstream.get("writes", [])
+                normalize_authority_path(path, label="workstream write path")
+                for path in _list_value(workstream.get("writes"))
                 if isinstance(path, str)
             ]
-            for workstream in manifest.get("workstreams", [])
+            for workstream in workstreams
             if isinstance(workstream, dict) and isinstance(workstream.get("id"), str)
         },
     }
@@ -79,21 +128,21 @@ def _classify_path(path: str, classifiers: dict[str, Any]) -> dict[str, Any]:
     if isinstance(manifest_path, str) and normalized == manifest_path:
         return _entry(normalized, "plan-authority", ["controller"])
     plan_root = classifiers["planArtifactRoot"]
-    if isinstance(plan_root, str) and is_under_repo_path(normalized, plan_root):
+    if isinstance(plan_root, str) and is_under_authority_path(normalized, plan_root):
         return _entry(normalized, "plan-authority", ["controller"])
-    lead = [root for root in classifiers["leadOwned"] if is_under_repo_path(normalized, root)]
+    lead = [root for root in classifiers["leadOwned"] if is_under_authority_path(normalized, root)]
     if lead:
         return _entry(normalized, "lead-owned", ["controller"], matched=lead)
-    forbidden = [root for root in classifiers["forbiddenWrites"] if is_under_repo_path(normalized, root)]
+    forbidden = [root for root in classifiers["forbiddenWrites"] if is_under_authority_path(normalized, root)]
     if forbidden:
         return _entry(normalized, "forbidden", [], matched=forbidden)
-    read_only = [root for root in classifiers["readOnly"] if is_under_repo_path(normalized, root)]
+    read_only = [root for root in classifiers["readOnly"] if is_under_authority_path(normalized, root)]
     if read_only:
         return _entry(normalized, "read-only", [], matched=read_only)
     owners = [
         owner
         for owner, roots in classifiers["workstreams"].items()
-        if any(is_under_repo_path(normalized, root) for root in roots)
+        if any(is_under_authority_path(normalized, root) for root in roots)
     ]
     if owners:
         return _entry(normalized, "workstream-owned", owners)
@@ -112,8 +161,15 @@ def _entry(
         value["matched"] = matched
     return value
 
-def _repo_relative(path: Path) -> str | None:
+
+def _repo_relative(path: Path | None) -> str | None:
+    if path is None:
+        return None
     try:
         return normalize_repo_path(str(path.resolve().relative_to(Path.cwd().resolve())))
     except ValueError:
         return None
+
+
+def _list_value(value: Any) -> list[Any]:
+    return value if isinstance(value, list) else []