agent-lifecycle-kit 2.38.0__tar.gz → 2.40.0__tar.gz

{agent_lifecycle_kit-2.38.0/src/agent_lifecycle_kit.egg-info → agent_lifecycle_kit-2.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-lifecycle-kit
-Version: 2.38.0
+Version: 2.40.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
@@ -42,7 +42,7 @@ Release 2.28 adds [bounded lifecycle and accounting baselines](docs/reference/pe
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md). Release 2.23 adds [compact S0/S1 authoring](docs/reference/tier-proportional-plan-packages.md) with explicit checklist completion and unchanged approval gates. Release 2.22 adds [conservative plan-review reuse](docs/reference/conservative-delta-review.md) with independent current applicability and no automatic full reruns. Release 2.21 adds [command accounting, bounded preparation and response recovery](docs/reference/source-native-workflow-accounting.md). Release 2.20 adds [target-bound initialization](docs/reference/cli.md#release-220-composed-initialization-and-digest-display), [bounded local continuation](docs/reference/workflow-continuation.md) and batched Git snapshots. Release 2.19 adds [safe artifact authoring and planning preflight](docs/reference/safe-artifact-authoring.md), [bounded review handoff](docs/reference/review-mesh.md#bounded-review-handoff) and thin skills with complete references. Release 2.18 bounds process/Git diagnostics, hardens signing and distinguishes OpenCode 1.x/2.x compatibility ([adapter notes](docs/adapters/opencode.md)); 2.17 strengthens [workflow validation and recovery](docs/reference/workflow-completeness.md). Release 2.16 introduced cumulative accounting within verified host capabilities; see [retention maintenance](docs/operations/retention-maintenance.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.15, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.38.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.15, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.40.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.38.0 → agent_lifecycle_kit-2.40.0}/README.md

@@ -19,7 +19,7 @@ Release 2.28 adds [bounded lifecycle and accounting baselines](docs/reference/pe
 ## Quick start
 Start with [install ALK and make the first run](docs/guides/install-and-first-run.md). Release 2.23 adds [compact S0/S1 authoring](docs/reference/tier-proportional-plan-packages.md) with explicit checklist completion and unchanged approval gates. Release 2.22 adds [conservative plan-review reuse](docs/reference/conservative-delta-review.md) with independent current applicability and no automatic full reruns. Release 2.21 adds [command accounting, bounded preparation and response recovery](docs/reference/source-native-workflow-accounting.md). Release 2.20 adds [target-bound initialization](docs/reference/cli.md#release-220-composed-initialization-and-digest-display), [bounded local continuation](docs/reference/workflow-continuation.md) and batched Git snapshots. Release 2.19 adds [safe artifact authoring and planning preflight](docs/reference/safe-artifact-authoring.md), [bounded review handoff](docs/reference/review-mesh.md#bounded-review-handoff) and thin skills with complete references. Release 2.18 bounds process/Git diagnostics, hardens signing and distinguishes OpenCode 1.x/2.x compatibility ([adapter notes](docs/adapters/opencode.md)); 2.17 strengthens [workflow validation and recovery](docs/reference/workflow-completeness.md). Release 2.16 introduced cumulative accounting within verified host capabilities; see [retention maintenance](docs/operations/retention-maintenance.md).
 
-It includes macOS, Linux and Windows instructions, Python 3.11-3.15, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.38.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.15, [PyPI](https://pypi.org/project/agent-lifecycle-kit/) installation with `python -m pip install agent-lifecycle-kit==2.40.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.38.0 → agent_lifecycle_kit-2.40.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-lifecycle-kit"
-version = "2.38.0"
+version = "2.40.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.16"

{agent_lifecycle_kit-2.38.0 → agent_lifecycle_kit-2.40.0}/src/agent_lifecycle/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "2.38.0"
+__version__ = "2.40.0"

{agent_lifecycle_kit-2.38.0 → agent_lifecycle_kit-2.40.0}/src/agent_lifecycle/accounting/closing_resource_recovery.py

@@ -156,6 +156,97 @@ _SIDECAR_FIELDS = frozenset(
 )
 
 
+def _closing_sidecar_owner(
+    item: dict,
+    operations: dict,
+    seen: set[str],
+    window: str,
+    proposal: dict,
+    effect_digest: str,
+) -> tuple[str, str]:
+    """Validate sidecar membership before inspecting native financial facts."""
+    if (
+        type(item) is not dict
+        or set(item) != _SIDECAR_FIELDS
+        or (item.get("schemaVersion") != "agent-closing-operation-binding.v1")
+    ):
+        _unavailable("Closing operation sidecar is malformed")
+    operation_id = item.get("operationId")
+    if type(operation_id) is not str or operation_id in seen or operation_id not in operations:
+        _unavailable("Closing operation is duplicated or absent from native accounting")
+    seen.add(operation_id)
+    if item.get("closingWindowId") != window:
+        _unavailable("Closing operation belongs to another window")
+    if (
+        item.get("runId") != proposal["runId"]
+        or item.get("budgetScopeId") != proposal["budgetScopeId"]
+        or item.get("bindingId") != proposal["bindingId"]
+        or item.get("policyEffectDigest") != effect_digest
+        or item.get("unit") != proposal["unit"]
+    ):
+        _unavailable("Closing operation differs from the signed scope")
+    for revision_name in ("expectedJournalRevision", "expectedWorkflowRevision", "expectedAuthorityEpoch"):
+        if _amount(item[revision_name], revision_name) > (1 << 53) - 1:
+            _unavailable("Closing operation revision exceeds the safe-integer domain")
+    if (
+        type(item["expectedGuardStateDigest"]) is not str
+        or re.fullmatch(r"[0-9a-f]{64}", item["expectedGuardStateDigest"]) is None
+    ):
+        _unavailable("Closing guard identity is malformed")
+    owner = _owner_key(item.get("owner"))
+    return operation_id, owner
+
+
+def _validate_closing_native_binding(
+    item: dict,
+    native: dict,
+    operation_id: str,
+    owner: str,
+    proposal: dict,
+) -> None:
+    """Require the exact persisted native identity for this sidecar."""
+    binding = native.get("binding")
+    if type(binding) is not dict or native.get("digest") != digest(binding):
+        _unavailable("Native operation binding is corrupted")
+    if (
+        item.get("nativeOperationDigest") != native["digest"]
+        or binding.get("operation_id") != operation_id
+        or binding.get("budget_scope_id") != proposal["budgetScopeId"]
+        or binding.get("run_id") != proposal["runId"]
+        or (binding.get("task_id") or "") != owner
+        or binding.get("unit_definition_id") != proposal["unit"]["unitDefinitionId"]
+        or binding.get("upper_bound_tokens") != item.get("upperBound")
+    ):
+        _unavailable("Closing sidecar does not match the native operation")
+
+
+def _closing_native_amounts(item: dict, native: dict) -> tuple[int | None, int]:
+    """Preserve settlement and reservation checks in their original order."""
+    upper = _amount(item["upperBound"], "operation upper bound")
+    reserved = _amount(native.get("reservation"), "native reservation")
+    if reserved not in {0, upper}:
+        _unavailable("Native reservation has an unsupported partial value")
+    actual = native.get("actual")
+    if actual is not None:
+        _amount(actual, "native actual")
+    native_status = native.get("state")
+    if native_status not in {
+        "RESERVED",
+        "DISPATCHED",
+        "UNAVAILABLE",
+        "SETTLED",
+        "CANCELLED_WITH_NO_DISPATCH_PROOF",
+    }:
+        _unavailable("Native operation state is unsupported")
+    if (native_status == "SETTLED") != (actual is not None):
+        _unavailable("Native settlement state and actual differ")
+    if native_status in {"SETTLED", "CANCELLED_WITH_NO_DISPATCH_PROOF"} and reserved != 0:
+        _unavailable("Finalized operation still holds a reservation")
+    if native_status in {"RESERVED", "DISPATCHED", "UNAVAILABLE"} and reserved != upper:
+        _unavailable("Pending operation lost its reservation")
+    return actual, reserved
+
+
 def _window_operations(
     state: dict,
     proposal: dict,
@@ -170,71 +261,17 @@ def _window_operations(
     totals: dict[str, dict[str, int]] = {}
     seen: set[str] = set()
     for item in bindings:
-        if (
-            type(item) is not dict
-            or set(item) != _SIDECAR_FIELDS
-            or (item.get("schemaVersion") != "agent-closing-operation-binding.v1")
-        ):
-            _unavailable("Closing operation sidecar is malformed")
-        operation_id = item.get("operationId")
-        if type(operation_id) is not str or operation_id in seen or operation_id not in operations:
-            _unavailable("Closing operation is duplicated or absent from native accounting")
-        seen.add(operation_id)
-        if item.get("closingWindowId") != window:
-            _unavailable("Closing operation belongs to another window")
-        if (
-            item.get("runId") != proposal["runId"]
-            or item.get("budgetScopeId") != proposal["budgetScopeId"]
-            or item.get("bindingId") != proposal["bindingId"]
-            or item.get("policyEffectDigest") != effect_digest
-            or item.get("unit") != proposal["unit"]
-        ):
-            _unavailable("Closing operation differs from the signed scope")
-        for revision_name in ("expectedJournalRevision", "expectedWorkflowRevision", "expectedAuthorityEpoch"):
-            if _amount(item[revision_name], revision_name) > (1 << 53) - 1:
-                _unavailable("Closing operation revision exceeds the safe-integer domain")
-        if (
-            type(item["expectedGuardStateDigest"]) is not str
-            or re.fullmatch(r"[0-9a-f]{64}", item["expectedGuardStateDigest"]) is None
-        ):
-            _unavailable("Closing guard identity is malformed")
-        owner = _owner_key(item.get("owner"))
+        operation_id, owner = _closing_sidecar_owner(
+            item,
+            operations,
+            seen,
+            window,
+            proposal,
+            effect_digest,
+        )
         native = operations[operation_id]
-        binding = native.get("binding")
-        if type(binding) is not dict or native.get("digest") != digest(binding):
-            _unavailable("Native operation binding is corrupted")
-        if (
-            item.get("nativeOperationDigest") != native["digest"]
-            or binding.get("operation_id") != operation_id
-            or binding.get("budget_scope_id") != proposal["budgetScopeId"]
-            or binding.get("run_id") != proposal["runId"]
-            or (binding.get("task_id") or "") != owner
-            or binding.get("unit_definition_id") != proposal["unit"]["unitDefinitionId"]
-            or binding.get("upper_bound_tokens") != item.get("upperBound")
-        ):
-            _unavailable("Closing sidecar does not match the native operation")
-        upper = _amount(item["upperBound"], "operation upper bound")
-        reserved = _amount(native.get("reservation"), "native reservation")
-        if reserved not in {0, upper}:
-            _unavailable("Native reservation has an unsupported partial value")
-        actual = native.get("actual")
-        if actual is not None:
-            _amount(actual, "native actual")
-        native_status = native.get("state")
-        if native_status not in {
-            "RESERVED",
-            "DISPATCHED",
-            "UNAVAILABLE",
-            "SETTLED",
-            "CANCELLED_WITH_NO_DISPATCH_PROOF",
-        }:
-            _unavailable("Native operation state is unsupported")
-        if (native_status == "SETTLED") != (actual is not None):
-            _unavailable("Native settlement state and actual differ")
-        if native_status in {"SETTLED", "CANCELLED_WITH_NO_DISPATCH_PROOF"} and reserved != 0:
-            _unavailable("Finalized operation still holds a reservation")
-        if native_status in {"RESERVED", "DISPATCHED", "UNAVAILABLE"} and reserved != upper:
-            _unavailable("Pending operation lost its reservation")
+        _validate_closing_native_binding(item, native, operation_id, owner, proposal)
+        actual, reserved = _closing_native_amounts(item, native)
         row = totals.setdefault(owner, {"spent": 0, "reservations": 0})
         row["spent"] = _sum([row["spent"], actual or 0], "window spend")
         row["reservations"] = _sum([row["reservations"], reserved], "window reservations")
@@ -275,19 +312,15 @@ def _protected_buckets(state: dict, proposal: dict, buckets: list[dict], owners:
     return current
 
 
-def reconstruct_closing_balances(
+def _validate_closing_reconstruction(
     state: dict,
     journal_revision: int,
     proposal: dict,
     operation_bindings: list[dict],
     protection_buckets: list[dict],
     policy_effect_digest: str,
-) -> list[dict]:
-    """Rebuild all owner rows from persisted membership and current native state.
-
-    A caller must authenticate the proposal, effect, and SQL snapshot separately.
-    Returned rows deliberately contain no financial admission or permission.
-    """
+) -> tuple[int, list[dict]]:
+    """Validate reconstruction scope and domain before selecting native owners."""
     if type(state) is not dict or type(proposal) is not dict:
         _unavailable("Native state or closing proposal is missing")
     if proposal.get("schemaVersion") != "agent-closing-resource-proposal.v1":
@@ -314,6 +347,11 @@ def reconstruct_closing_balances(
     limits = proposal.get("limits")
     if type(limits) is not list or not limits:
         _unavailable("Closing owner inventory is missing")
+    return revision, limits
+
+
+def _select_closing_owner_limits(state: dict, limits: list[dict]) -> dict[str, dict]:
+    """Require complete owner membership and consistent known financial facts."""
     selected: dict[str, dict] = {}
     for item in limits:
         try:
@@ -333,6 +371,77 @@ def reconstruct_closing_balances(
         or state.get("opening", {}).get("pending_operations") != []
     ):
         _unavailable("Native qualification contradicts unknown financial facts")
+    return selected
+
+
+def _closing_balance_row(
+    native: Any,
+    owner: str,
+    limit: dict,
+    proposal: dict,
+    revision: int,
+    qualified: bool,
+    status: str,
+    window: dict[str, int],
+    pool: int,
+) -> dict:
+    """Project one validated owner without granting financial authority."""
+    entry = native.tasks[owner] if owner else None
+    known = entry["known_spent"] if entry else native.known_spent
+    spent = entry["spent"] if entry else native.spent
+    reserved = entry["active_reservations"] if entry else native.active_reservations
+    protected = entry["protected_closeout"] if entry else native.protected_closeout
+    enabled = limit["participation"] == "CLOSING_ENABLED"
+    if not enabled and (window["spent"] or window["reservations"] or pool):
+        _unavailable("Retained task acquired new-window resources")
+    if protected is not None and pool > protected:
+        _unavailable("Window protection exceeds native owner pool")
+    return {
+        "schemaVersion": "agent-closing-resource-balance.v1",
+        "runId": proposal["runId"],
+        "budgetScopeId": proposal["budgetScopeId"],
+        "closingWindowId": proposal["closingWindowId"],
+        "journalRevision": revision,
+        "unit": proposal["unit"],
+        "scope": limit["scope"],
+        "spentAtActivation": limit["knownSpentAtAnchor"],
+        "currentKnownCumulativeSpent": known,
+        "currentCumulativeSpent": spent if qualified else None,
+        "windowKnownSpent": window["spent"],
+        "windowSpent": window["spent"] if qualified else None,
+        "allActiveReservations": reserved,
+        "windowActiveReservations": window["reservations"] if reserved is not None else None,
+        "globalProtected": protected,
+        "windowProtected": pool if protected is not None else None,
+        "cumulativeCeiling": limit["prospectiveCumulativeCeiling"],
+        "windowAllowance": limit["approvedAdditional"],
+        "priorViolationsDigest": limit["priorViolationSetDigest"],
+        "qualification": status,
+    }
+
+
+def reconstruct_closing_balances(
+    state: dict,
+    journal_revision: int,
+    proposal: dict,
+    operation_bindings: list[dict],
+    protection_buckets: list[dict],
+    policy_effect_digest: str,
+) -> list[dict]:
+    """Rebuild all owner rows from persisted membership and current native state.
+
+    A caller must authenticate the proposal, effect, and SQL snapshot separately.
+    Returned rows deliberately contain no financial admission or permission.
+    """
+    revision, limits = _validate_closing_reconstruction(
+        state,
+        journal_revision,
+        proposal,
+        operation_bindings,
+        protection_buckets,
+        policy_effect_digest,
+    )
+    selected = _select_closing_owner_limits(state, limits)
     operation_totals = _window_operations(state, proposal, operation_bindings, policy_effect_digest)
     if not set(operation_totals) <= set(selected):
         _unavailable("Closing operation has no owner")
@@ -353,45 +462,24 @@ def reconstruct_closing_balances(
     run_reserved = _sum([x["reservations"] for x in operation_totals.values()], "run window reservations")
     rows = []
     for owner, limit in selected.items():
-        entry = native.tasks[owner] if owner else None
-        known = entry["known_spent"] if entry else native.known_spent
-        spent = entry["spent"] if entry else native.spent
-        reserved = entry["active_reservations"] if entry else native.active_reservations
-        protected = entry["protected_closeout"] if entry else native.protected_closeout
         window = operation_totals.get(owner, {"spent": 0, "reservations": 0})
         if owner == "":
             window = {"spent": run_spent, "reservations": run_reserved}
             pool = _sum(list(window_protected.values()), "run window protection")
         else:
             pool = window_protected.get(owner, 0)
-        enabled = limit["participation"] == "CLOSING_ENABLED"
-        if not enabled and (window["spent"] or window["reservations"] or pool):
-            _unavailable("Retained task acquired new-window resources")
-        if protected is not None and pool > protected:
-            _unavailable("Window protection exceeds native owner pool")
         rows.append(
-            {
-                "schemaVersion": "agent-closing-resource-balance.v1",
-                "runId": proposal["runId"],
-                "budgetScopeId": proposal["budgetScopeId"],
-                "closingWindowId": proposal["closingWindowId"],
-                "journalRevision": revision,
-                "unit": unit,
-                "scope": limit["scope"],
-                "spentAtActivation": limit["knownSpentAtAnchor"],
-                "currentKnownCumulativeSpent": known,
-                "currentCumulativeSpent": spent if qualified else None,
-                "windowKnownSpent": window["spent"],
-                "windowSpent": window["spent"] if qualified else None,
-                "allActiveReservations": reserved,
-                "windowActiveReservations": window["reservations"] if reserved is not None else None,
-                "globalProtected": protected,
-                "windowProtected": pool if protected is not None else None,
-                "cumulativeCeiling": limit["prospectiveCumulativeCeiling"],
-                "windowAllowance": limit["approvedAdditional"],
-                "priorViolationsDigest": limit["priorViolationSetDigest"],
-                "qualification": status,
-            }
+            _closing_balance_row(
+                native,
+                owner,
+                limit,
+                proposal,
+                revision,
+                qualified,
+                status,
+                window,
+                pool,
+            )
         )
     return rows
 

{agent_lifecycle_kit-2.38.0 → agent_lifecycle_kit-2.40.0}/src/agent_lifecycle/accounting/declared_ledger.py

@@ -5,7 +5,9 @@ from __future__ import annotations
 import hashlib
 import os
 import re
+import secrets
 import stat
+from contextlib import ExitStack
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -22,6 +24,8 @@ from agent_lifecycle.accounting.declared_ledger_records import (
 )
 from agent_lifecycle.contracts import LifecycleError, canonical_bytes, canonical_digest
 from agent_lifecycle.contracts.authority_io import (
+    create_authority_bytes,
+    hold_authority_read_fd,
     normalize_authority_path,
     read_authority_bytes,
     replace_authority_bytes,
@@ -371,6 +375,22 @@ def _decode_coordinator_origin(
     }
 
 
+def _r11_coordinator_claim_matches(primary: Path, pending: Path, owned_claim: tuple[bytes, int] | None) -> bool:
+    if owned_claim is None:
+        return not pending.exists() and not pending.is_symlink()
+    raw, descriptor = owned_claim
+    try:
+        held, current = os.fstat(descriptor), pending.lstat()
+        return (
+            stat.S_ISREG(current.st_mode)
+            and os.path.samestat(held, current)
+            and held.st_mode == current.st_mode
+            and read_authority_bytes(pending, root=primary, max_bytes=131_072) == raw
+        )
+    except (OSError, LifecycleError):
+        return False
+
+
 def read_coordinator_cost_head(project_root: Path, *, ancestor_head_sha256: str | None = None) -> dict[str, Any]:
     """Read current declared provenance and optionally prove a pinned ancestor.
 
@@ -379,6 +399,15 @@ def read_coordinator_cost_head(project_root: Path, *, ancestor_head_sha256: str
     Missing, altered, cyclic, over-limit or pending ancestry never falls back to
     a current-balance comparison. This reads no session history or telemetry.
     """
+    return _read_coordinator_cost_head(project_root, ancestor_head_sha256=ancestor_head_sha256)
+
+
+def _read_coordinator_cost_head(
+    project_root: Path,
+    *,
+    ancestor_head_sha256: str | None = None,
+    owned_claim: tuple[bytes, int] | None = None,
+) -> dict[str, Any]:
     _require(
         ancestor_head_sha256 is None
         or (isinstance(ancestor_head_sha256, str) and re.fullmatch("[0-9a-f]{64}", ancestor_head_sha256) is not None),
@@ -389,7 +418,7 @@ def read_coordinator_cost_head(project_root: Path, *, ancestor_head_sha256: str
     path = primary / _R11_COORDINATOR_HEAD
     pending = path.with_suffix(".pending.json")
     _require(
-        not pending.exists() and not pending.is_symlink(),
+        _r11_coordinator_claim_matches(primary, pending, owned_claim),
         "r11-opening-pending",
         "coordinator head update is unresolved",
     )
@@ -495,8 +524,7 @@ def read_coordinator_cost_head(project_root: Path, *, ancestor_head_sha256: str
         stable = (
             _r11_coordinator_head_bytes(primary) == raw
             and all(read_authority_bytes(p, root=primary, max_bytes=131_072) == value for p, value in observed.items())
-            and not pending.exists()
-            and not pending.is_symlink()
+            and _r11_coordinator_claim_matches(primary, pending, owned_claim)
         )
     except OSError:
         stable = False
@@ -575,8 +603,6 @@ def advance_coordinator_cost_head(project_root: Path, *, source_path: str) -> di
 
     def exclusive(target: Path, raw: bytes) -> None:
         if os.name == "nt":
-            from agent_lifecycle.contracts.authority_io import create_authority_bytes
-
             create_authority_bytes(target, raw, root=primary, private=True)
             return
         fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
@@ -587,44 +613,58 @@ def advance_coordinator_cost_head(project_root: Path, *, source_path: str) -> di
 
     # Refuse unsupported durability before creating a sticky claim.
     _sync_directory(path.parent)
-    exclusive(pending, canonical_bytes(head))
-    _sync_directory(path.parent)
-    if (
-        _r11_coordinator_head_bytes(primary) != previous_raw
-        or read_authority_bytes(primary / source_path, root=primary, max_bytes=131_072) != source_raw
-    ):
-        # This writer has not touched the head. Release only its own stale claim;
-        # a competing successful update must not be left blocked by this loser.
-        pending.unlink()
-        _sync_directory(path.parent)
-        raise LifecycleError("r11-opening-stale", "source/head changed after update claim")
-    if previous_raw is not None:
-        archive = path.parent / "coordinator-cost-head-history"
-        if os.name == "nt":
-            from agent_lifecycle.contracts.private_storage import ensure_private_directory
-
-            ensure_private_directory(archive, boundary=path.parent)
-        else:
-            archive.mkdir(mode=0o700, exist_ok=True)
-        _require(stat.S_ISDIR(archive.lstat().st_mode), "r11-opening-origin", "head archive is indirect")
-        archived = archive / (hashlib.sha256(previous_raw).hexdigest() + ".json")
-        if archived.exists():
+    claim = canonical_bytes({"head": head, "ownerNonce": secrets.token_hex(16)})
+    create_authority_bytes(pending, claim, root=primary, private=True)
+    with ExitStack() as guards:
+        descriptor = guards.enter_context(hold_authority_read_fd(pending, root=primary))
+        ownership = (claim, descriptor)
+        try:
             _require(
-                read_authority_bytes(archived, root=primary, max_bytes=131_072) == previous_raw,
-                "r11-opening-origin",
-                "previous head archive differs",
+                _r11_coordinator_claim_matches(primary, pending, ownership),
+                "r11-opening-pending",
+                "coordinator claim ownership changed",
             )
-        else:
-            exclusive(archived, previous_raw)
-        _sync_directory(archive)
-    exclusive(temporary, canonical_bytes(head))
-    _sync_directory(path.parent)
-    replace_authority_bytes(path, canonical_bytes(head), root=primary)
-    temporary.unlink()
-    _sync_directory(path.parent)
+            _sync_directory(path.parent)
+            if (
+                _r11_coordinator_head_bytes(primary) != previous_raw
+                or read_authority_bytes(primary / source_path, root=primary, max_bytes=131_072) != source_raw
+            ):
+                guards.close()
+                pending.unlink()
+                _sync_directory(path.parent)
+                raise LifecycleError("r11-opening-stale", "source/head changed after update claim")
+            if previous_raw is not None:
+                archive = path.parent / "coordinator-cost-head-history"
+                if os.name == "nt":
+                    from agent_lifecycle.contracts.private_storage import ensure_private_directory
+
+                    ensure_private_directory(archive, boundary=path.parent)
+                else:
+                    archive.mkdir(mode=0o700, exist_ok=True)
+                _require(stat.S_ISDIR(archive.lstat().st_mode), "r11-opening-origin", "head archive is indirect")
+                archived = archive / (hashlib.sha256(previous_raw).hexdigest() + ".json")
+                if archived.exists():
+                    _require(
+                        read_authority_bytes(archived, root=primary, max_bytes=131_072) == previous_raw,
+                        "r11-opening-origin",
+                        "previous head archive differs",
+                    )
+                else:
+                    exclusive(archived, previous_raw)
+                _sync_directory(archive)
+            exclusive(temporary, canonical_bytes(head))
+            _sync_directory(path.parent)
+            replace_authority_bytes(path, canonical_bytes(head), root=primary)
+            temporary.unlink()
+            _sync_directory(path.parent)
+            result = _read_coordinator_cost_head(project_root, owned_claim=ownership)
+        except BaseException:
+            # Close normally so an unrelated publication error keeps its type.
+            guards.close()
+            raise
     pending.unlink()
     _sync_directory(path.parent)
-    return read_coordinator_cost_head(project_root)
+    return result
 
 
 def _sync_directory(path: Path) -> None:

{agent_lifecycle_kit-2.38.0 → agent_lifecycle_kit-2.40.0}/src/agent_lifecycle/contracts/authority_io.py

@@ -374,6 +374,35 @@ def open_authority_read(path: Path, *, root: Path | None = None) -> Iterator[Bin
         raise LifecycleError("authority-input-unavailable", "authority input cannot be safely read") from None
 
 
+@contextmanager
+def hold_authority_read_fd(path: Path, *, root: Path | None = None) -> Iterator[int]:
+    """Borrow a read-only FD; validate file and parents at both boundaries."""
+    root, name = authority_location(path, root=root)
+    target = root / name
+    descriptor = None
+    try:
+        with open_authority_read(target, root=root) as handle:
+            before = os.fstat(handle.fileno())
+            parents = [(parent, parent.lstat()) for parent in target.parents]
+            descriptor = os.dup(handle.fileno())
+            os.set_inheritable(descriptor, False)
+        yield descriptor
+        with open_authority_read(target, root=root) as handle:
+            _same_identity(before, os.fstat(descriptor), content=True)
+            _same_identity(before, os.fstat(handle.fileno()), content=True)
+            for parent, identity in parents:
+                _same_identity(identity, parent.lstat())
+    except FileNotFoundError:
+        if descriptor is None:
+            raise
+        raise LifecycleError("authority-input-changed", "authority input changed during I/O") from None
+    except OSError:
+        raise LifecycleError("authority-input-unavailable", "authority input cannot be safely read") from None
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+
+
 def read_authority_bytes(path: Path, *, max_bytes: int, root: Path | None = None) -> bytes:
     """Read bounded stable bytes from the actual descriptor consumed by the caller."""
 

{agent_lifecycle_kit-2.38.0 → agent_lifecycle_kit-2.40.0}/src/agent_lifecycle/workflow/query.py

@@ -18,13 +18,26 @@ from agent_lifecycle.workflow.transition_contract import build_action
 
 def status(state_path: Path, *, full: bool = False) -> dict[str, Any]:
     state = load_state(state_path)
+    budgets = state.get("budgets")
+    validation_accounting = {
+        "mode": "DECLARED_ONLY",
+        "declaredMaxPerTask": budgets.get("maxValidationRunsPerTask") if isinstance(budgets, dict) else None,
+        "observedRuns": None,
+        "enforcement": "NOT_ENFORCED_FOR_EXTERNAL_COMMANDS",
+        "stateCounterSemantics": "UNVERIFIED_LEGACY_COUNTER",
+    }
     if full:
         return {
             "schemaVersion": "agent-workflow-status-full.v1",
             "state": state,
             "nextAction": next_action(state),
+            "validationAccounting": validation_accounting,
         }
-    return {**summarize_state(state_path, state), "nextAction": next_action(state)}
+    return {
+        **summarize_state(state_path, state),
+        "nextAction": next_action(state),
+        "validationAccounting": validation_accounting,
+    }
 
 
 def next_action(state: dict[str, Any]) -> dict[str, Any]: