agent-lifecycle-kit 2.13.0__tar.gz → 2.15.0__tar.gz

{agent_lifecycle_kit-2.13.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 2.13.0
+Version: 2.15.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==2.13.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==2.15.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:
 
@@ -69,7 +69,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
 - The [system architecture](docs/architecture/system-architecture.md) page explains how the project is organized, and [project comparison](docs/reference/project-comparison.md) shows how it differs from similar tools.
 - Multiple-agent boundaries, workflow configuration, model choice, prompts, timeouts and retries are described in [workflow customization and execution controls](docs/reference/workflow-customization.md).
 - Create a local project profile with `agent-lifecycle project profile init`; see [project workflow profile](docs/reference/project-workflow-profile.md). Explain the selected profile, plan constraints and adapter capability lineage with [effective configuration](docs/reference/effective-configuration.md), [structured result qualification](docs/reference/structured-result-qualification.md) and [adapter action evidence](docs/reference/adapter-action-evidence.md). Add optional project-owned architecture and dependency evidence with [external verification checks](docs/reference/external-verification-checks.md), run longer specialized adapter work through [bounded external tool jobs](docs/reference/external-tool-jobs.md), track bounded terminology with [project domain language](docs/reference/project-domain-language.md), coordinate several runs with the read-only [multi-run attention view](docs/reference/multi-run-attention-view.md), or use the optional [security analysis profile](docs/reference/security-analysis-profile.md) for untrusted findings and independently verified remediation.
-- For long sessions, use [context checkpoints and compaction recovery](docs/reference/context-checkpoints.md). They preserve a bounded local continuation package without changing plan authority. Measure phases and releases with [release accounting](docs/reference/release-accounting.md), follow the bounded [phase-to-session handoff](docs/guides/phase-session-handoff.md) with [phase packets](docs/reference/phase-packets.md), and choose focused checks through the read-only [validation ladder](docs/reference/validation-ladder.md).
+- For long sessions, use [context checkpoints and compaction recovery](docs/reference/context-checkpoints.md). They preserve a bounded local continuation package without changing plan authority. Measure phases and releases with [release accounting](docs/reference/release-accounting.md), compare only compatible evidence through [workflow economics](docs/reference/workflow-economics.md), follow the bounded [phase-to-session handoff](docs/guides/phase-session-handoff.md) with [phase packets](docs/reference/phase-packets.md), and choose focused checks through the read-only [validation ladder](docs/reference/validation-ladder.md).
 ## What it gives you
 - A finish-oriented lifecycle: plan, execute, review, and prove the result.
 - One process for different CLIs: adapter-specific commands stay outside the

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.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==2.13.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==2.15.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:
 
@@ -47,7 +47,7 @@ agent-lifecycle start --adapter <adapter-id> --file task.md
 - The [system architecture](docs/architecture/system-architecture.md) page explains how the project is organized, and [project comparison](docs/reference/project-comparison.md) shows how it differs from similar tools.
 - Multiple-agent boundaries, workflow configuration, model choice, prompts, timeouts and retries are described in [workflow customization and execution controls](docs/reference/workflow-customization.md).
 - Create a local project profile with `agent-lifecycle project profile init`; see [project workflow profile](docs/reference/project-workflow-profile.md). Explain the selected profile, plan constraints and adapter capability lineage with [effective configuration](docs/reference/effective-configuration.md), [structured result qualification](docs/reference/structured-result-qualification.md) and [adapter action evidence](docs/reference/adapter-action-evidence.md). Add optional project-owned architecture and dependency evidence with [external verification checks](docs/reference/external-verification-checks.md), run longer specialized adapter work through [bounded external tool jobs](docs/reference/external-tool-jobs.md), track bounded terminology with [project domain language](docs/reference/project-domain-language.md), coordinate several runs with the read-only [multi-run attention view](docs/reference/multi-run-attention-view.md), or use the optional [security analysis profile](docs/reference/security-analysis-profile.md) for untrusted findings and independently verified remediation.
-- For long sessions, use [context checkpoints and compaction recovery](docs/reference/context-checkpoints.md). They preserve a bounded local continuation package without changing plan authority. Measure phases and releases with [release accounting](docs/reference/release-accounting.md), follow the bounded [phase-to-session handoff](docs/guides/phase-session-handoff.md) with [phase packets](docs/reference/phase-packets.md), and choose focused checks through the read-only [validation ladder](docs/reference/validation-ladder.md).
+- For long sessions, use [context checkpoints and compaction recovery](docs/reference/context-checkpoints.md). They preserve a bounded local continuation package without changing plan authority. Measure phases and releases with [release accounting](docs/reference/release-accounting.md), compare only compatible evidence through [workflow economics](docs/reference/workflow-economics.md), follow the bounded [phase-to-session handoff](docs/guides/phase-session-handoff.md) with [phase packets](docs/reference/phase-packets.md), and choose focused checks through the read-only [validation ladder](docs/reference/validation-ladder.md).
 ## What it gives you
 - A finish-oriented lifecycle: plan, execute, review, and prove the result.
 - One process for different CLIs: adapter-specific commands stay outside the

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/pyproject.toml

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

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "2.13.0"
+__version__ = "2.15.0"

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/adapter_sessions/external_jobs.py

@@ -313,7 +313,7 @@ def request_external_job_cancel(
     job_root: Path | None = None,
     now: Clock | None = None,
 ) -> dict[str, Any]:
-    """Create an idempotent, source-bound cancellation request for a running attempt."""
+    """Acknowledge cancellation-request publication, not process termination."""
 
     require_external_job_pass(validate_external_job_request(request), "request")
     attempt_root = external_job_attempt_path(request, job_root=job_root)
@@ -345,8 +345,7 @@ def request_external_job_cancel(
     except FileExistsError:
         existing = _load_private_json(path, "external job cancel request")
         return _cancel_receipt(request, latest, requested_at=existing.get("requestedAt"), idempotent=True)
-    if completion_path.exists():
-        return _cancel_receipt(request, latest, requested_at=requested_at, idempotent=True, terminal=True)
+    # Completion after publication cannot turn this creator into a no-op retry.
     return _cancel_receipt(request, latest, requested_at=requested_at, idempotent=False)
 
 

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/adapter_sessions/lifecycle_control.py

@@ -69,10 +69,9 @@ def pre_action_gate(
         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
-        ),
+        expected_state_revision=(expected_state_revision if expected_state_revision is not None else 0),
         package_integrity=package_integrity,
+        repository_root=repository_root,
     )
 
 
@@ -92,6 +91,7 @@ def post_action_gate(
     actual_status: str = "PASS",
     event: dict[str, Any] | None = None,
     policy_path: Path | None = None,
+    repository_root: Path | None = None,
 ) -> dict[str, Any]:
     """Validate host output and changed paths after an authorized action."""
 
@@ -99,6 +99,7 @@ def post_action_gate(
     policy = load_lifecycle_control_policy(policy_path) if policy_path else None
     return evaluate_post_action_gate(
         pre_action=pre_action,
+        repository_root=repository_root,
         manifest=manifest,
         actual_changed_paths=actual_changed_paths,
         outcome=outcome,

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/audit/implementation.py

@@ -7,6 +7,7 @@ from typing import Any
 
 from agent_lifecycle.audit.ownership import build_ownership_report, report_has_category
 from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
+from agent_lifecycle.contracts.authority_text import require_review_text
 from agent_lifecycle.contracts.paths import normalize_repo_path
 from agent_lifecycle.contracts.review_verdict import (
     BLOCKING_REVIEW_SEVERITIES,
@@ -218,6 +219,7 @@ def validate_implementation_audit_report(
 ) -> dict[str, Any]:
     blockers: list[dict[str, Any]] = []
     compatibility_validation: dict[str, Any] | None = None
+    require_review_text(report)
     if report.get("schemaVersion") != IMPLEMENTATION_AUDIT_SCHEMA:
         blockers.append(
             {"code": "implementation-audit-schema", "message": "unsupported implementation audit schemaVersion"}
@@ -389,6 +391,7 @@ def build_final_implementation_audit(
 def validate_final_implementation_audit(
     audit: dict[str, Any], *, state: dict[str, Any] | None = None
 ) -> dict[str, Any]:
+    require_review_text(audit)
     blockers: list[dict[str, Any]] = []
     if audit.get("schemaVersion") != FINAL_IMPLEMENTATION_AUDIT_SCHEMA:
         blockers.append(

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/audit/ownership.py

@@ -6,8 +6,13 @@ from collections import Counter
 from pathlib import Path
 from typing import Any
 
-from agent_lifecycle.contracts import read_json_object
-from agent_lifecycle.contracts.ownership_paths import is_under_authority_path, normalize_authority_path
+from agent_lifecycle.contracts import LifecycleError, read_json_object
+from agent_lifecycle.contracts.ownership_paths import (
+    is_under_authority_path,
+    normalize_authority_path,
+    observed_authority_paths,
+    require_manifest_authority_paths,
+)
 from agent_lifecycle.contracts.paths import normalize_repo_path
 
 
@@ -16,9 +21,16 @@ def build_ownership_report(
     paths: list[str],
     *,
     base: str | None = None,
+    repository_root: Path | 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)
+    return build_ownership_report_from_manifest(
+        manifest,
+        paths,
+        manifest_path=manifest_path,
+        base=base,
+        repository_root=repository_root if repository_root is not None else Path.cwd(),
+    )
 
 
 def build_ownership_report_from_manifest(
@@ -27,11 +39,16 @@ def build_ownership_report_from_manifest(
     *,
     manifest_path: Path | None = None,
     base: str | None = None,
+    repository_root: Path | 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))]
+    require_manifest_authority_paths(manifest, operation_root=repository_root)
+    classifiers = _classifiers(manifest, manifest_path, repository_root=repository_root)
+    entries = [
+        _classify_path(path, classifiers, repository_root=repository_root)
+        for path in observed_authority_paths(paths, operation_root=repository_root)
+    ]
     categories = Counter(entry["category"] for entry in entries)
     owners = Counter(owner for entry in entries for owner in entry.get("owners", []))
     return {
@@ -57,15 +74,13 @@ def declared_ownership_paths(manifest: dict[str, Any]) -> list[str]:
     """Return literal workstream ownership paths for read-only projections."""
 
     classifiers = _classifiers(manifest, None)
-    paths = {
-        path
-        for roots in classifiers["workstreams"].values()
-        for path in roots
-    }
+    paths = {path for roots in classifiers["workstreams"].values() for path in roots}
     return sorted(paths)
 
 
-def _classifiers(manifest: dict[str, Any], manifest_path: Path | None) -> dict[str, Any]:
+def _classifiers(
+    manifest: dict[str, Any], manifest_path: Path | None, *, repository_root: Path | None = None
+) -> dict[str, Any]:
     package_value = manifest.get("package")
     package = package_value if isinstance(package_value, dict) else {}
     plan_root = package.get("planArtifactRoot")
@@ -97,7 +112,7 @@ def _classifiers(manifest: dict[str, Any], manifest_path: Path | None) -> dict[s
         ],
     }
     return {
-        "manifestPath": _repo_relative(manifest_path),
+        "manifestPath": _repo_relative(manifest_path, repository_root=repository_root),
         "planArtifactRoot": normalize_authority_path(plan_root, label="planArtifactRoot")
         if isinstance(plan_root, str)
         else None,
@@ -134,28 +149,48 @@ def _classifiers(manifest: dict[str, Any], manifest_path: Path | None) -> dict[s
     }
 
 
-def _classify_path(path: str, classifiers: dict[str, Any]) -> dict[str, Any]:
+def _classify_path(path: str, classifiers: dict[str, Any], *, repository_root: Path | None = None) -> dict[str, Any]:
     normalized = normalize_repo_path(path)
     manifest_path = classifiers["manifestPath"]
-    if isinstance(manifest_path, str) and normalized == manifest_path:
+    if (
+        isinstance(manifest_path, str)
+        and normalized.count("/") == manifest_path.count("/")
+        and is_under_authority_path(normalized, manifest_path, operation_root=repository_root)
+    ):
         return _entry(normalized, "plan-authority", ["controller"])
     plan_root = classifiers["planArtifactRoot"]
-    if isinstance(plan_root, str) and is_under_authority_path(normalized, plan_root):
+    if isinstance(plan_root, str) and is_under_authority_path(normalized, plan_root, operation_root=repository_root):
         return _entry(normalized, "plan-authority", ["controller"])
-    lead = [root for root in classifiers["leadOwned"] if is_under_authority_path(normalized, root)]
+    lead = [
+        root
+        for root in classifiers["leadOwned"]
+        if is_under_authority_path(normalized, root, operation_root=repository_root)
+    ]
     if lead:
         return _entry(normalized, "lead-owned", ["controller"], matched=lead)
-    forbidden = [root for root in classifiers["forbiddenWrites"] if is_under_authority_path(normalized, root)]
+    forbidden = [
+        root
+        for root in classifiers["forbiddenWrites"]
+        if is_under_authority_path(normalized, root, operation_root=repository_root)
+    ]
     if forbidden:
         return _entry(normalized, "forbidden", [], matched=forbidden)
-    read_only = [root for root in classifiers["readOnly"] if is_under_authority_path(normalized, root)]
+    read_only = [
+        root
+        for root in classifiers["readOnly"]
+        if is_under_authority_path(normalized, root, operation_root=repository_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_authority_path(normalized, root) for root in roots)
-    ]
+    owners = []
+    for owner, roots in classifiers["workstreams"].items():
+        for root in roots:
+            if not is_under_authority_path(normalized, root, operation_root=repository_root):
+                continue
+            if repository_root is not None and not is_under_authority_path(normalized, root):
+                raise LifecycleError("ambiguous-authority-path", "filesystem alias would broaden a write grant")
+            if owner not in owners:
+                owners.append(owner)
     if owners:
         return _entry(normalized, "workstream-owned", owners)
     return _entry(normalized, "unowned", [])
@@ -174,11 +209,12 @@ def _entry(
     return value
 
 
-def _repo_relative(path: Path | None) -> str | None:
+def _repo_relative(path: Path | None, *, repository_root: Path | None = None) -> str | None:
     if path is None:
         return None
     try:
-        return normalize_repo_path(str(path.resolve().relative_to(Path.cwd().resolve())))
+        root = repository_root if repository_root is not None else Path.cwd()
+        return normalize_repo_path(path.absolute().relative_to(root.absolute()).as_posix())
     except ValueError:
         return None
 

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/audit/package.py

@@ -13,6 +13,8 @@ from agent_lifecycle.audit.implementation import (
 from agent_lifecycle.audit.ownership import build_ownership_report, report_has_category
 from agent_lifecycle.changesets import changed_files
 from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object
+from agent_lifecycle.contracts.authority_text import require_review_text
+from agent_lifecycle.contracts.ownership_paths import require_manifest_authority_paths
 from agent_lifecycle.contracts.paths import normalize_repo_path
 from agent_lifecycle.freeze import plan_integrity_required, verify_plan_lock, verify_plan_package_integrity
 from agent_lifecycle.planning import (
@@ -79,9 +81,16 @@ def build_package_audit(
     package_files = _package_file_check(package_dir, manifest=manifest, repository_root=repository_root)
     _capture_check_failure("package-files", package_files, findings, blockers)
 
+    authority_check = _run_check(
+        lambda: require_manifest_authority_paths(manifest, operation_root=repository_root)
+    )
+    _capture_check_failure("authority-paths", authority_check, findings, blockers)
+
     profile = _load_profile(completeness_profile_path)
     manifest_check = _run_check(lambda: validate_plan_manifest(manifest))
-    completeness_check = _run_check(lambda: validate_plan_completeness(manifest, profile=profile))
+    completeness_check = _run_check(
+        lambda: validate_plan_completeness(manifest, profile=profile, operation_root=repository_root)
+    )
     _capture_check_failure("manifest", manifest_check, findings, blockers)
     _capture_check_failure("completeness", completeness_check, findings, blockers)
 
@@ -121,6 +130,7 @@ def build_package_audit(
             "packageFiles": package_files,
             "manifest": manifest_check,
             "completeness": completeness_check,
+            "authorityPaths": authority_check,
             "lock": lock_check,
             "acceptance": acceptance_check,
             "references": references_check,
@@ -170,6 +180,7 @@ def build_package_audit(
                 "packageFiles": package_files,
                 "manifest": manifest_check,
                 "completeness": completeness_check,
+            "authorityPaths": authority_check,
                 "lock": lock_check,
                 "acceptance": acceptance_check,
                 "references": references_check,
@@ -219,6 +230,7 @@ def build_finding_check_adoption_audit(
 def validate_package_audit(audit: dict[str, Any]) -> dict[str, Any]:
     """Validate the integrity and top-level semantics of a package receipt."""
 
+    require_review_text(audit)
     blockers: list[dict[str, Any]] = []
     if audit.get("schemaVersion") != PACKAGE_AUDIT_SCHEMA:
         blockers.append({"code": "package-audit-schema", "message": "unsupported package audit schemaVersion"})

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/changesets/git.py

@@ -24,6 +24,7 @@ def changed_files(cwd: Path, *, base: str | None = None) -> list[str]:
                     "diff",
                     "--no-ext-diff",
                     "--no-textconv",
+                    "--no-renames",
                     "--name-only",
                     "-z",
                     "--end-of-options",
@@ -36,13 +37,23 @@ def changed_files(cwd: Path, *, base: str | None = None) -> list[str]:
         paths.update(
             _git_paths(
                 cwd,
-                ["git", "diff", "--no-ext-diff", "--no-textconv", "--name-only", "-z", "--"],
+                ["git", "diff", "--no-ext-diff", "--no-textconv", "--no-renames", "--name-only", "-z", "--"],
             )
         )
         paths.update(
             _git_paths(
                 cwd,
-                ["git", "diff", "--no-ext-diff", "--no-textconv", "--name-only", "-z", "--cached", "--"],
+                [
+                    "git",
+                    "diff",
+                    "--no-ext-diff",
+                    "--no-textconv",
+                    "--no-renames",
+                    "--name-only",
+                    "-z",
+                    "--cached",
+                    "--",
+                ],
             )
         )
     paths.update(_git_paths(cwd, ["git", "ls-files", "--others", "--exclude-standard", "-z"]))

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/changesets/snapshot.py

@@ -11,7 +11,11 @@ from typing import Any
 
 from agent_lifecycle.changesets.git import GIT_TIMEOUT_SECONDS, changed_files, resolve_revision
 from agent_lifecycle.contracts import LifecycleError, canonical_digest
-from agent_lifecycle.contracts.ownership_paths import is_under_authority_path, normalize_authority_path
+from agent_lifecycle.contracts.ownership_paths import (
+    is_under_authority_path,
+    normalize_authority_path,
+    observed_authority_paths,
+)
 from agent_lifecycle.contracts.paths import normalize_repo_path, read_stable_repository_file
 
 MAX_CHANGED_FILES = 10_000
@@ -38,7 +42,12 @@ def capture_task_change_set(
             "changed file count exceeds the task snapshot limit",
             {"count": len(all_changed), "maxFiles": MAX_CHANGED_FILES},
         )
-    scoped = [path for path in all_changed if any(is_under_authority_path(path, prefix) for prefix in authority)]
+    all_changed = observed_authority_paths(all_changed, operation_root=root)
+    scoped = [
+        path
+        for path in all_changed
+        if any(is_under_authority_path(path, prefix, operation_root=root) for prefix in authority)
+    ]
     transitions: list[dict[str, Any]] = []
     current_entries: list[dict[str, Any]] = []
     total_bytes = 0

agent_lifecycle_kit-2.15.0/src/agent_lifecycle/cli/dispatch_metrics.py

@@ -0,0 +1,85 @@
+"""Metrics-specific dispatch helpers for the observability facade."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+from agent_lifecycle.contracts import LifecycleError, canonical_digest, read_json_object, write_json_create
+from agent_lifecycle.metrics import require_lifecycle_recommendation_pass
+from agent_lifecycle.metrics.recommendations import recommend_from_workflow_comparison
+from agent_lifecycle.metrics.regression_signals import (
+    compare_workflow_economics,
+    validate_workflow_economics_comparison_view,
+    workflow_comparison_context_from_fixture,
+)
+from agent_lifecycle.reporting.execution_resources import (
+    build_execution_resource_report,
+    validate_execution_resource_report,
+)
+
+
+def _dispatch_execution_report(args: argparse.Namespace) -> dict[str, Any]:
+    receipts: list[dict[str, Any]] = []
+    for item in args.receipt:
+        payload = read_json_object(Path(item), label="process execution receipt")
+        raw_receipt = payload.get("processReceipt")
+        candidate = raw_receipt if isinstance(raw_receipt, dict) else payload
+        receipts.append(candidate)
+    lineage = {"operationId": args.operation_id} if args.operation_id else None
+    report = build_execution_resource_report(receipts, lineage=lineage)
+    validation = validate_execution_resource_report(report)
+    write_json_create(Path(args.out), report)
+    return {
+        "schemaVersion": "agent-execution-resource-report-generation.v1",
+        "status": validation["status"],
+        "reportPath": args.out,
+        "reportDigest": canonical_digest(report),
+        "validation": validation,
+        "liveCallsStarted": False,
+        "productionPromotionClaimed": False,
+    }
+
+
+def _dispatch_workflow_compare(args: argparse.Namespace) -> dict[str, Any]:
+    before = workflow_comparison_context_from_fixture(
+        read_json_object(Path(args.before), label="workflow comparison before fixture")
+    )
+    after = workflow_comparison_context_from_fixture(
+        read_json_object(Path(args.after), label="workflow comparison after fixture")
+    )
+    comparison_pair = (
+        read_json_object(Path(args.comparison_pair), label="workflow comparison pair") if args.comparison_pair else None
+    )
+    comparison = compare_workflow_economics(before, after, comparison_pair=comparison_pair)
+    validation = validate_workflow_economics_comparison_view(comparison)
+    if validation["status"] != "PASS":
+        raise LifecycleError(
+            "workflow-comparison-invalid",
+            "workflow economics comparison failed validation",
+            {"validation": validation},
+        )
+    write_json_create(Path(args.out), comparison)
+    return comparison
+
+
+def _dispatch_workflow_recommend(args: argparse.Namespace) -> dict[str, Any]:
+    comparison = read_json_object(Path(args.comparison), label="workflow economics comparison")
+    validation = validate_workflow_economics_comparison_view(comparison)
+    if validation["status"] != "PASS":
+        raise LifecycleError(
+            "workflow-comparison-invalid",
+            "workflow economics comparison failed validation",
+            {"validation": validation},
+        )
+    recommendation = recommend_from_workflow_comparison(
+        comparison=comparison,
+        task_shape=args.task_shape,
+        current_mode=args.current_mode,
+        required_mode=args.required_mode,
+        protected_work=args.protected_work,
+    )
+    require_lifecycle_recommendation_pass(recommendation)
+    write_json_create(Path(args.out), recommendation)
+    return recommendation

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/cli/dispatch_observability.py

@@ -7,7 +7,11 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
-from agent_lifecycle.cli.dispatch_metrics import _dispatch_execution_report
+from agent_lifecycle.cli.dispatch_metrics import (
+    _dispatch_execution_report,
+    _dispatch_workflow_compare,
+    _dispatch_workflow_recommend,
+)
 from agent_lifecycle.context import check_context, load_context_profile, render_context
 from agent_lifecycle.context.checkpoint_store import (
     restore_context_checkpoint,
@@ -452,18 +456,14 @@ def _dispatch_model(args: argparse.Namespace) -> dict[str, Any]:
     if args.model_command == "route":
         routing_profile = read_json_object(Path(args.profile), label="model routing profile")
         host_profile = (
-            read_json_object(Path(args.host_profile), label="host model profile")
-            if args.host_profile
-            else None
+            read_json_object(Path(args.host_profile), label="host model profile") if args.host_profile else None
         )
         request = read_json_object(Path(args.request), label="model route request")
         return resolve_model_route(request, routing_profile, host_profile=host_profile)
     if args.model_command == "usage-check":
         receipt = read_json_object(Path(args.receipt), label="model usage receipt")
         decision = (
-            read_json_object(Path(args.route_decision), label="model route decision")
-            if args.route_decision
-            else None
+            read_json_object(Path(args.route_decision), label="model route decision") if args.route_decision else None
         )
         targets = read_json_object(Path(args.budget_targets), label="budget targets") if args.budget_targets else None
         result = validate_usage_receipt(receipt, budget_targets=targets, route_decision=decision)
@@ -512,6 +512,10 @@ def _dispatch_metrics(args: argparse.Namespace) -> dict[str, Any] | str:
         return _dispatch_phase_resources(args)
     if args.metrics_command == "release-accounting":
         return _dispatch_release_accounting(args)
+    if args.metrics_command == "workflow-compare":
+        return _dispatch_workflow_compare(args)
+    if args.metrics_command == "workflow-recommend":
+        return _dispatch_workflow_recommend(args)
     if args.metrics_command == "usage-export":
         export = build_usage_export(
             artifact_paths=[Path(item) for item in args.artifact],
@@ -591,9 +595,7 @@ def _dispatch_metrics(args: argparse.Namespace) -> dict[str, Any] | str:
     if args.metrics_command == "audit-proposal":
         report = read_json_object(Path(args.report), label="audit optimization report")
         raw_recommendation = report.get("recommendation")
-        proposal_recommendation: dict[str, Any] = (
-            raw_recommendation if isinstance(raw_recommendation, dict) else {}
-        )
+        proposal_recommendation: dict[str, Any] = raw_recommendation if isinstance(raw_recommendation, dict) else {}
         proposal = build_optimization_proposal(
             proposal_recommendation,
             approved=args.approved,
@@ -648,9 +650,7 @@ def _dispatch_phase_resources(args: argparse.Namespace) -> dict[str, Any]:
 
 def _dispatch_release_accounting(args: argparse.Namespace) -> dict[str, Any]:
     declared_provenance = (
-        read_json_object(Path(args.provenance), label="release accounting provenance")
-        if args.provenance
-        else None
+        read_json_object(Path(args.provenance), label="release accounting provenance") if args.provenance else None
     )
     accounting = build_release_accounting(
         args.release_id,

{agent_lifecycle_kit-2.13.0 → agent_lifecycle_kit-2.15.0}/src/agent_lifecycle/cli/metrics_parser.py

@@ -31,6 +31,24 @@ def add_metrics_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentP
     release_accounting.add_argument("--project-root", default=".")
     release_accounting.add_argument("--provenance")
     release_accounting.add_argument("--out", required=True)
+    workflow_compare = metrics_sub.add_parser(
+        "workflow-compare",
+        help="compare two explicitly bound workflow economics fixtures",
+    )
+    workflow_compare.add_argument("--before", required=True)
+    workflow_compare.add_argument("--after", required=True)
+    workflow_compare.add_argument("--comparison-pair")
+    workflow_compare.add_argument("--out", required=True)
+    workflow_recommend = metrics_sub.add_parser(
+        "workflow-recommend",
+        help="build an advisory recommendation from a workflow comparison",
+    )
+    workflow_recommend.add_argument("--comparison", required=True)
+    workflow_recommend.add_argument("--task-shape", default="feature")
+    workflow_recommend.add_argument("--current-mode", choices=MODES, required=True)
+    workflow_recommend.add_argument("--required-mode", choices=MODES, required=True)
+    workflow_recommend.add_argument("--protected-work", action="store_true")
+    workflow_recommend.add_argument("--out", required=True)
     usage_export = metrics_sub.add_parser("usage-export")
     usage_export.add_argument("--artifact", action="append", default=[])
     usage_export.add_argument("--project-root", default=".")