src/tests/runtime/test_managed_query.py

from __future__ import annotations

import copy
import hashlib
import pickle
from concurrent.futures import ThreadPoolExecutor
from contextlib import contextmanager, nullcontext
from dataclasses import FrozenInstanceError, dataclass, field, replace
from datetime import UTC, datetime
from pathlib import Path
from threading import Barrier

import networkx as nx
import pytest

from ctx.core.graph.graph_store import build_graph_store
from ctx.engine.benefit import BenefitCandidate, EvidenceSummary, NetBenefitPolicy, ResourceCosts
from ctx.engine.content import MaterialDescriptor, MaterialIdentity
from ctx.engine.installation import (
    InstallAuthorizer,
    InstallConsentPolicy,
    InstallExecutionBinding,
    InstallPlanDescriptor,
    InstallPlanningBundle,
    PreparedInstallPlan,
)
from ctx.engine.planner import CapabilityCandidate, CapabilitySelection, WorkObservation
from ctx.engine.protocol import (
    INSTALL_RECEIPT_SCHEMA_V3,
    EngineEvent,
    HostAction,
    ScopeRef,
)
from ctx.engine.replay import (
    ObservationNormalizer,
    ObservationReference,
    StructuredSurrogate,
)
from ctx.engine.engine import EngineSnapshot
from ctx.engine.state import CommittedPlanV3, EngineState
from ctx.engine.store import (
    ActivationExecutionStatus,
    EventIdCollision,
    RevisionConflict,
    StreamId,
)
from ctx.runtime.composition import EngineComposition, open_engine_composition
from ctx.runtime.managed_query import (
    ManagedAdvanceResult,
    ManagedQueryError,
    PreparedManagedQuery,
    _project_prepared_managed_query_snapshot,
    advance_managed_query,
    prepare_managed_query,
    reopen_managed_query,
)


NOW = "2026-08-02T12:00:00Z"
CATALOG_NAMESPACE_DIGEST = hashlib.sha256(b"managed-query-catalog").hexdigest()


def _digest(value: str) -> str:
    return hashlib.sha256(value.encode("utf-8")).hexdigest()


def _scope(suffix: str = "one") -> ScopeRef:
    return ScopeRef(
        tenant_id="tenant-1",
        workspace_id="workspace-1",
        repository_id="repository-1",
        session_id=f"session-{suffix}",
        exposure_id=f"exposure-{suffix}",
        host_context_id="host-neutral",
    )


def _candidate(
    capability_id: str,
    *,
    actionability: str,
    installation_snapshot_digest: str | None = None,
) -> CapabilityCandidate:
    kind, name = capability_id.split(":", 1)
    descriptor = (
        None
        if installation_snapshot_digest is None
        else _install_bundle(capability_id, installation_snapshot_digest).descriptor
    )
    return CapabilityCandidate(
        capability_id=capability_id,
        kind=kind,
        name=name,
        source_digest=_digest(f"source:{capability_id}:{actionability}"),
        normalized_score_ppm=900_000,
        matching_signals=("python",),
        reason_codes=("graph-match",),
        actionability=actionability,
        install_descriptor_digest=(None if descriptor is None else descriptor.descriptor_digest),
        install_plan_digest=(None if descriptor is None else descriptor.plan_digest),
    )


def _install_bundle(capability_id: str, snapshot_digest: str) -> InstallPlanningBundle:
    kind = capability_id.split(":", 1)[0]
    material = MaterialIdentity.create(
        capability_id=capability_id,
        kind=kind,
        content_sha256=_digest(f"installed:{capability_id}"),
        content_bytes=64,
    )
    descriptor = InstallPlanDescriptor.create(
        capability_id=capability_id,
        kind=kind,
        installer_id=f"ctx-{kind}-installer-v1",
        plan_digest=_digest(f"install-plan:{capability_id}"),
        provenance_digest=snapshot_digest,
        result_material_identity_digest=material.identity_digest,
    )
    return InstallPlanningBundle(descriptor=descriptor, result_material=material)


@dataclass
class _Facts:
    benefit_facts_snapshot_digest: str = field(
        default_factory=lambda: _digest("managed-benefit-facts")
    )
    calls: list[str] = field(default_factory=list)

    def benefit_candidate(
        self,
        presentation: CapabilityCandidate,
        _observation: WorkObservation,
    ) -> BenefitCandidate:
        self.calls.append(presentation.capability_id)
        return BenefitCandidate(
            capability_id=presentation.capability_id,
            source_digest=presentation.source_digest,
            resource_profile_digest=_digest(f"profile:{presentation.capability_id}"),
            availability=("advisory" if presentation.actionability == "manual" else "executable"),
            expected_task_benefit_ppm=800_000,
            relevance_ppm=900_000,
            trust_ppm=1_000_000,
            costs=ResourceCosts(),
            evidence=EvidenceSummary(
                capability_id=presentation.capability_id,
                kind=presentation.kind,
                source_digest=presentation.source_digest,
                evidence_window_digest=_digest(f"window:{presentation.capability_id}"),
                opportunity_observable=False,
            ),
            source_trusted=True,
            security_approved=True,
            permissions_allowed=True,
            credentials_available=True,
        )


@dataclass
class _MaterialAuthority:
    capability_ids: set[str]
    material_snapshot_digest: str = field(default_factory=lambda: _digest("material-snapshot"))

    def describe(self, capability_id: str, kind: str) -> MaterialDescriptor:
        if capability_id not in self.capability_ids:
            return MaterialDescriptor.create(
                capability_id=capability_id,
                kind=kind,
                actionability="manual",
                content_sha256=None,
                content_bytes=0,
                estimated_tokens=0,
                provenance_digest=self.material_snapshot_digest,
                material_identity_digest=None,
            )
        identity = MaterialIdentity.create(
            capability_id=capability_id,
            kind=kind,
            content_sha256=_digest(f"content:{capability_id}"),
            content_bytes=64,
        )
        return MaterialDescriptor.create(
            capability_id=capability_id,
            kind=kind,
            actionability="load",
            content_sha256=identity.content_sha256,
            content_bytes=identity.content_bytes,
            estimated_tokens=16,
            provenance_digest=self.material_snapshot_digest,
            material_identity_digest=identity.identity_digest,
        )

    def prepare(self, *_args: object, **_kwargs: object) -> object:
        raise AssertionError("managed planning must not prepare material")


@dataclass
class _InstallAuthority:
    installation_snapshot_digest: str
    bundles: dict[str, InstallPlanningBundle | None]

    def describe(self, capability_id: str, _kind: str) -> InstallPlanDescriptor | None:
        bundle = self.bundles.get(capability_id)
        return None if bundle is None else bundle.descriptor

    def describe_bundle(self, capability_id: str, _kind: str) -> InstallPlanningBundle | None:
        return self.bundles.get(capability_id)

    def prepare(
        self,
        _action: HostAction,
        _selection: CapabilitySelection,
        _descriptor: InstallPlanDescriptor,
        *,
        expected_catalog_snapshot_digest: str,
        expected_policy_digest: str,
        authority: InstallAuthorizer | None = None,
    ) -> PreparedInstallPlan:
        del expected_catalog_snapshot_digest, expected_policy_digest, authority
        raise AssertionError("candidate retrieval must not prepare an install plan")


def _normalizer(requested_limit: int):
    def normalize(
        _reference: ObservationReference,
        _state: EngineState | None,
    ) -> StructuredSurrogate:
        return StructuredSurrogate.create(
            schema_id="ctx.observation.current-work",
            schema_version=1,
            value={
                "signals": ["python"],
                "languages": ["python"],
                "baseline_capability_ids": [],
                "active_capability_ids": [],
                "rejected_capability_ids": [],
                "requested_limit": requested_limit,
            },
        )

    return normalize


def _composition(
    tmp_path: Path,
    *,
    candidates: tuple[CapabilityCandidate, ...],
    requested_limit: int = 5,
    material_authority: _MaterialAuthority | None = None,
    install_authority: _InstallAuthority | None = None,
    facts: _Facts | None = None,
    observation_normalizer: ObservationNormalizer | None = None,
    interactive_install_decision_guard: object | None = None,
    trusted_utc_now: object | None = None,
    suffix: str = "one",
) -> EngineComposition:
    graph = nx.Graph()
    for candidate in candidates:
        graph.add_node(
            candidate.capability_id,
            label=candidate.name,
            type=candidate.kind,
            tags=["python"],
        )
    graph_path = tmp_path / f"managed-{suffix}-graph.sqlite3"
    if not graph_path.exists():
        build_graph_store(graph_path, graph)
        graph_path.chmod(0o444)
    return open_engine_composition(
        graph_artifact_path=graph_path,
        graph_artifact_sha256=hashlib.sha256(graph_path.read_bytes()).hexdigest(),
        journal_path=tmp_path / f"managed-{suffix}.sqlite3",
        observation_normalizer=(
            _normalizer(requested_limit)
            if observation_normalizer is None
            else observation_normalizer
        ),
        benefit_facts_port=_Facts() if facts is None else facts,
        net_benefit_policy=NetBenefitPolicy(
            calibration_digest=_digest("calibration"),
            minimum_relevance_ppm=1,
        ),
        catalog_namespace_digest=CATALOG_NAMESPACE_DIGEST,
        benefit_audit_path=tmp_path / f"managed-{suffix}-audit.sqlite3",
        material_port=material_authority,  # type: ignore[arg-type]
        install_bundle_port=install_authority,
        planner_version="ctx-managed-query-planner-v3",
        interactive_install_decision_guard=interactive_install_decision_guard,  # type: ignore[arg-type]
        trusted_utc_now=trusted_utc_now,  # type: ignore[arg-type]
    )


def _event(
    composition: EngineComposition,
    *,
    kind: str,
    revision: int,
    suffix: str,
    payload: dict[str, object],
) -> EngineEvent:
    scope = _scope(suffix)
    return EngineEvent(
        event_id=f"event-{kind.lower()}-{suffix}",
        kind=kind,
        scope=scope,
        expected_revision=revision,
        occurred_at=NOW,
        payload=payload,
        correlation_id=f"plan-{suffix}",
        causation_id=f"cause-{suffix}",
        engine_version="ctx-engine-v1",
        planner_version=composition.planner_version,
        policy_version="policy-v1",
        host_descriptor_digest=_digest("host-neutral-managing"),
        catalog_snapshot_digest=composition.catalog_snapshot_digest,
        semantic_model_digest=_digest("semantic-disabled"),
        semantic_index_digest=_digest("semantic-index-disabled"),
        work_signature=_digest(f"work:{suffix}"),
        random_seed=0,
    )


def _prepare(
    composition: EngineComposition,
    *,
    suffix: str,
) -> PreparedManagedQuery:
    return prepare_managed_query(
        composition=composition,
        session_started=_event(
            composition,
            kind="SessionStarted",
            revision=0,
            suffix=suffix,
            payload={"host_level": "managing"},
        ),
        intent_observed=_event(
            composition,
            kind="IntentObserved",
            revision=1,
            suffix=suffix,
            payload={
                "observation_ref": {
                    "provider_id": "managed-query-test",
                    "opaque_id": f"observation-{suffix}",
                    "content_digest": _digest(f"work:{suffix}"),
                }
            },
        ),
    )


def _managed_events(
    composition: EngineComposition,
    *,
    suffix: str,
) -> tuple[EngineEvent, EngineEvent]:
    return (
        _event(
            composition,
            kind="SessionStarted",
            revision=0,
            suffix=suffix,
            payload={"host_level": "managing"},
        ),
        _event(
            composition,
            kind="IntentObserved",
            revision=1,
            suffix=suffix,
            payload={
                "observation_ref": {
                    "provider_id": "managed-query-test",
                    "opaque_id": f"observation-{suffix}",
                    "content_digest": _digest(f"work:{suffix}"),
                }
            },
        ),
    )


def _development_event(
    initial_intent: EngineEvent,
    *,
    revision: int,
    attempt: str,
    scope: ScopeRef | None = None,
) -> EngineEvent:
    return replace(
        initial_intent,
        event_id=f"event-developmentobserved-{attempt}",
        kind="DevelopmentObserved",
        scope=initial_intent.scope if scope is None else scope,
        expected_revision=revision,
        payload={
            "observation_ref": {
                "provider_id": "managed-query-test",
                "opaque_id": f"observation-{attempt}",
                "content_digest": _digest(f"work:{attempt}"),
            }
        },
        correlation_id=f"plan-{attempt}",
        causation_id=f"cause-{attempt}",
        work_signature=_digest(f"work:{attempt}"),
    )


def _projection_fields(prepared: PreparedManagedQuery) -> tuple[object, ...]:
    return (
        prepared.status,
        prepared.abstention_code,
        prepared.plan_id,
        prepared.planning_environment_digest,
        prepared.decision_digest,
        prepared.journal_revision,
        prepared.journal_record_digest,
        prepared.benefit_result_digest,
        prepared.requested_limit,
        prepared.candidate_pool_count,
        prepared.search_evaluation_count,
        tuple(
            (
                item.capability_id,
                item.kind,
                item.name,
                item.actionability,
                item.matching_signals,
                item.reason_codes,
                item.benefit_tier,
                item.individual_net_benefit_u,
                item.marginal_net_benefit_u,
                item.source_digest,
                item.catalog_identity_digest,
                item.install_descriptor_digest,
                item.install_plan_digest,
            )
            for item in prepared.selections
        ),
    )


def _explanatory_fields(prepared: PreparedManagedQuery) -> tuple[object, ...]:
    fields = _projection_fields(prepared)
    return (*fields[:5], *fields[7:])


def _snapshot_at_revision(
    snapshot: EngineSnapshot,
    revision: int,
    *,
    record_digest: str | None = None,
    committed_plan: CommittedPlanV3 | None = None,
) -> EngineSnapshot:
    assert snapshot.state is not None
    state = replace(
        snapshot.state,
        revision=revision,
        committed_plan=(
            snapshot.state.committed_plan if committed_plan is None else committed_plan
        ),
    )
    return EngineSnapshot(
        stream_id=snapshot.stream_id,
        revision=revision,
        state=state,
        record_digest=record_digest or _digest(f"record:{revision}"),
    )


def test_one_committed_plan_globally_bounds_four_competing_types(tmp_path: Path) -> None:
    candidates = tuple(
        _candidate(capability_id, actionability="manual")
        for capability_id in (
            "agent:reviewer",
            "harness:python-runner",
            "mcp-server:docs",
            "skill:lint",
            "skill:test",
            "skill:types",
        )
    )
    with _composition(tmp_path, candidates=candidates, suffix="bounded") as composition:
        prepared = _prepare(composition, suffix="bounded")
        snapshot = composition.snapshot(_scope("bounded"))

    assert prepared.status == "ready"
    assert len(prepared.selections) == 5
    assert {item.kind for item in prepared.selections} == {
        "skill",
        "agent",
        "mcp-server",
        "harness",
    }
    assert prepared.benefit_result_digest is not None
    assert all(item.name for item in prepared.selections)
    assert all("python" in item.matching_signals for item in prepared.selections)
    assert all("graph-match" in item.reason_codes for item in prepared.selections)
    assert all(item.marginal_net_benefit_u > 0 for item in prepared.selections)
    assert snapshot.state is not None
    committed = snapshot.state.committed_plan
    assert isinstance(committed, CommittedPlanV3)
    assert (
        prepared.plan_id,
        prepared.planning_environment_digest,
        prepared.decision_digest,
        prepared.benefit_result_digest,
        prepared.journal_revision,
        prepared.journal_record_digest,
    ) == (
        committed.plan_id,
        committed.catalog_snapshot_id,
        committed.decision_digest,
        committed.benefit_audit.result_digest if committed.benefit_audit else None,
        snapshot.revision,
        snapshot.record_digest,
    )
    assert tuple(item.capability_id for item in prepared.selections) == tuple(
        item.capability_id for item in committed.capabilities
    )
    assert tuple(
        (
            item.name,
            item.matching_signals,
            item.reason_codes,
            item.benefit_tier,
            item.individual_net_benefit_u,
            item.marginal_net_benefit_u,
        )
        for item in prepared.selections
    ) == tuple(
        (
            item.name,
            item.selection.presentation.matching_signals,
            item.selection.presentation.reason_codes,
            item.benefit.tier,
            item.benefit.individual_net_benefit_u,
            item.benefit.marginal_net_benefit_u,
        )
        for item in committed.capabilities
    )


def test_zero_limit_is_one_audited_abstention(tmp_path: Path) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(
        tmp_path,
        candidates=candidates,
        requested_limit=0,
        suffix="zero",
    ) as composition:
        prepared = _prepare(composition, suffix="zero")

    assert prepared.status == "abstained"
    assert prepared.abstention_code == "limit-zero"
    assert prepared.selections == ()
    assert prepared.benefit_result_digest is not None


def test_mixed_projection_uses_existing_typed_authority_without_reranking(
    tmp_path: Path,
) -> None:
    installation_snapshot = _digest("mixed-installation")
    candidates = (
        _candidate("skill:loaded", actionability="load"),
        _candidate(
            "agent:installer",
            actionability="install",
            installation_snapshot_digest=installation_snapshot,
        ),
        _candidate("mcp-server:manual-docs", actionability="manual"),
        _candidate("harness:manual-runner", actionability="manual"),
    )
    load_candidate = candidates[0]
    install_bundle = _install_bundle("agent:installer", installation_snapshot)
    with _composition(
        tmp_path,
        candidates=candidates,
        material_authority=_MaterialAuthority(
            capability_ids={load_candidate.capability_id},
        ),
        install_authority=_InstallAuthority(
            installation_snapshot_digest=installation_snapshot,
            bundles={install_bundle.descriptor.capability_id: install_bundle},
        ),
        suffix="mixed",
    ) as composition:
        prepared = _prepare(composition, suffix="mixed")

    assert tuple(
        (item.capability_id, item.kind, item.actionability) for item in prepared.selections
    ) == (
        ("agent:installer", "agent", "install"),
        ("skill:loaded", "skill", "load"),
        ("harness:manual-runner", "harness", "manual"),
        ("mcp-server:manual-docs", "mcp-server", "manual"),
    )


def test_graph_uninstalled_row_requires_exact_install_authority(tmp_path: Path) -> None:
    installation_snapshot = _digest("graph-installation")
    agent_bundle = _install_bundle("agent:reviewer", installation_snapshot)
    install_authority = _InstallAuthority(
        installation_snapshot_digest=installation_snapshot,
        bundles={"agent:reviewer": agent_bundle, "mcp-server:docs": None},
    )
    candidates = (
        _candidate(
            "agent:reviewer",
            actionability="install",
            installation_snapshot_digest=installation_snapshot,
        ),
        _candidate("mcp-server:docs", actionability="manual"),
    )
    with _composition(
        tmp_path,
        candidates=candidates,
        install_authority=install_authority,
        suffix="graph",
    ) as composition:
        prepared = _prepare(composition, suffix="graph")

    projected = {item.capability_id: item.actionability for item in prepared.selections}
    assert projected == {"agent:reviewer": "install", "mcp-server:docs": "manual"}


def test_prepared_projection_is_factory_issued_immutable_and_nonserializable(
    tmp_path: Path,
) -> None:
    with pytest.raises(TypeError, match="trusted production composition"):
        EngineComposition()
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(
        tmp_path,
        candidates=candidates,
        suffix="sealed",
    ) as composition:
        prepared = _prepare(composition, suffix="sealed")
        with pytest.raises(AttributeError, match="immutable"):
            composition._engine = object()  # type: ignore[assignment,attr-defined,misc]
        with pytest.raises(TypeError, match="copied"):
            copy.copy(composition)
        with pytest.raises(TypeError, match="serialized"):
            pickle.dumps(composition)

    with pytest.raises(TypeError, match="factory"):
        PreparedManagedQuery()  # type: ignore[call-arg]
    with pytest.raises((FrozenInstanceError, AttributeError)):
        prepared.status = "abstained"  # type: ignore[misc]
    with pytest.raises(TypeError, match="copied"):
        copy.copy(prepared)
    with pytest.raises(TypeError, match="copied"):
        copy.deepcopy(prepared)
    with pytest.raises(TypeError, match="serialized"):
        pickle.dumps(prepared)
    assert not hasattr(prepared, "to_dict")
    assert not hasattr(prepared, "__dict__")
    assert all(not hasattr(item, "__dict__") for item in prepared.selections)
    representation = repr(prepared)
    assert prepared.decision_digest in representation
    assert "prompt" not in representation
    assert str(tmp_path) not in representation
    assert "credential" not in representation


def test_snapshot_projection_reopens_revision_two_and_later_heads_without_live_authority(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(tmp_path, candidates=candidates, suffix="snapshot") as composition:
        prepared = _prepare(composition, suffix="snapshot")
        committed_snapshot = composition.snapshot(_scope("snapshot"))

    reopened = _project_prepared_managed_query_snapshot(
        snapshot=committed_snapshot,
        expected_plan_id=prepared.plan_id,
    )
    assert _projection_fields(reopened) == _projection_fields(prepared)

    later_snapshot = _snapshot_at_revision(committed_snapshot, 7)
    later = _project_prepared_managed_query_snapshot(
        snapshot=later_snapshot,
        expected_plan_id=prepared.plan_id,
    )
    assert _projection_fields(later) == (
        *_projection_fields(prepared)[:5],
        7,
        _digest("record:7"),
        *_projection_fields(prepared)[7:],
    )
    with pytest.raises(AttributeError, match="immutable"):
        later.journal_revision = 8  # type: ignore[misc]
    with pytest.raises(TypeError, match="copied"):
        copy.deepcopy(later)
    with pytest.raises(TypeError, match="serialized"):
        pickle.dumps(later)


def test_snapshot_projection_preserves_exact_degraded_plan_without_authority(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(tmp_path, candidates=candidates, suffix="degraded") as composition:
        _prepare(composition, suffix="degraded")
        committed_snapshot = composition.snapshot(_scope("degraded"))
        catalog_snapshot_digest = composition.catalog_snapshot_digest
    assert committed_snapshot.state is not None
    degraded = CommittedPlanV3(
        plan_id="plan-degraded-reopen",
        catalog_snapshot_id=catalog_snapshot_digest,
        decision_digest=_digest("degraded-decision"),
        status="degraded",
        abstention_code="planner-failed",
        benefit_audit=None,
        capabilities=(),
    )
    degraded_state = replace(
        committed_snapshot.state,
        revision=4,
        committed_plan=degraded,
        last_manual_bundle=(),
    )
    degraded_snapshot = EngineSnapshot(
        stream_id=committed_snapshot.stream_id,
        revision=4,
        state=degraded_state,
        record_digest=_digest("record:4"),
    )

    projected = _project_prepared_managed_query_snapshot(
        snapshot=degraded_snapshot,
        expected_plan_id=degraded.plan_id,
    )

    assert projected.status == "degraded"
    assert projected.abstention_code == "planner-failed"
    assert projected.plan_id == degraded.plan_id
    assert projected.journal_revision == 4
    assert projected.selections == ()
    assert projected.benefit_result_digest is None
    assert projected.requested_limit is None
    assert projected.candidate_pool_count is None
    assert projected.search_evaluation_count is None


@pytest.mark.parametrize("expected_plan_id", ["", "contains whitespace", 7])
def test_snapshot_projection_rejects_invalid_expected_plan_identity(
    tmp_path: Path,
    expected_plan_id: object,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(tmp_path, candidates=candidates, suffix="plan-identity") as composition:
        _prepare(composition, suffix="plan-identity")
        snapshot = composition.snapshot(_scope("plan-identity"))

    with pytest.raises((TypeError, ManagedQueryError), match="expected_plan_id"):
        _project_prepared_managed_query_snapshot(
            snapshot=snapshot,
            expected_plan_id=expected_plan_id,  # type: ignore[arg-type]
        )


def test_snapshot_projection_rejects_plan_substitution(tmp_path: Path) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(tmp_path, candidates=candidates, suffix="plan-match") as composition:
        prepared = _prepare(composition, suffix="plan-match")
        snapshot = composition.snapshot(_scope("plan-match"))

    with pytest.raises(ManagedQueryError, match="plan identity"):
        _project_prepared_managed_query_snapshot(
            snapshot=snapshot,
            expected_plan_id=f"{prepared.plan_id}-substituted",
        )


def test_snapshot_projection_rejects_absent_or_invalid_authoritative_state(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(tmp_path, candidates=candidates, suffix="invalid-head") as composition:
        _prepare(composition, suffix="invalid-head")
        snapshot = composition.snapshot(_scope("invalid-head"))
    assert snapshot.state is not None

    empty = EngineSnapshot(
        stream_id=snapshot.stream_id,
        revision=0,
        state=None,
        record_digest=None,
    )
    no_plan = EngineSnapshot(
        stream_id=snapshot.stream_id,
        revision=2,
        state=EngineState(
            revision=2,
            scope=snapshot.state.scope,
            host_level=snapshot.state.host_level,
            host_descriptor_digest=snapshot.state.host_descriptor_digest,
        ),
        record_digest=_digest("no-plan"),
    )
    invalid_digest = EngineSnapshot(
        stream_id=snapshot.stream_id,
        revision=2,
        state=snapshot.state,
        record_digest="not-a-digest",
    )
    invalid_state = object.__new__(EngineSnapshot)
    object.__setattr__(invalid_state, "stream_id", snapshot.stream_id)
    object.__setattr__(invalid_state, "revision", 2)
    object.__setattr__(invalid_state, "state", object())
    object.__setattr__(invalid_state, "record_digest", _digest("invalid-state"))
    object.__setattr__(invalid_state, "projection_repaired", False)
    wrong_stream = EngineSnapshot(
        stream_id=StreamId.from_scope(_scope("substituted-stream")),
        revision=snapshot.revision,
        state=snapshot.state,
        record_digest=snapshot.record_digest,
    )

    for candidate, message in (
        (empty, "revision"),
        (no_plan, "committed"),
        (invalid_digest, "journal_record_digest"),
        (invalid_state, "state"),
        (wrong_stream, "stream"),
    ):
        with pytest.raises((TypeError, ManagedQueryError), match=message):
            _project_prepared_managed_query_snapshot(snapshot=candidate)

    with pytest.raises(TypeError, match="EngineSnapshot"):
        _project_prepared_managed_query_snapshot(snapshot=object())  # type: ignore[arg-type]


def test_managed_advance_commits_revision_zero_and_resumes_revision_one(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)

    with _composition(tmp_path, candidates=candidates, suffix="advance-zero") as composition:
        session_started, intent_observed = _managed_events(
            composition,
            suffix="advance-zero",
        )
        advanced = advance_managed_query(
            composition=composition,
            session_started=session_started,
            planning_observed=intent_observed,
        )
        prepared = advanced.prepared
        assert advanced.transition.event_id == intent_observed.event_id
        assert prepared.journal_revision == 2
        assert prepared.plan_id == intent_observed.correlation_id

    with _composition(tmp_path, candidates=candidates, suffix="advance-one") as composition:
        session_started, intent_observed = _managed_events(
            composition,
            suffix="advance-one",
        )
        started = composition.process(session_started)
        assert started.to_revision == 1
        advanced = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        prepared = advanced.prepared
        assert advanced.transition.from_revision == 1
        assert prepared.journal_revision == 2
        assert prepared.plan_id == intent_observed.correlation_id


def test_managed_reopen_and_exact_advance_retry_are_planner_free(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    facts = _Facts()
    with _composition(
        tmp_path,
        candidates=candidates,
        facts=facts,
        suffix="reopen",
    ) as composition:
        session_started, intent_observed = _managed_events(composition, suffix="reopen")
        advanced = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        prepared = advanced.prepared
        facts.calls.clear()

        reopened = reopen_managed_query(
            composition=composition,
            scope=intent_observed.scope,
            expected_plan_id=prepared.plan_id,
        )
        retry = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        retried = retry.prepared

    assert facts.calls == []
    assert retry.transition == advanced.transition
    assert _projection_fields(reopened) == _projection_fields(prepared)
    assert _projection_fields(retried) == _projection_fields(prepared)


def test_managed_development_commits_latest_plan_across_later_stream_heads(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    facts = _Facts()
    with _composition(
        tmp_path,
        candidates=candidates,
        facts=facts,
        suffix="development",
    ) as composition:
        session_started, intent_observed = _managed_events(
            composition,
            suffix="development",
        )
        composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        child_scope = replace(
            intent_observed.scope,
            exposure_id="exposure-development-child",
            host_context_id="child-agent",
            parent_exposure_id=intent_observed.scope.exposure_id,
        )
        development = _development_event(
            intent_observed,
            revision=2,
            attempt="development-later",
            scope=child_scope,
        )

        advanced = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=development,
        )
        assert advanced.prepared.plan_id == development.correlation_id
        assert advanced.prepared.journal_revision == 3
        assert advanced.transition.from_revision == 2
        assert advanced.transition.to_revision == 3

        composition.process(
            replace(
                development,
                event_id="event-turnended-development-later",
                kind="TurnEnded",
                expected_revision=3,
                payload={},
            )
        )
        facts.calls.clear()
        reopened = composition.reopen_managed_query(
            child_scope,
            expected_plan_id=development.correlation_id,
        )
        retried = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=development,
        )

    assert facts.calls == []
    assert retried.transition == advanced.transition
    assert reopened.journal_revision == retried.prepared.journal_revision == 4
    assert _explanatory_fields(reopened) == _explanatory_fields(advanced.prepared)
    assert _explanatory_fields(retried.prepared) == _explanatory_fields(advanced.prepared)


def test_managed_advance_result_is_factory_issued_immutable_and_nonserializable(
    tmp_path: Path,
) -> None:
    with pytest.raises(TypeError, match="factory"):
        ManagedAdvanceResult()
    candidates = (_candidate("skill:test", actionability="manual"),)
    with _composition(tmp_path, candidates=candidates, suffix="advance-sealed") as composition:
        session_started, intent_observed = _managed_events(
            composition,
            suffix="advance-sealed",
        )
        result = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )

    with pytest.raises(AttributeError, match="immutable"):
        result.prepared = result.prepared  # type: ignore[misc]
    with pytest.raises(TypeError, match="copied"):
        copy.copy(result)
    with pytest.raises(TypeError, match="copied"):
        copy.deepcopy(result)
    with pytest.raises(TypeError, match="serialized"):
        pickle.dumps(result)
    assert not hasattr(result, "__dict__")


def test_managed_advance_rejects_changed_retry_and_stale_head_without_planning(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    facts = _Facts()
    with _composition(
        tmp_path,
        candidates=candidates,
        facts=facts,
        suffix="stale",
    ) as composition:
        session_started, intent_observed = _managed_events(composition, suffix="stale")
        composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        facts.calls.clear()
        before_collision = composition.snapshot(intent_observed.scope)
        with pytest.raises(EventIdCollision):
            composition.advance_managed_query(
                session_started=replace(
                    session_started,
                    payload={"host_level": "activating"},
                ),
                planning_observed=intent_observed,
            )
        changed_retry = replace(
            intent_observed,
            payload={
                "observation_ref": {
                    "provider_id": "managed-query-test",
                    "opaque_id": "observation-stale-substituted",
                    "content_digest": _digest("work:stale-substituted"),
                }
            },
        )
        with pytest.raises(EventIdCollision):
            composition.advance_managed_query(
                session_started=session_started,
                planning_observed=changed_retry,
            )
        assert composition.snapshot(intent_observed.scope) == before_collision
        assert facts.calls == []

        composition.process(
            replace(
                intent_observed,
                event_id="event-turnended-stale",
                kind="TurnEnded",
                expected_revision=2,
                payload={},
            )
        )
        stale_development = _development_event(
            intent_observed,
            revision=2,
            attempt="stale-development",
        )
        before_stale = composition.snapshot(intent_observed.scope)
        with pytest.raises(RevisionConflict) as captured:
            composition.advance_managed_query(
                session_started=session_started,
                planning_observed=stale_development,
            )
        assert composition.snapshot(intent_observed.scope) == before_stale

    assert captured.value.expected == 2
    assert captured.value.actual == 3
    assert facts.calls == []
    assert composition.closed
    assert before_stale.revision == 3


@pytest.mark.parametrize(
    ("binding", "message"),
    [
        ("kind", "IntentObserved"),
        ("stream", "stable stream"),
        ("catalog", "planning environment"),
        ("planner", "planner"),
        ("host", "host_descriptor_digest"),
        ("semantic-model", "semantic_model_digest"),
        ("semantic-index", "semantic_index_digest"),
        ("plan", "plan and work identity"),
        ("work", "plan and work identity"),
    ],
)
def test_managed_advance_rejects_substituted_event_identity_before_start(
    tmp_path: Path,
    binding: str,
    message: str,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    facts = _Facts()
    with _composition(
        tmp_path,
        candidates=candidates,
        facts=facts,
        suffix=f"identity-{binding}",
    ) as composition:
        session_started, intent_observed = _managed_events(
            composition,
            suffix=f"identity-{binding}",
        )
        if binding == "kind":
            intent_observed = replace(intent_observed, kind="DevelopmentObserved")
        elif binding == "stream":
            intent_observed = replace(intent_observed, scope=_scope("foreign-stream"))
        elif binding == "catalog":
            intent_observed = replace(
                intent_observed,
                catalog_snapshot_digest=_digest("foreign-catalog"),
            )
        elif binding == "planner":
            intent_observed = replace(intent_observed, planner_version="foreign-planner")
        elif binding == "host":
            intent_observed = replace(
                intent_observed,
                host_descriptor_digest=_digest("foreign-host"),
            )
        elif binding == "semantic-model":
            intent_observed = replace(
                intent_observed,
                semantic_model_digest=_digest("foreign-semantic-model"),
            )
        elif binding == "semantic-index":
            intent_observed = replace(
                intent_observed,
                semantic_index_digest=_digest("foreign-semantic-index"),
            )
        elif binding == "plan":
            intent_observed = replace(intent_observed, correlation_id="plan-foreign")
        else:
            intent_observed = replace(
                intent_observed,
                work_signature=_digest("foreign-work"),
            )

        before = composition.snapshot(session_started.scope)
        with pytest.raises(ManagedQueryError, match=message):
            composition.advance_managed_query(
                session_started=session_started,
                planning_observed=intent_observed,
            )
        assert composition.snapshot(session_started.scope) == before

    assert facts.calls == []


def test_managed_advance_rejects_pending_consent_and_effect_before_planning(
    tmp_path: Path,
) -> None:
    capability_id = "skill:pending"
    installation_snapshot = _digest("pending-installation")
    bundle = _install_bundle(capability_id, installation_snapshot)
    candidates = (
        _candidate(
            capability_id,
            actionability="install",
            installation_snapshot_digest=installation_snapshot,
        ),
    )
    facts = _Facts()
    with _composition(
        tmp_path,
        candidates=candidates,
        install_authority=_InstallAuthority(
            installation_snapshot_digest=installation_snapshot,
            bundles={capability_id: bundle},
        ),
        facts=facts,
        interactive_install_decision_guard=lambda _reservation: nullcontext(),
        trusted_utc_now=lambda: datetime(2026, 8, 2, 12, 1, tzinfo=UTC),
        suffix="pending",
    ) as composition:
        session_started, intent_observed = _managed_events(composition, suffix="pending")
        composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        snapshot = composition.snapshot(intent_observed.scope)
        assert snapshot.state is not None
        committed = snapshot.state.committed_plan
        assert isinstance(committed, CommittedPlanV3)
        capability = committed.capabilities[0]
        desired = composition.process(
            replace(
                intent_observed,
                event_id="event-pending-desired",
                kind="ReassessmentRequested",
                expected_revision=2,
                payload={
                    "owner_id": "owner-pending",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "desired_capabilities": [
                        {
                            "capability_id": capability.capability_id,
                            "source_digest": capability.source_digest,
                            "kind": capability.kind,
                            "actionability": capability.actionability,
                            "install_descriptor_digest": capability.install_descriptor_digest,
                            "install_plan_digest": capability.install_plan_digest,
                            "lease_id": "lease-pending",
                        }
                    ],
                },
            )
        )
        request = desired.actions[0]
        assert request.kind == "RequestConsent"
        facts.calls.clear()
        pending_consent = composition.snapshot(intent_observed.scope)
        with pytest.raises(ManagedQueryError, match="settle pending authority"):
            composition.advance_managed_query(
                session_started=session_started,
                planning_observed=_development_event(
                    intent_observed,
                    revision=3,
                    attempt="pending-consent",
                ),
            )
        assert composition.snapshot(intent_observed.scope) == pending_consent
        assert facts.calls == []

        granted = composition.process(
            replace(
                intent_observed,
                event_id="event-pending-consent-granted",
                kind="UserDecision",
                expected_revision=3,
                payload={
                    "consent_id": request.consent_id,
                    "decision": "granted",
                    "decision_basis": "interactive",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "requested_action_id": request.payload["requested_action_id"],
                    "requested_action_kind": request.payload["requested_action_kind"],
                    "requested_action_content_digest": request.payload[
                        "requested_action_content_digest"
                    ],
                    "requested_action_precondition_revision": request.payload[
                        "requested_action_precondition_revision"
                    ],
                },
            )
        )
        assert granted.actions[0].kind == "InstallCapability"
        pending_effect = composition.snapshot(intent_observed.scope)
        with pytest.raises(ManagedQueryError, match="settle pending authority"):
            composition.advance_managed_query(
                session_started=session_started,
                planning_observed=_development_event(
                    intent_observed,
                    revision=4,
                    attempt="pending-effect",
                ),
            )
        assert composition.snapshot(intent_observed.scope) == pending_effect

    assert facts.calls == []


def test_managed_advance_rejects_ended_session_but_reopen_remains_available(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    facts = _Facts()
    with _composition(
        tmp_path,
        candidates=candidates,
        facts=facts,
        suffix="ended",
    ) as composition:
        session_started, intent_observed = _managed_events(composition, suffix="ended")
        initial = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        composition.process(
            replace(
                intent_observed,
                event_id="event-sessionended-ended",
                kind="SessionEnded",
                expected_revision=2,
                payload={},
            )
        )
        facts.calls.clear()
        reopened = composition.reopen_managed_query(
            intent_observed.scope,
            expected_plan_id=initial.prepared.plan_id,
        )
        ended = composition.snapshot(intent_observed.scope)
        with pytest.raises(ManagedQueryError, match="session has ended"):
            composition.advance_managed_query(
                session_started=session_started,
                planning_observed=_development_event(
                    intent_observed,
                    revision=3,
                    attempt="ended-later",
                ),
            )
        assert composition.snapshot(intent_observed.scope) == ended

    assert reopened.journal_revision == 3
    assert _explanatory_fields(reopened) == _explanatory_fields(initial.prepared)
    assert facts.calls == []


def test_concurrent_managed_development_attempts_commit_exactly_one_winner(
    tmp_path: Path,
) -> None:
    candidates = (_candidate("skill:test", actionability="manual"),)
    barrier = Barrier(2)
    base_normalizer = _normalizer(5)

    def racing_normalizer(
        reference: ObservationReference,
        state: EngineState | None,
    ) -> StructuredSurrogate:
        if reference.opaque_id in {
            "observation-race-first",
            "observation-race-second",
        }:
            barrier.wait(timeout=5)
        return base_normalizer(reference, state)

    first = _composition(
        tmp_path,
        candidates=candidates,
        observation_normalizer=racing_normalizer,
        suffix="race",
    )
    second = _composition(
        tmp_path,
        candidates=candidates,
        observation_normalizer=racing_normalizer,
        suffix="race",
    )
    with first, second:
        session_started, intent_observed = _managed_events(first, suffix="race")
        first.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        attempts = (
            _development_event(
                intent_observed,
                revision=2,
                attempt="race-first",
            ),
            _development_event(
                intent_observed,
                revision=2,
                attempt="race-second",
            ),
        )
        with ThreadPoolExecutor(max_workers=2) as executor:
            futures = tuple(
                executor.submit(
                    composition.advance_managed_query,
                    session_started=session_started,
                    planning_observed=attempt,
                )
                for composition, attempt in zip((first, second), attempts, strict=True)
            )
            results: list[ManagedAdvanceResult] = []
            errors: list[BaseException] = []
            for future in futures:
                try:
                    results.append(future.result(timeout=10))
                except BaseException as exc:
                    errors.append(exc)

        assert len(results) == 1, errors
        assert len(errors) == 1
        assert isinstance(errors[0], RevisionConflict)
        winner = results[0]
        latest = first.reopen_managed_query(
            intent_observed.scope,
            expected_plan_id=winner.prepared.plan_id,
        )
        snapshot = first.snapshot(intent_observed.scope)

    assert latest.plan_id == winner.prepared.plan_id
    assert snapshot.revision == 3


def test_managed_development_preserves_exact_lifecycle_transition_on_retry(
    tmp_path: Path,
) -> None:
    capability_id = "skill:installed"
    installation_snapshot = _digest("lifecycle-installation")
    bundle = _install_bundle(capability_id, installation_snapshot)
    candidates = (
        _candidate(
            capability_id,
            actionability="install",
            installation_snapshot_digest=installation_snapshot,
        ),
    )
    facts = _Facts()
    initial_normalizer = _normalizer(5)
    abstaining_normalizer = _normalizer(0)

    def phase_normalizer(
        reference: ObservationReference,
        state: EngineState | None,
    ) -> StructuredSurrogate:
        normalizer = (
            abstaining_normalizer
            if reference.opaque_id == "observation-lifecycle-later"
            else initial_normalizer
        )
        return normalizer(reference, state)

    with _composition(
        tmp_path,
        candidates=candidates,
        install_authority=_InstallAuthority(
            installation_snapshot_digest=installation_snapshot,
            bundles={capability_id: bundle},
        ),
        facts=facts,
        observation_normalizer=phase_normalizer,
        interactive_install_decision_guard=lambda _reservation: nullcontext(),
        trusted_utc_now=lambda: datetime(2026, 8, 2, 12, 1, tzinfo=UTC),
        suffix="lifecycle",
    ) as composition:
        session_started, intent_observed = _managed_events(
            composition,
            suffix="lifecycle",
        )
        composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        snapshot = composition.snapshot(intent_observed.scope)
        assert snapshot.state is not None
        committed = snapshot.state.committed_plan
        assert isinstance(committed, CommittedPlanV3)
        capability = committed.capabilities[0]
        desired = composition.process(
            replace(
                intent_observed,
                event_id="event-lifecycle-desired",
                kind="ReassessmentRequested",
                expected_revision=2,
                payload={
                    "owner_id": "owner-lifecycle",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "desired_capabilities": [
                        {
                            "capability_id": capability.capability_id,
                            "source_digest": capability.source_digest,
                            "kind": capability.kind,
                            "actionability": capability.actionability,
                            "install_descriptor_digest": capability.install_descriptor_digest,
                            "install_plan_digest": capability.install_plan_digest,
                            "lease_id": "lease-lifecycle",
                        }
                    ],
                },
            )
        )
        request = desired.actions[0]
        assert request.kind == "RequestConsent"
        granted = composition.process(
            replace(
                intent_observed,
                event_id="event-lifecycle-consent-granted",
                kind="UserDecision",
                expected_revision=3,
                payload={
                    "consent_id": request.consent_id,
                    "decision": "granted",
                    "decision_basis": "interactive",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "requested_action_id": request.payload["requested_action_id"],
                    "requested_action_kind": request.payload["requested_action_kind"],
                    "requested_action_content_digest": request.payload[
                        "requested_action_content_digest"
                    ],
                    "requested_action_precondition_revision": request.payload[
                        "requested_action_precondition_revision"
                    ],
                },
            )
        )
        install = granted.actions[0]
        assert install.kind == "InstallCapability"
        binding = InstallExecutionBinding(
            driver_id=bundle.descriptor.installer_id,
            driver_digest=install.payload["installer_digest"],  # type: ignore[arg-type]
            host_identity_digest=_digest("managed-query-host"),
            target_identity_digest=_digest("managed-query-target"),
        )
        engine = composition._engine  # noqa: SLF001 - exact coordinator settlement seam.
        engine.authorize_install(
            install,
            capability.selection,
            bundle.descriptor,
            expected_catalog_snapshot_digest=composition.catalog_snapshot_digest,
            expected_policy_digest=InstallConsentPolicy.safe_default().policy_digest,
            execution_binding=binding,
        )
        install_guard = engine._record_install_outcome(  # noqa: SLF001
            install,
            execution_binding=binding,
            execution_authority=engine._issue_install_outcome_permit(  # noqa: SLF001
                install,
                binding,
            ),
            outcome="applied",
            observed_material_identity_digest=bundle.result_material.identity_digest,
            verification_digest=_digest("managed-query-install-observation"),
        )
        install_status = engine.install_execution_status(install)
        assert install_status.observed_at is not None
        install_receipt = replace(
            intent_observed,
            event_id="event-lifecycle-install-applied",
            kind="ActionApplied",
            expected_revision=4,
            occurred_at=install_status.observed_at,
            payload={
                "action_id": install.action_id,
                "action_kind": install.kind,
                "action_content_digest": install.content_digest,
                "action_precondition_revision": install.precondition_revision,
                "verification": {
                    "schema": INSTALL_RECEIPT_SCHEMA_V3,
                    "host_state": "installed",
                    "capability_id": install.entity_id,
                    "capability_kind": install.payload["capability_kind"],
                    "catalog_identity": install.payload["catalog_identity"],
                    "material_identity": install.payload["result_material"],
                    "install_plan_descriptor": install.payload["install_plan_descriptor"],
                    "installer_digest": install.payload["installer_digest"],
                    "policy_snapshot_digest": install.payload["policy_snapshot_digest"],
                },
            },
        )
        installed = engine.process_install_receipt(install_receipt, install_guard)
        activation = installed.actions[0]
        assert activation.kind == "ActivateCapability"
        applied = composition.execute_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
            verification_digest=_digest("managed-query-activation-observation"),
        )
        assert applied.outcome == "applied"
        assert applied.settled is True
        assert applied.claim_was_new is True
        # Re-entry after a settled activation is idempotent: no new claim, no
        # journal advance, and no fresh receipt transition.
        head_after_activation = composition.snapshot(intent_observed.scope).revision
        replayed = composition.execute_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
            verification_digest=_digest("managed-query-activation-observation"),
        )
        assert replayed.outcome == "applied"
        assert replayed.settled is True
        assert replayed.claim_was_new is False
        assert replayed.transition is None
        assert composition.snapshot(intent_observed.scope).revision == head_after_activation
        development = _development_event(
            intent_observed,
            revision=6,
            attempt="lifecycle-later",
        )

        advanced = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=development,
        )
        facts.calls.clear()
        retried = composition.advance_managed_query(
            session_started=session_started,
            planning_observed=development,
        )

    assert advanced.prepared.status == "abstained"
    assert [action.kind for action in advanced.transition.actions] == ["DeactivateCapability"]
    assert retried.transition == advanced.transition
    assert facts.calls == []


@contextmanager
def _pending_activation_composition(tmp_path: Path, *, suffix: str):
    """Yield a composition holding one installed-inactive skill with a pending
    ``ActivateCapability`` action, plus the exact action and execution binding."""

    capability_id = "skill:installed"
    installation_snapshot = _digest(f"{suffix}-installation")
    bundle = _install_bundle(capability_id, installation_snapshot)
    candidates = (
        _candidate(
            capability_id,
            actionability="install",
            installation_snapshot_digest=installation_snapshot,
        ),
    )
    with _composition(
        tmp_path,
        candidates=candidates,
        install_authority=_InstallAuthority(
            installation_snapshot_digest=installation_snapshot,
            bundles={capability_id: bundle},
        ),
        facts=_Facts(),
        observation_normalizer=_normalizer(5),
        interactive_install_decision_guard=lambda _reservation: nullcontext(),
        trusted_utc_now=lambda: datetime(2026, 8, 2, 12, 1, tzinfo=UTC),
        suffix=suffix,
    ) as composition:
        session_started, intent_observed = _managed_events(composition, suffix=suffix)
        composition.advance_managed_query(
            session_started=session_started,
            planning_observed=intent_observed,
        )
        snapshot = composition.snapshot(intent_observed.scope)
        assert snapshot.state is not None
        committed = snapshot.state.committed_plan
        assert isinstance(committed, CommittedPlanV3)
        capability = committed.capabilities[0]
        desired = composition.process(
            replace(
                intent_observed,
                event_id=f"event-{suffix}-desired",
                kind="ReassessmentRequested",
                expected_revision=2,
                payload={
                    "owner_id": f"owner-{suffix}",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "desired_capabilities": [
                        {
                            "capability_id": capability.capability_id,
                            "source_digest": capability.source_digest,
                            "kind": capability.kind,
                            "actionability": capability.actionability,
                            "install_descriptor_digest": capability.install_descriptor_digest,
                            "install_plan_digest": capability.install_plan_digest,
                            "lease_id": f"lease-{suffix}",
                        }
                    ],
                },
            )
        )
        request = desired.actions[0]
        assert request.kind == "RequestConsent"
        granted = composition.process(
            replace(
                intent_observed,
                event_id=f"event-{suffix}-consent-granted",
                kind="UserDecision",
                expected_revision=3,
                payload={
                    "consent_id": request.consent_id,
                    "decision": "granted",
                    "decision_basis": "interactive",
                    "policy_snapshot_digest": InstallConsentPolicy.safe_default().policy_digest,
                    "requested_action_id": request.payload["requested_action_id"],
                    "requested_action_kind": request.payload["requested_action_kind"],
                    "requested_action_content_digest": request.payload[
                        "requested_action_content_digest"
                    ],
                    "requested_action_precondition_revision": request.payload[
                        "requested_action_precondition_revision"
                    ],
                },
            )
        )
        install = granted.actions[0]
        assert install.kind == "InstallCapability"
        binding = InstallExecutionBinding(
            driver_id=bundle.descriptor.installer_id,
            driver_digest=install.payload["installer_digest"],  # type: ignore[arg-type]
            host_identity_digest=_digest("managed-query-host"),
            target_identity_digest=_digest("managed-query-target"),
        )
        engine = composition._engine  # noqa: SLF001 - exact coordinator settlement seam.
        engine.authorize_install(
            install,
            capability.selection,
            bundle.descriptor,
            expected_catalog_snapshot_digest=composition.catalog_snapshot_digest,
            expected_policy_digest=InstallConsentPolicy.safe_default().policy_digest,
            execution_binding=binding,
        )
        install_guard = engine._record_install_outcome(  # noqa: SLF001
            install,
            execution_binding=binding,
            execution_authority=engine._issue_install_outcome_permit(install, binding),  # noqa: SLF001
            outcome="applied",
            observed_material_identity_digest=bundle.result_material.identity_digest,
            verification_digest=_digest("managed-query-install-observation"),
        )
        install_status = engine.install_execution_status(install)
        assert install_status.observed_at is not None
        install_receipt = replace(
            intent_observed,
            event_id=f"event-{suffix}-install-applied",
            kind="ActionApplied",
            expected_revision=4,
            occurred_at=install_status.observed_at,
            payload={
                "action_id": install.action_id,
                "action_kind": install.kind,
                "action_content_digest": install.content_digest,
                "action_precondition_revision": install.precondition_revision,
                "verification": {
                    "schema": INSTALL_RECEIPT_SCHEMA_V3,
                    "host_state": "installed",
                    "capability_id": install.entity_id,
                    "capability_kind": install.payload["capability_kind"],
                    "catalog_identity": install.payload["catalog_identity"],
                    "material_identity": install.payload["result_material"],
                    "install_plan_descriptor": install.payload["install_plan_descriptor"],
                    "installer_digest": install.payload["installer_digest"],
                    "policy_snapshot_digest": install.payload["policy_snapshot_digest"],
                },
            },
        )
        installed = engine.process_install_receipt(install_receipt, install_guard)
        activation = installed.actions[0]
        assert activation.kind == "ActivateCapability"
        yield composition, session_started, intent_observed, activation, binding


def _activation_observation() -> str:
    return _digest("managed-query-activation-observation")


def test_execute_activation_recovers_a_recorded_but_unsettled_outcome(tmp_path: Path) -> None:
    with _pending_activation_composition(tmp_path, suffix="rec-outcome") as (
        composition,
        session_started,
        intent_observed,
        activation,
        binding,
    ):
        engine = composition._engine  # noqa: SLF001 - crash-injection seam.
        # Simulate a crash after the durable outcome but before the receipt.
        engine.authorize_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
        )
        engine._record_activation_outcome(  # noqa: SLF001
            activation,
            execution_binding=binding,
            execution_authority=engine._issue_activation_outcome_permit(activation, binding),  # noqa: SLF001
            observed_material_identity_digest=activation.payload["material_identity"][  # type: ignore[index]
                "identity_digest"
            ],
            verification_digest=_activation_observation(),
        )
        status = engine.activation_execution_status(activation)
        assert status.outcome_recorded is True
        assert status.settled is False
        head_before = composition.snapshot(intent_observed.scope).revision

        report = composition.execute_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
            verification_digest=_activation_observation(),
        )

        assert report.outcome == "applied"
        assert report.settled is True
        assert report.claim_was_new is False
        assert report.transition is not None
        assert composition.snapshot(intent_observed.scope).revision == head_before + 1
        assert engine.activation_execution_status(activation).settled is True


def test_execute_activation_recovers_after_a_claim_without_outcome(tmp_path: Path) -> None:
    with _pending_activation_composition(tmp_path, suffix="rec-claim") as (
        composition,
        session_started,
        intent_observed,
        activation,
        binding,
    ):
        engine = composition._engine  # noqa: SLF001 - crash-injection seam.
        # Simulate a crash after the durable claim but before the outcome.
        engine.authorize_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
        )
        status = engine.activation_execution_status(activation)
        assert status.claimed is True
        assert status.outcome_recorded is False
        head_before = composition.snapshot(intent_observed.scope).revision

        report = composition.execute_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
            verification_digest=_activation_observation(),
        )

        assert report.outcome == "applied"
        assert report.settled is True
        assert report.claim_was_new is False
        assert composition.snapshot(intent_observed.scope).revision == head_before + 1


def test_execute_activation_tolerates_a_lost_claim_race(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    with _pending_activation_composition(tmp_path, suffix="race-claim") as (
        composition,
        session_started,
        intent_observed,
        activation,
        binding,
    ):
        engine = composition._engine  # noqa: SLF001 - race-injection seam.
        # A competing owner has already burned the exact one-use claim.
        engine.authorize_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
        )
        real_status = engine.activation_execution_status
        unclaimed = ActivationExecutionStatus(
            claimed=False,
            outcome_recorded=False,
            settled=False,
            execution_binding_digest=None,
            outcome_digest=None,
            observed_at=None,
        )
        calls = {"n": 0}

        def flaky_status(action: object) -> ActivationExecutionStatus:
            calls["n"] += 1
            if calls["n"] == 1:
                # Force execute_activation into the authorize branch even though
                # the claim already exists, so the ActivationActionAlreadyClaimed
                # catch and re-read path are exercised deterministically.
                return unclaimed
            return real_status(action)

        monkeypatch.setattr(engine, "activation_execution_status", flaky_status)

        report = composition.execute_activation(
            activation,
            execution_binding=binding,
            expected_host_descriptor_digest=session_started.host_descriptor_digest or "",
            verification_digest=_activation_observation(),
        )

        assert report.outcome == "applied"
        assert report.settled is True
        assert report.claim_was_new is False
        assert calls["n"] >= 2